feat: ionet integrate (#2105)

* wip ionet integrate

* wip ionet integrate

* wip ionet integrate

* ollama wip

* wip

* feat: ionet integration & ollama manage

* fix merge conflict

* wip

* fix: test conn cors

* wip

* fix ionet

* fix ionet

* wip

* fix model select

* refactor: Remove `pkg/ionet` test files and update related Go source and web UI model deployment components.

* feat: Enhance model deployment UI with styling improvements, updated text, and a new description component.

* Revert "feat: Enhance model deployment UI with styling improvements, updated text, and a new description component."

This reverts commit 8b75cb5bf0d1a534b339df8c033be9a6c7df7964.

.dockerignore

@@ -6,4 +6,5 @@
 Makefile
 docs
 .eslintcache
-.gocache
\ No newline at end of file
+.gocache
+/web/node_modules
\ No newline at end of file

.gitignore

@@ -23,4 +23,6 @@ web/bun.lock
 electron/node_modules
 electron/dist
 data/
-.gomodcache/
\ No newline at end of file
+.gomodcache/
+.gocache-temp
+.gopath

controller/channel.go

@@ -11,16 +11,18 @@ import (
 	"github.com/QuantumNous/new-api/constant"
 	"github.com/QuantumNous/new-api/dto"
 	"github.com/QuantumNous/new-api/model"
+	"github.com/QuantumNous/new-api/relay/channel/ollama"
 	"github.com/QuantumNous/new-api/service"
 
 	"github.com/gin-gonic/gin"
 )
 
 type OpenAIModel struct {
-	ID         string `json:"id"`
-	Object     string `json:"object"`
-	Created    int64  `json:"created"`
-	OwnedBy    string `json:"owned_by"`
+	ID         string         `json:"id"`
+	Object     string         `json:"object"`
+	Created    int64          `json:"created"`
+	OwnedBy    string         `json:"owned_by"`
+	Metadata   map[string]any `json:"metadata,omitempty"`
 	Permission []struct {
 		ID                 string `json:"id"`
 		Object             string `json:"object"`
@@ -207,6 +209,57 @@ func FetchUpstreamModels(c *gin.Context) {
 		baseURL = channel.GetBaseURL()
 	}
 
+	// 对于 Ollama 渠道，使用特殊处理
+	if channel.Type == constant.ChannelTypeOllama {
+		key := strings.Split(channel.Key, "\n")[0]
+		models, err := ollama.FetchOllamaModels(baseURL, key)
+		if err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"success": false,
+				"message": fmt.Sprintf("获取Ollama模型失败: %s", err.Error()),
+			})
+			return
+		}
+
+		result := OpenAIModelsResponse{
+			Data: make([]OpenAIModel, 0, len(models)),
+		}
+
+		for _, modelInfo := range models {
+			metadata := map[string]any{}
+			if modelInfo.Size > 0 {
+				metadata["size"] = modelInfo.Size
+			}
+			if modelInfo.Digest != "" {
+				metadata["digest"] = modelInfo.Digest
+			}
+			if modelInfo.ModifiedAt != "" {
+				metadata["modified_at"] = modelInfo.ModifiedAt
+			}
+			details := modelInfo.Details
+			if details.ParentModel != "" || details.Format != "" || details.Family != "" || len(details.Families) > 0 || details.ParameterSize != "" || details.QuantizationLevel != "" {
+				metadata["details"] = modelInfo.Details
+			}
+			if len(metadata) == 0 {
+				metadata = nil
+			}
+
+			result.Data = append(result.Data, OpenAIModel{
+				ID:       modelInfo.Name,
+				Object:   "model",
+				Created:  0,
+				OwnedBy:  "ollama",
+				Metadata: metadata,
+			})
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+			"data":    result.Data,
+		})
+		return
+	}
+
 	var url string
 	switch channel.Type {
 	case constant.ChannelTypeGemini:
@@ -975,6 +1028,32 @@ func FetchModels(c *gin.Context) {
 		baseURL = constant.ChannelBaseURLs[req.Type]
 	}
 
+	// remove line breaks and extra spaces.
+	key := strings.TrimSpace(req.Key)
+	key = strings.Split(key, "\n")[0]
+
+	if req.Type == constant.ChannelTypeOllama {
+		models, err := ollama.FetchOllamaModels(baseURL, key)
+		if err != nil {
+			c.JSON(http.StatusOK, gin.H{
+				"success": false,
+				"message": fmt.Sprintf("获取Ollama模型失败: %s", err.Error()),
+			})
+			return
+		}
+
+		names := make([]string, 0, len(models))
+		for _, modelInfo := range models {
+			names = append(names, modelInfo.Name)
+		}
+
+		c.JSON(http.StatusOK, gin.H{
+			"success": true,
+			"data":    names,
+		})
+		return
+	}
+
 	client := &http.Client{}
 	url := fmt.Sprintf("%s/v1/models", baseURL)
 
@@ -987,10 +1066,6 @@ func FetchModels(c *gin.Context) {
 		return
 	}
 
-	// remove line breaks and extra spaces.
-	key := strings.TrimSpace(req.Key)
-	// If the key contains a line break, only take the first part.
-	key = strings.Split(key, "\n")[0]
 	request.Header.Set("Authorization", "Bearer "+key)
 
 	response, err := client.Do(request)
@@ -1640,3 +1715,262 @@ func ManageMultiKeys(c *gin.Context) {
 		return
 	}
 }
+
+// OllamaPullModel 拉取 Ollama 模型
+func OllamaPullModel(c *gin.Context) {
+	var req struct {
+		ChannelID int    `json:"channel_id"`
+		ModelName string `json:"model_name"`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Invalid request parameters",
+		})
+		return
+	}
+
+	if req.ChannelID == 0 || req.ModelName == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Channel ID and model name are required",
+		})
+		return
+	}
+
+	// 获取渠道信息
+	channel, err := model.GetChannelById(req.ChannelID, true)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{
+			"success": false,
+			"message": "Channel not found",
+		})
+		return
+	}
+
+	// 检查是否是 Ollama 渠道
+	if channel.Type != constant.ChannelTypeOllama {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "This operation is only supported for Ollama channels",
+		})
+		return
+	}
+
+	baseURL := constant.ChannelBaseURLs[channel.Type]
+	if channel.GetBaseURL() != "" {
+		baseURL = channel.GetBaseURL()
+	}
+
+	key := strings.Split(channel.Key, "\n")[0]
+	err = ollama.PullOllamaModel(baseURL, key, req.ModelName)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"message": fmt.Sprintf("Failed to pull model: %s", err.Error()),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"message": fmt.Sprintf("Model %s pulled successfully", req.ModelName),
+	})
+}
+
+// OllamaPullModelStream 流式拉取 Ollama 模型
+func OllamaPullModelStream(c *gin.Context) {
+	var req struct {
+		ChannelID int    `json:"channel_id"`
+		ModelName string `json:"model_name"`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Invalid request parameters",
+		})
+		return
+	}
+
+	if req.ChannelID == 0 || req.ModelName == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Channel ID and model name are required",
+		})
+		return
+	}
+
+	// 获取渠道信息
+	channel, err := model.GetChannelById(req.ChannelID, true)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{
+			"success": false,
+			"message": "Channel not found",
+		})
+		return
+	}
+
+	// 检查是否是 Ollama 渠道
+	if channel.Type != constant.ChannelTypeOllama {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "This operation is only supported for Ollama channels",
+		})
+		return
+	}
+
+	baseURL := constant.ChannelBaseURLs[channel.Type]
+	if channel.GetBaseURL() != "" {
+		baseURL = channel.GetBaseURL()
+	}
+
+	// 设置 SSE 头部
+	c.Header("Content-Type", "text/event-stream")
+	c.Header("Cache-Control", "no-cache")
+	c.Header("Connection", "keep-alive")
+	c.Header("Access-Control-Allow-Origin", "*")
+
+	key := strings.Split(channel.Key, "\n")[0]
+
+	// 创建进度回调函数
+	progressCallback := func(progress ollama.OllamaPullResponse) {
+		data, _ := json.Marshal(progress)
+		fmt.Fprintf(c.Writer, "data: %s\n\n", string(data))
+		c.Writer.Flush()
+	}
+
+	// 执行拉取
+	err = ollama.PullOllamaModelStream(baseURL, key, req.ModelName, progressCallback)
+
+	if err != nil {
+		errorData, _ := json.Marshal(gin.H{
+			"error": err.Error(),
+		})
+		fmt.Fprintf(c.Writer, "data: %s\n\n", string(errorData))
+	} else {
+		successData, _ := json.Marshal(gin.H{
+			"message": fmt.Sprintf("Model %s pulled successfully", req.ModelName),
+		})
+		fmt.Fprintf(c.Writer, "data: %s\n\n", string(successData))
+	}
+
+	// 发送结束标志
+	fmt.Fprintf(c.Writer, "data: [DONE]\n\n")
+	c.Writer.Flush()
+}
+
+// OllamaDeleteModel 删除 Ollama 模型
+func OllamaDeleteModel(c *gin.Context) {
+	var req struct {
+		ChannelID int    `json:"channel_id"`
+		ModelName string `json:"model_name"`
+	}
+
+	if err := c.ShouldBindJSON(&req); err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Invalid request parameters",
+		})
+		return
+	}
+
+	if req.ChannelID == 0 || req.ModelName == "" {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Channel ID and model name are required",
+		})
+		return
+	}
+
+	// 获取渠道信息
+	channel, err := model.GetChannelById(req.ChannelID, true)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{
+			"success": false,
+			"message": "Channel not found",
+		})
+		return
+	}
+
+	// 检查是否是 Ollama 渠道
+	if channel.Type != constant.ChannelTypeOllama {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "This operation is only supported for Ollama channels",
+		})
+		return
+	}
+
+	baseURL := constant.ChannelBaseURLs[channel.Type]
+	if channel.GetBaseURL() != "" {
+		baseURL = channel.GetBaseURL()
+	}
+
+	key := strings.Split(channel.Key, "\n")[0]
+	err = ollama.DeleteOllamaModel(baseURL, key, req.ModelName)
+	if err != nil {
+		c.JSON(http.StatusInternalServerError, gin.H{
+			"success": false,
+			"message": fmt.Sprintf("Failed to delete model: %s", err.Error()),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"message": fmt.Sprintf("Model %s deleted successfully", req.ModelName),
+	})
+}
+
+// OllamaVersion 获取 Ollama 服务版本信息
+func OllamaVersion(c *gin.Context) {
+	id, err := strconv.Atoi(c.Param("id"))
+	if err != nil {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "Invalid channel id",
+		})
+		return
+	}
+
+	channel, err := model.GetChannelById(id, true)
+	if err != nil {
+		c.JSON(http.StatusNotFound, gin.H{
+			"success": false,
+			"message": "Channel not found",
+		})
+		return
+	}
+
+	if channel.Type != constant.ChannelTypeOllama {
+		c.JSON(http.StatusBadRequest, gin.H{
+			"success": false,
+			"message": "This operation is only supported for Ollama channels",
+		})
+		return
+	}
+
+	baseURL := constant.ChannelBaseURLs[channel.Type]
+	if channel.GetBaseURL() != "" {
+		baseURL = channel.GetBaseURL()
+	}
+
+	key := strings.Split(channel.Key, "\n")[0]
+	version, err := ollama.FetchOllamaVersion(baseURL, key)
+	if err != nil {
+		c.JSON(http.StatusOK, gin.H{
+			"success": false,
+			"message": fmt.Sprintf("获取Ollama版本失败: %s", err.Error()),
+		})
+		return
+	}
+
+	c.JSON(http.StatusOK, gin.H{
+		"success": true,
+		"data": gin.H{
+			"version": version,
+		},
+	})
+}

docs/ionet-client.md

+Request URL
+https://api.io.solutions/v1/io-cloud/clusters/654fc0a9-0d4a-4db4-9b95-3f56189348a2/update-name
+Request Method
+PUT
+
+{"status":"succeeded","message":"Cluster name updated successfully"}
+

go.mod

@@ -37,6 +37,7 @@ require (
 	github.com/samber/lo v1.52.0
 	github.com/shirou/gopsutil v3.21.11+incompatible
 	github.com/shopspring/decimal v1.4.0
+	github.com/stretchr/testify v1.11.1
 	github.com/stripe/stripe-go/v81 v81.4.0
 	github.com/tcolgate/mp3 v0.0.0-20170426193717-e79c5a46d300
 	github.com/thanhpk/randstr v1.0.6
@@ -63,6 +64,7 @@ require (
 	github.com/bytedance/sonic/loader v0.3.0 // indirect
 	github.com/cespare/xxhash/v2 v2.3.0 // indirect
 	github.com/cloudwego/base64x v0.1.6 // indirect
+	github.com/davecgh/go-spew v1.1.1 // indirect
 	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
 	github.com/dlclark/regexp2 v1.11.5 // indirect
 	github.com/dustin/go-humanize v1.0.1 // indirect
@@ -103,7 +105,9 @@ require (
 	github.com/modern-go/reflect2 v1.0.2 // indirect
 	github.com/ncruces/go-strftime v0.1.9 // indirect
 	github.com/pelletier/go-toml/v2 v2.2.1 // indirect
+	github.com/pmezard/go-difflib v1.0.0 // indirect
 	github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/tidwall/match v1.1.1 // indirect
 	github.com/tidwall/pretty v1.2.0 // indirect
 	github.com/tklauser/go-sysconf v0.3.12 // indirect

model/main.go

@@ -248,26 +248,26 @@ func InitLogDB() (err error) {
 }
 
 func migrateDB() error {
-	err := DB.AutoMigrate(
-		&Channel{},
-		&Token{},
-		&User{},
-		&PasskeyCredential{},
+    err := DB.AutoMigrate(
+        &Channel{},
+        &Token{},
+        &User{},
+        &PasskeyCredential{},
 		&Option{},
-		&Redemption{},
-		&Ability{},
-		&Log{},
-		&Midjourney{},
-		&TopUp{},
-		&QuotaData{},
-		&Task{},
-		&Model{},
-		&Vendor{},
-		&PrefillGroup{},
-		&Setup{},
-		&TwoFA{},
-		&TwoFABackupCode{},
-	)
+        &Redemption{},
+        &Ability{},
+        &Log{},
+        &Midjourney{},
+        &TopUp{},
+        &QuotaData{},
+        &Task{},
+        &Model{},
+        &Vendor{},
+        &PrefillGroup{},
+        &Setup{},
+        &TwoFA{},
+        &TwoFABackupCode{},
+    )
 	if err != nil {
 		return err
 	}
@@ -278,29 +278,29 @@ func migrateDBFast() error {
 
 	var wg sync.WaitGroup
 
-	migrations := []struct {
-		model interface{}
-		name  string
-	}{
-		{&Channel{}, "Channel"},
-		{&Token{}, "Token"},
-		{&User{}, "User"},
-		{&PasskeyCredential{}, "PasskeyCredential"},
+    migrations := []struct {
+        model interface{}
+        name  string
+    }{
+        {&Channel{}, "Channel"},
+        {&Token{}, "Token"},
+        {&User{}, "User"},
+        {&PasskeyCredential{}, "PasskeyCredential"},
 		{&Option{}, "Option"},
-		{&Redemption{}, "Redemption"},
-		{&Ability{}, "Ability"},
-		{&Log{}, "Log"},
-		{&Midjourney{}, "Midjourney"},
-		{&TopUp{}, "TopUp"},
-		{&QuotaData{}, "QuotaData"},
-		{&Task{}, "Task"},
-		{&Model{}, "Model"},
-		{&Vendor{}, "Vendor"},
-		{&PrefillGroup{}, "PrefillGroup"},
-		{&Setup{}, "Setup"},
-		{&TwoFA{}, "TwoFA"},
-		{&TwoFABackupCode{}, "TwoFABackupCode"},
-	}
+        {&Redemption{}, "Redemption"},
+        {&Ability{}, "Ability"},
+        {&Log{}, "Log"},
+        {&Midjourney{}, "Midjourney"},
+        {&TopUp{}, "TopUp"},
+        {&QuotaData{}, "QuotaData"},
+        {&Task{}, "Task"},
+        {&Model{}, "Model"},
+        {&Vendor{}, "Vendor"},
+        {&PrefillGroup{}, "PrefillGroup"},
+        {&Setup{}, "Setup"},
+        {&TwoFA{}, "TwoFA"},
+        {&TwoFABackupCode{}, "TwoFABackupCode"},
+    }
 	// 动态计算migration数量，确保errChan缓冲区足够大
 	errChan := make(chan error, len(migrations))
 

pkg/ionet/client.go

+package ionet
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"strconv"
+	"time"
+)
+
+const (
+	DefaultEnterpriseBaseURL = "https://api.io.solutions/enterprise/v1/io-cloud/caas"
+	DefaultBaseURL           = "https://api.io.solutions/v1/io-cloud/caas"
+	DefaultTimeout           = 30 * time.Second
+)
+
+// DefaultHTTPClient is the default HTTP client implementation
+type DefaultHTTPClient struct {
+	client *http.Client
+}
+
+// NewDefaultHTTPClient creates a new default HTTP client
+func NewDefaultHTTPClient(timeout time.Duration) *DefaultHTTPClient {
+	return &DefaultHTTPClient{
+		client: &http.Client{
+			Timeout: timeout,
+		},
+	}
+}
+
+// Do executes an HTTP request
+func (c *DefaultHTTPClient) Do(req *HTTPRequest) (*HTTPResponse, error) {
+	httpReq, err := http.NewRequest(req.Method, req.URL, bytes.NewReader(req.Body))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create HTTP request: %w", err)
+	}
+
+	// Set headers
+	for key, value := range req.Headers {
+		httpReq.Header.Set(key, value)
+	}
+
+	resp, err := c.client.Do(httpReq)
+	if err != nil {
+		return nil, fmt.Errorf("HTTP request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// Read response body
+	var body bytes.Buffer
+	_, err = body.ReadFrom(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	// Convert headers
+	headers := make(map[string]string)
+	for key, values := range resp.Header {
+		if len(values) > 0 {
+			headers[key] = values[0]
+		}
+	}
+
+	return &HTTPResponse{
+		StatusCode: resp.StatusCode,
+		Headers:    headers,
+		Body:       body.Bytes(),
+	}, nil
+}
+
+// NewEnterpriseClient creates a new IO.NET API client targeting the enterprise API base URL.
+func NewEnterpriseClient(apiKey string) *Client {
+	return NewClientWithConfig(apiKey, DefaultEnterpriseBaseURL, nil)
+}
+
+// NewClient creates a new IO.NET API client targeting the public API base URL.
+func NewClient(apiKey string) *Client {
+	return NewClientWithConfig(apiKey, DefaultBaseURL, nil)
+}
+
+// NewClientWithConfig creates a new IO.NET API client with custom configuration
+func NewClientWithConfig(apiKey, baseURL string, httpClient HTTPClient) *Client {
+	if baseURL == "" {
+		baseURL = DefaultBaseURL
+	}
+	if httpClient == nil {
+		httpClient = NewDefaultHTTPClient(DefaultTimeout)
+	}
+	return &Client{
+		BaseURL:    baseURL,
+		APIKey:     apiKey,
+		HTTPClient: httpClient,
+	}
+}
+
+// makeRequest performs an HTTP request and handles common response processing
+func (c *Client) makeRequest(method, endpoint string, body interface{}) (*HTTPResponse, error) {
+	var reqBody []byte
+	var err error
+
+	if body != nil {
+		reqBody, err = json.Marshal(body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to marshal request body: %w", err)
+		}
+	}
+
+	headers := map[string]string{
+		"X-API-KEY":    c.APIKey,
+		"Content-Type": "application/json",
+	}
+
+	req := &HTTPRequest{
+		Method:  method,
+		URL:     c.BaseURL + endpoint,
+		Headers: headers,
+		Body:    reqBody,
+	}
+
+	resp, err := c.HTTPClient.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("request failed: %w", err)
+	}
+
+	// Handle API errors
+	if resp.StatusCode >= 400 {
+		var apiErr APIError
+		if len(resp.Body) > 0 {
+			// Try to parse the actual error format: {"detail": "message"}
+			var errorResp struct {
+				Detail string `json:"detail"`
+			}
+			if err := json.Unmarshal(resp.Body, &errorResp); err == nil && errorResp.Detail != "" {
+				apiErr = APIError{
+					Code:    resp.StatusCode,
+					Message: errorResp.Detail,
+				}
+			} else {
+				// Fallback: use raw body as details
+				apiErr = APIError{
+					Code:    resp.StatusCode,
+					Message: fmt.Sprintf("API request failed with status %d", resp.StatusCode),
+					Details: string(resp.Body),
+				}
+			}
+		} else {
+			apiErr = APIError{
+				Code:    resp.StatusCode,
+				Message: fmt.Sprintf("API request failed with status %d", resp.StatusCode),
+			}
+		}
+		return nil, &apiErr
+	}
+
+	return resp, nil
+}
+
+// buildQueryParams builds query parameters for GET requests
+func buildQueryParams(params map[string]interface{}) string {
+	if len(params) == 0 {
+		return ""
+	}
+
+	values := url.Values{}
+	for key, value := range params {
+		if value == nil {
+			continue
+		}
+		switch v := value.(type) {
+		case string:
+			if v != "" {
+				values.Add(key, v)
+			}
+		case int:
+			if v != 0 {
+				values.Add(key, strconv.Itoa(v))
+			}
+		case int64:
+			if v != 0 {
+				values.Add(key, strconv.FormatInt(v, 10))
+			}
+		case float64:
+			if v != 0 {
+				values.Add(key, strconv.FormatFloat(v, 'f', -1, 64))
+			}
+		case bool:
+			values.Add(key, strconv.FormatBool(v))
+		case time.Time:
+			if !v.IsZero() {
+				values.Add(key, v.Format(time.RFC3339))
+			}
+		case *time.Time:
+			if v != nil && !v.IsZero() {
+				values.Add(key, v.Format(time.RFC3339))
+			}
+		case []int:
+			if len(v) > 0 {
+				if encoded, err := json.Marshal(v); err == nil {
+					values.Add(key, string(encoded))
+				}
+			}
+		case []string:
+			if len(v) > 0 {
+				if encoded, err := json.Marshal(v); err == nil {
+					values.Add(key, string(encoded))
+				}
+			}
+		default:
+			values.Add(key, fmt.Sprint(v))
+		}
+	}
+
+	if len(values) > 0 {
+		return "?" + values.Encode()
+	}
+	return ""
+}

pkg/ionet/container.go

+package ionet
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/samber/lo"
+)
+
+// ListContainers retrieves all containers for a specific deployment
+func (c *Client) ListContainers(deploymentID string) (*ContainerList, error) {
+	if deploymentID == "" {
+		return nil, fmt.Errorf("deployment ID cannot be empty")
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/containers", deploymentID)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list containers: %w", err)
+	}
+
+	var containerList ContainerList
+	if err := decodeDataWithFlexibleTimes(resp.Body, &containerList); err != nil {
+		return nil, fmt.Errorf("failed to parse containers list: %w", err)
+	}
+
+	return &containerList, nil
+}
+
+// GetContainerDetails retrieves detailed information about a specific container
+func (c *Client) GetContainerDetails(deploymentID, containerID string) (*Container, error) {
+	if deploymentID == "" {
+		return nil, fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return nil, fmt.Errorf("container ID cannot be empty")
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/container/%s", deploymentID, containerID)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get container details: %w", err)
+	}
+
+	// API response format not documented, assuming direct format
+	var container Container
+	if err := decodeWithFlexibleTimes(resp.Body, &container); err != nil {
+		return nil, fmt.Errorf("failed to parse container details: %w", err)
+	}
+
+	return &container, nil
+}
+
+// GetContainerJobs retrieves containers jobs for a specific container (similar to containers endpoint)
+func (c *Client) GetContainerJobs(deploymentID, containerID string) (*ContainerList, error) {
+	if deploymentID == "" {
+		return nil, fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return nil, fmt.Errorf("container ID cannot be empty")
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/containers-jobs/%s", deploymentID, containerID)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get container jobs: %w", err)
+	}
+
+	var containerList ContainerList
+	if err := decodeDataWithFlexibleTimes(resp.Body, &containerList); err != nil {
+		return nil, fmt.Errorf("failed to parse container jobs: %w", err)
+	}
+
+	return &containerList, nil
+}
+
+// buildLogEndpoint constructs the request path for fetching logs
+func buildLogEndpoint(deploymentID, containerID string, opts *GetLogsOptions) (string, error) {
+	if deploymentID == "" {
+		return "", fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return "", fmt.Errorf("container ID cannot be empty")
+	}
+
+	params := make(map[string]interface{})
+
+	if opts != nil {
+		if opts.Level != "" {
+			params["level"] = opts.Level
+		}
+		if opts.Stream != "" {
+			params["stream"] = opts.Stream
+		}
+		if opts.Limit > 0 {
+			params["limit"] = opts.Limit
+		}
+		if opts.Cursor != "" {
+			params["cursor"] = opts.Cursor
+		}
+		if opts.Follow {
+			params["follow"] = true
+		}
+
+		if opts.StartTime != nil {
+			params["start_time"] = opts.StartTime
+		}
+		if opts.EndTime != nil {
+			params["end_time"] = opts.EndTime
+		}
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/log/%s", deploymentID, containerID)
+	endpoint += buildQueryParams(params)
+
+	return endpoint, nil
+}
+
+// GetContainerLogs retrieves logs for containers in a deployment and normalizes them
+func (c *Client) GetContainerLogs(deploymentID, containerID string, opts *GetLogsOptions) (*ContainerLogs, error) {
+	raw, err := c.GetContainerLogsRaw(deploymentID, containerID, opts)
+	if err != nil {
+		return nil, err
+	}
+
+	logs := &ContainerLogs{
+		ContainerID: containerID,
+	}
+
+	if raw == "" {
+		return logs, nil
+	}
+
+	normalized := strings.ReplaceAll(raw, "\r\n", "\n")
+	lines := strings.Split(normalized, "\n")
+	logs.Logs = lo.FilterMap(lines, func(line string, _ int) (LogEntry, bool) {
+		if strings.TrimSpace(line) == "" {
+			return LogEntry{}, false
+		}
+		return LogEntry{Message: line}, true
+	})
+
+	return logs, nil
+}
+
+// GetContainerLogsRaw retrieves the raw text logs for a specific container
+func (c *Client) GetContainerLogsRaw(deploymentID, containerID string, opts *GetLogsOptions) (string, error) {
+	endpoint, err := buildLogEndpoint(deploymentID, containerID, opts)
+	if err != nil {
+		return "", err
+	}
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return "", fmt.Errorf("failed to get container logs: %w", err)
+	}
+
+	return string(resp.Body), nil
+}
+
+// StreamContainerLogs streams real-time logs for a specific container
+// This method uses a callback function to handle incoming log entries
+func (c *Client) StreamContainerLogs(deploymentID, containerID string, opts *GetLogsOptions, callback func(*LogEntry) error) error {
+	if deploymentID == "" {
+		return fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return fmt.Errorf("container ID cannot be empty")
+	}
+	if callback == nil {
+		return fmt.Errorf("callback function cannot be nil")
+	}
+
+	// Set follow to true for streaming
+	if opts == nil {
+		opts = &GetLogsOptions{}
+	}
+	opts.Follow = true
+
+	endpoint, err := buildLogEndpoint(deploymentID, containerID, opts)
+	if err != nil {
+		return err
+	}
+
+	// Note: This is a simplified implementation. In a real scenario, you might want to use
+	// Server-Sent Events (SSE) or WebSocket for streaming logs
+	for {
+		resp, err := c.makeRequest("GET", endpoint, nil)
+		if err != nil {
+			return fmt.Errorf("failed to stream container logs: %w", err)
+		}
+
+		var logs ContainerLogs
+		if err := decodeWithFlexibleTimes(resp.Body, &logs); err != nil {
+			return fmt.Errorf("failed to parse container logs: %w", err)
+		}
+
+		// Call the callback for each log entry
+		for _, logEntry := range logs.Logs {
+			if err := callback(&logEntry); err != nil {
+				return fmt.Errorf("callback error: %w", err)
+			}
+		}
+
+		// If there are no more logs or we have a cursor, continue polling
+		if !logs.HasMore && logs.NextCursor == "" {
+			break
+		}
+
+		// Update cursor for next request
+		if logs.NextCursor != "" {
+			opts.Cursor = logs.NextCursor
+			endpoint, err = buildLogEndpoint(deploymentID, containerID, opts)
+			if err != nil {
+				return err
+			}
+		}
+
+		// Wait a bit before next poll to avoid overwhelming the API
+		time.Sleep(2 * time.Second)
+	}
+
+	return nil
+}
+
+// RestartContainer restarts a specific container (if supported by the API)
+func (c *Client) RestartContainer(deploymentID, containerID string) error {
+	if deploymentID == "" {
+		return fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return fmt.Errorf("container ID cannot be empty")
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/container/%s/restart", deploymentID, containerID)
+
+	_, err := c.makeRequest("POST", endpoint, nil)
+	if err != nil {
+		return fmt.Errorf("failed to restart container: %w", err)
+	}
+
+	return nil
+}
+
+// StopContainer stops a specific container (if supported by the API)
+func (c *Client) StopContainer(deploymentID, containerID string) error {
+	if deploymentID == "" {
+		return fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return fmt.Errorf("container ID cannot be empty")
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/container/%s/stop", deploymentID, containerID)
+
+	_, err := c.makeRequest("POST", endpoint, nil)
+	if err != nil {
+		return fmt.Errorf("failed to stop container: %w", err)
+	}
+
+	return nil
+}
+
+// ExecuteInContainer executes a command in a specific container (if supported by the API)
+func (c *Client) ExecuteInContainer(deploymentID, containerID string, command []string) (string, error) {
+	if deploymentID == "" {
+		return "", fmt.Errorf("deployment ID cannot be empty")
+	}
+	if containerID == "" {
+		return "", fmt.Errorf("container ID cannot be empty")
+	}
+	if len(command) == 0 {
+		return "", fmt.Errorf("command cannot be empty")
+	}
+
+	reqBody := map[string]interface{}{
+		"command": command,
+	}
+
+	endpoint := fmt.Sprintf("/deployment/%s/container/%s/exec", deploymentID, containerID)
+
+	resp, err := c.makeRequest("POST", endpoint, reqBody)
+	if err != nil {
+		return "", fmt.Errorf("failed to execute command in container: %w", err)
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(resp.Body, &result); err != nil {
+		return "", fmt.Errorf("failed to parse execution result: %w", err)
+	}
+
+	if output, ok := result["output"].(string); ok {
+		return output, nil
+	}
+
+	return string(resp.Body), nil
+}

pkg/ionet/hardware.go

+package ionet
+
+import (
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/samber/lo"
+)
+
+// GetAvailableReplicas retrieves available replicas per location for specified hardware
+func (c *Client) GetAvailableReplicas(hardwareID int, gpuCount int) (*AvailableReplicasResponse, error) {
+	if hardwareID <= 0 {
+		return nil, fmt.Errorf("hardware_id must be greater than 0")
+	}
+	if gpuCount < 1 {
+		return nil, fmt.Errorf("gpu_count must be at least 1")
+	}
+
+	params := map[string]interface{}{
+		"hardware_id":  hardwareID,
+		"hardware_qty": gpuCount,
+	}
+
+	endpoint := "/available-replicas" + buildQueryParams(params)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get available replicas: %w", err)
+	}
+
+	type availableReplicaPayload struct {
+		ID                int    `json:"id"`
+		ISO2              string `json:"iso2"`
+		Name              string `json:"name"`
+		AvailableReplicas int    `json:"available_replicas"`
+	}
+	var payload []availableReplicaPayload
+
+	if err := decodeData(resp.Body, &payload); err != nil {
+		return nil, fmt.Errorf("failed to parse available replicas response: %w", err)
+	}
+
+	replicas := lo.Map(payload, func(item availableReplicaPayload, _ int) AvailableReplica {
+		return AvailableReplica{
+			LocationID:     item.ID,
+			LocationName:   item.Name,
+			HardwareID:     hardwareID,
+			HardwareName:   "",
+			AvailableCount: item.AvailableReplicas,
+			MaxGPUs:        gpuCount,
+		}
+	})
+
+	return &AvailableReplicasResponse{Replicas: replicas}, nil
+}
+
+// GetMaxGPUsPerContainer retrieves the maximum number of GPUs available per hardware type
+func (c *Client) GetMaxGPUsPerContainer() (*MaxGPUResponse, error) {
+	resp, err := c.makeRequest("GET", "/hardware/max-gpus-per-container", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get max GPUs per container: %w", err)
+	}
+
+	var maxGPUResp MaxGPUResponse
+	if err := decodeData(resp.Body, &maxGPUResp); err != nil {
+		return nil, fmt.Errorf("failed to parse max GPU response: %w", err)
+	}
+
+	return &maxGPUResp, nil
+}
+
+// ListHardwareTypes retrieves available hardware types using the max GPUs endpoint
+func (c *Client) ListHardwareTypes() ([]HardwareType, int, error) {
+	maxGPUResp, err := c.GetMaxGPUsPerContainer()
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to list hardware types: %w", err)
+	}
+
+	mapped := lo.Map(maxGPUResp.Hardware, func(hw MaxGPUInfo, _ int) HardwareType {
+		name := strings.TrimSpace(hw.HardwareName)
+		if name == "" {
+			name = fmt.Sprintf("Hardware %d", hw.HardwareID)
+		}
+
+		return HardwareType{
+			ID:             hw.HardwareID,
+			Name:           name,
+			GPUType:        "",
+			GPUMemory:      0,
+			MaxGPUs:        hw.MaxGPUsPerContainer,
+			CPU:            "",
+			Memory:         0,
+			Storage:        0,
+			HourlyRate:     0,
+			Available:      hw.Available > 0,
+			BrandName:      strings.TrimSpace(hw.BrandName),
+			AvailableCount: hw.Available,
+		}
+	})
+
+	totalAvailable := maxGPUResp.Total
+	if totalAvailable == 0 {
+		totalAvailable = lo.SumBy(maxGPUResp.Hardware, func(hw MaxGPUInfo) int {
+			return hw.Available
+		})
+	}
+
+	return mapped, totalAvailable, nil
+}
+
+// ListLocations retrieves available deployment locations (if supported by the API)
+func (c *Client) ListLocations() (*LocationsResponse, error) {
+	resp, err := c.makeRequest("GET", "/locations", nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to list locations: %w", err)
+	}
+
+	var locations LocationsResponse
+	if err := decodeData(resp.Body, &locations); err != nil {
+		return nil, fmt.Errorf("failed to parse locations response: %w", err)
+	}
+
+	locations.Locations = lo.Map(locations.Locations, func(location Location, _ int) Location {
+		location.ISO2 = strings.ToUpper(strings.TrimSpace(location.ISO2))
+		return location
+	})
+
+	if locations.Total == 0 {
+		locations.Total = lo.SumBy(locations.Locations, func(location Location) int {
+			return location.Available
+		})
+	}
+
+	return &locations, nil
+}
+
+// GetHardwareType retrieves details about a specific hardware type
+func (c *Client) GetHardwareType(hardwareID int) (*HardwareType, error) {
+	if hardwareID <= 0 {
+		return nil, fmt.Errorf("hardware ID must be greater than 0")
+	}
+
+	endpoint := fmt.Sprintf("/hardware/types/%d", hardwareID)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get hardware type: %w", err)
+	}
+
+	// API response format not documented, assuming direct format
+	var hardwareType HardwareType
+	if err := json.Unmarshal(resp.Body, &hardwareType); err != nil {
+		return nil, fmt.Errorf("failed to parse hardware type: %w", err)
+	}
+
+	return &hardwareType, nil
+}
+
+// GetLocation retrieves details about a specific location
+func (c *Client) GetLocation(locationID int) (*Location, error) {
+	if locationID <= 0 {
+		return nil, fmt.Errorf("location ID must be greater than 0")
+	}
+
+	endpoint := fmt.Sprintf("/locations/%d", locationID)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get location: %w", err)
+	}
+
+	// API response format not documented, assuming direct format
+	var location Location
+	if err := json.Unmarshal(resp.Body, &location); err != nil {
+		return nil, fmt.Errorf("failed to parse location: %w", err)
+	}
+
+	return &location, nil
+}
+
+// GetLocationAvailability retrieves real-time availability for a specific location
+func (c *Client) GetLocationAvailability(locationID int) (*LocationAvailability, error) {
+	if locationID <= 0 {
+		return nil, fmt.Errorf("location ID must be greater than 0")
+	}
+
+	endpoint := fmt.Sprintf("/locations/%d/availability", locationID)
+
+	resp, err := c.makeRequest("GET", endpoint, nil)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get location availability: %w", err)
+	}
+
+	// API response format not documented, assuming direct format
+	var availability LocationAvailability
+	if err := json.Unmarshal(resp.Body, &availability); err != nil {
+		return nil, fmt.Errorf("failed to parse location availability: %w", err)
+	}
+
+	return &availability, nil
+}

pkg/ionet/jsonutil.go

+package ionet
+
+import (
+	"encoding/json"
+	"strings"
+	"time"
+
+	"github.com/samber/lo"
+)
+
+// decodeWithFlexibleTimes unmarshals API responses while tolerating timestamp strings
+// that omit timezone information by normalizing them to RFC3339Nano.
+func decodeWithFlexibleTimes(data []byte, target interface{}) error {
+	var intermediate interface{}
+	if err := json.Unmarshal(data, &intermediate); err != nil {
+		return err
+	}
+
+	normalized := normalizeTimeValues(intermediate)
+	reencoded, err := json.Marshal(normalized)
+	if err != nil {
+		return err
+	}
+
+	return json.Unmarshal(reencoded, target)
+}
+
+func decodeData[T any](data []byte, target *T) error {
+	var wrapper struct {
+		Data T `json:"data"`
+	}
+	if err := json.Unmarshal(data, &wrapper); err != nil {
+		return err
+	}
+	*target = wrapper.Data
+	return nil
+}
+
+func decodeDataWithFlexibleTimes[T any](data []byte, target *T) error {
+	var wrapper struct {
+		Data T `json:"data"`
+	}
+	if err := decodeWithFlexibleTimes(data, &wrapper); err != nil {
+		return err
+	}
+	*target = wrapper.Data
+	return nil
+}
+
+func normalizeTimeValues(value interface{}) interface{} {
+	switch v := value.(type) {
+	case map[string]interface{}:
+		return lo.MapValues(v, func(val interface{}, _ string) interface{} {
+			return normalizeTimeValues(val)
+		})
+	case []interface{}:
+		return lo.Map(v, func(item interface{}, _ int) interface{} {
+			return normalizeTimeValues(item)
+		})
+	case string:
+		if normalized, changed := normalizeTimeString(v); changed {
+			return normalized
+		}
+		return v
+	default:
+		return value
+	}
+}
+
+func normalizeTimeString(input string) (string, bool) {
+	trimmed := strings.TrimSpace(input)
+	if trimmed == "" {
+		return input, false
+	}
+
+	if _, err := time.Parse(time.RFC3339Nano, trimmed); err == nil {
+		return trimmed, trimmed != input
+	}
+	if _, err := time.Parse(time.RFC3339, trimmed); err == nil {
+		return trimmed, trimmed != input
+	}
+
+	layouts := []string{
+		"2006-01-02T15:04:05.999999999",
+		"2006-01-02T15:04:05.999999",
+		"2006-01-02T15:04:05",
+	}
+
+	for _, layout := range layouts {
+		if parsed, err := time.Parse(layout, trimmed); err == nil {
+			return parsed.UTC().Format(time.RFC3339Nano), true
+		}
+	}
+
+	return input, false
+}

relay/channel/ollama/dto.go

@@ -67,3 +67,40 @@ type OllamaEmbeddingResponse struct {
 	Embeddings      [][]float64 `json:"embeddings"`
 	PromptEvalCount int         `json:"prompt_eval_count,omitempty"`
 }
+
+type OllamaTagsResponse struct {
+	Models []OllamaModel `json:"models"`
+}
+
+type OllamaModel struct {
+	Name       string            `json:"name"`
+	Size       int64             `json:"size"`
+	Digest     string            `json:"digest,omitempty"`
+	ModifiedAt string            `json:"modified_at"`
+	Details    OllamaModelDetail `json:"details,omitempty"`
+}
+
+type OllamaModelDetail struct {
+	ParentModel       string   `json:"parent_model,omitempty"`
+	Format            string   `json:"format,omitempty"`
+	Family            string   `json:"family,omitempty"`
+	Families          []string `json:"families,omitempty"`
+	ParameterSize     string   `json:"parameter_size,omitempty"`
+	QuantizationLevel string   `json:"quantization_level,omitempty"`
+}
+
+type OllamaPullRequest struct {
+	Name   string `json:"name"`
+	Stream bool   `json:"stream,omitempty"`
+}
+
+type OllamaPullResponse struct {
+	Status    string `json:"status"`
+	Digest    string `json:"digest,omitempty"`
+	Total     int64  `json:"total,omitempty"`
+	Completed int64  `json:"completed,omitempty"`
+}
+
+type OllamaDeleteRequest struct {
+	Name string `json:"name"`
+}

relay/channel/ollama/relay-ollama.go

 package ollama
 
 import (
+	"bufio"
 	"encoding/json"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
+	"time"
 
 	"github.com/QuantumNous/new-api/common"
 	"github.com/QuantumNous/new-api/dto"
@@ -283,3 +285,246 @@ func ollamaEmbeddingHandler(c *gin.Context, info *relaycommon.RelayInfo, resp *h
 	service.IOCopyBytesGracefully(c, resp, out)
 	return usage, nil
 }
+
+func FetchOllamaModels(baseURL, apiKey string) ([]OllamaModel, error) {
+	url := fmt.Sprintf("%s/api/tags", baseURL)
+
+	client := &http.Client{}
+	request, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return nil, fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	// Ollama 通常不需要 Bearer token，但为了兼容性保留
+	if apiKey != "" {
+		request.Header.Set("Authorization", "Bearer "+apiKey)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return nil, fmt.Errorf("请求失败: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(response.Body)
+		return nil, fmt.Errorf("服务器返回错误 %d: %s", response.StatusCode, string(body))
+	}
+
+	var tagsResponse OllamaTagsResponse
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return nil, fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	err = common.Unmarshal(body, &tagsResponse)
+	if err != nil {
+		return nil, fmt.Errorf("解析响应失败: %v", err)
+	}
+
+	return tagsResponse.Models, nil
+}
+
+// 拉取 Ollama 模型 (非流式)
+func PullOllamaModel(baseURL, apiKey, modelName string) error {
+	url := fmt.Sprintf("%s/api/pull", baseURL)
+
+	pullRequest := OllamaPullRequest{
+		Name:   modelName,
+		Stream: false, // 非流式，简化处理
+	}
+
+	requestBody, err := common.Marshal(pullRequest)
+	if err != nil {
+		return fmt.Errorf("序列化请求失败: %v", err)
+	}
+
+	client := &http.Client{
+		Timeout: 30 * 60 * 1000 * time.Millisecond, // 30分钟超时，支持大模型
+	}
+	request, err := http.NewRequest("POST", url, strings.NewReader(string(requestBody)))
+	if err != nil {
+		return fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	if apiKey != "" {
+		request.Header.Set("Authorization", "Bearer "+apiKey)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return fmt.Errorf("请求失败: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("拉取模型失败 %d: %s", response.StatusCode, string(body))
+	}
+
+	return nil
+}
+
+// 流式拉取 Ollama 模型 (支持进度回调)
+func PullOllamaModelStream(baseURL, apiKey, modelName string, progressCallback func(OllamaPullResponse)) error {
+	url := fmt.Sprintf("%s/api/pull", baseURL)
+
+	pullRequest := OllamaPullRequest{
+		Name:   modelName,
+		Stream: true, // 启用流式
+	}
+
+	requestBody, err := common.Marshal(pullRequest)
+	if err != nil {
+		return fmt.Errorf("序列化请求失败: %v", err)
+	}
+
+	client := &http.Client{
+		Timeout: 60 * 60 * 1000 * time.Millisecond, // 1小时超时，支持超大模型
+	}
+	request, err := http.NewRequest("POST", url, strings.NewReader(string(requestBody)))
+	if err != nil {
+		return fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	if apiKey != "" {
+		request.Header.Set("Authorization", "Bearer "+apiKey)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return fmt.Errorf("请求失败: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("拉取模型失败 %d: %s", response.StatusCode, string(body))
+	}
+
+	// 读取流式响应
+	scanner := bufio.NewScanner(response.Body)
+	successful := false
+	for scanner.Scan() {
+		line := scanner.Text()
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+
+		var pullResponse OllamaPullResponse
+		if err := common.Unmarshal([]byte(line), &pullResponse); err != nil {
+			continue // 忽略解析失败的行
+		}
+
+		if progressCallback != nil {
+			progressCallback(pullResponse)
+		}
+
+		// 检查是否出现错误或完成
+		if strings.EqualFold(pullResponse.Status, "error") {
+			return fmt.Errorf("拉取模型失败: %s", strings.TrimSpace(line))
+		}
+		if strings.EqualFold(pullResponse.Status, "success") {
+			successful = true
+			break
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("读取流式响应失败: %v", err)
+	}
+
+	if !successful {
+		return fmt.Errorf("拉取模型未完成: 未收到成功状态")
+	}
+
+	return nil
+}
+
+// 删除 Ollama 模型
+func DeleteOllamaModel(baseURL, apiKey, modelName string) error {
+	url := fmt.Sprintf("%s/api/delete", baseURL)
+
+	deleteRequest := OllamaDeleteRequest{
+		Name: modelName,
+	}
+
+	requestBody, err := common.Marshal(deleteRequest)
+	if err != nil {
+		return fmt.Errorf("序列化请求失败: %v", err)
+	}
+
+	client := &http.Client{}
+	request, err := http.NewRequest("DELETE", url, strings.NewReader(string(requestBody)))
+	if err != nil {
+		return fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	request.Header.Set("Content-Type", "application/json")
+	if apiKey != "" {
+		request.Header.Set("Authorization", "Bearer "+apiKey)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return fmt.Errorf("请求失败: %v", err)
+	}
+	defer response.Body.Close()
+
+	if response.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(response.Body)
+		return fmt.Errorf("删除模型失败 %d: %s", response.StatusCode, string(body))
+	}
+
+	return nil
+}
+
+func FetchOllamaVersion(baseURL, apiKey string) (string, error) {
+	trimmedBase := strings.TrimRight(baseURL, "/")
+	if trimmedBase == "" {
+		return "", fmt.Errorf("baseURL 为空")
+	}
+
+	url := fmt.Sprintf("%s/api/version", trimmedBase)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	request, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return "", fmt.Errorf("创建请求失败: %v", err)
+	}
+
+	if apiKey != "" {
+		request.Header.Set("Authorization", "Bearer "+apiKey)
+	}
+
+	response, err := client.Do(request)
+	if err != nil {
+		return "", fmt.Errorf("请求失败: %v", err)
+	}
+	defer response.Body.Close()
+
+	body, err := io.ReadAll(response.Body)
+	if err != nil {
+		return "", fmt.Errorf("读取响应失败: %v", err)
+	}
+
+	if response.StatusCode != http.StatusOK {
+		return "", fmt.Errorf("查询版本失败 %d: %s", response.StatusCode, string(body))
+	}
+
+	var versionResp struct {
+		Version string `json:"version"`
+	}
+
+	if err := json.Unmarshal(body, &versionResp); err != nil {
+		return "", fmt.Errorf("解析响应失败: %v", err)
+	}
+
+	if versionResp.Version == "" {
+		return "", fmt.Errorf("未返回版本信息")
+	}
+
+	return versionResp.Version, nil
+}

router/api-router.go

@@ -152,6 +152,10 @@ func SetApiRouter(router *gin.Engine) {
 			channelRoute.POST("/fix", controller.FixChannelsAbilities)
 			channelRoute.GET("/fetch_models/:id", controller.FetchUpstreamModels)
 			channelRoute.POST("/fetch_models", controller.FetchModels)
+			channelRoute.POST("/ollama/pull", controller.OllamaPullModel)
+			channelRoute.POST("/ollama/pull/stream", controller.OllamaPullModelStream)
+			channelRoute.DELETE("/ollama/delete", controller.OllamaDeleteModel)
+			channelRoute.GET("/ollama/version/:id", controller.OllamaVersion)
 			channelRoute.POST("/batch/tag", controller.BatchSetChannelTag)
 			channelRoute.GET("/tag/models", controller.GetTagModels)
 			channelRoute.POST("/copy/:id", controller.CopyChannel)
@@ -256,5 +260,45 @@ func SetApiRouter(router *gin.Engine) {
 			modelsRoute.PUT("/", controller.UpdateModelMeta)
 			modelsRoute.DELETE("/:id", controller.DeleteModelMeta)
 		}
+
+		// Deployments (model deployment management)
+		deploymentsRoute := apiRouter.Group("/deployments")
+		deploymentsRoute.Use(middleware.AdminAuth())
+		{
+			// List and search deployments
+			deploymentsRoute.GET("/", controller.GetAllDeployments)
+			deploymentsRoute.GET("/search", controller.SearchDeployments)
+
+			// Connection utilities
+			deploymentsRoute.POST("/test-connection", controller.TestIoNetConnection)
+
+			// Resource and configuration endpoints
+			deploymentsRoute.GET("/hardware-types", controller.GetHardwareTypes)
+			deploymentsRoute.GET("/locations", controller.GetLocations)
+			deploymentsRoute.GET("/available-replicas", controller.GetAvailableReplicas)
+			deploymentsRoute.POST("/price-estimation", controller.GetPriceEstimation)
+			deploymentsRoute.GET("/check-name", controller.CheckClusterNameAvailability)
+
+			// Create new deployment
+			deploymentsRoute.POST("/", controller.CreateDeployment)
+
+			// Individual deployment operations
+			deploymentsRoute.GET("/:id", controller.GetDeployment)
+			deploymentsRoute.GET("/:id/logs", controller.GetDeploymentLogs)
+			deploymentsRoute.GET("/:id/containers", controller.ListDeploymentContainers)
+			deploymentsRoute.GET("/:id/containers/:container_id", controller.GetContainerDetails)
+			deploymentsRoute.PUT("/:id", controller.UpdateDeployment)
+			deploymentsRoute.PUT("/:id/name", controller.UpdateDeploymentName)
+			deploymentsRoute.POST("/:id/extend", controller.ExtendDeployment)
+			deploymentsRoute.DELETE("/:id", controller.DeleteDeployment)
+
+			// Future batch operations:
+			// deploymentsRoute.POST("/:id/start", controller.StartDeployment)
+			// deploymentsRoute.POST("/:id/stop", controller.StopDeployment)
+			// deploymentsRoute.POST("/:id/restart", controller.RestartDeployment)
+			// deploymentsRoute.POST("/batch_delete", controller.BatchDeleteDeployments)
+			// deploymentsRoute.POST("/batch_start", controller.BatchStartDeployments)
+			// deploymentsRoute.POST("/batch_stop", controller.BatchStopDeployments)
+		}
 	}
 }

web/src/App.jsx

@@ -42,6 +42,7 @@ import Midjourney from './pages/Midjourney';
 import Pricing from './pages/Pricing';
 import Task from './pages/Task';
 import ModelPage from './pages/Model';
+import ModelDeploymentPage from './pages/ModelDeployment';
 import Playground from './pages/Playground';
 import OAuth2Callback from './components/auth/OAuth2Callback';
 import PersonalSetting from './components/settings/PersonalSetting';
@@ -109,6 +110,14 @@ function App() {
           }
         />
         <Route
+          path='/console/deployment'
+          element={
+            <AdminRoute>
+              <ModelDeploymentPage />
+            </AdminRoute>
+          }
+        />
+        <Route
           path='/console/channel'
           element={
             <AdminRoute>

web/src/components/layout/SiderBar.jsx

@@ -45,6 +45,7 @@ const routerMap = {
   pricing: '/pricing',
   task: '/console/task',
   models: '/console/models',
+  deployment: '/console/deployment',
   playground: '/console/playground',
   personal: '/console/personal',
 };
@@ -158,6 +159,12 @@ const SiderBar = ({ onNavigate = () => {} }) => {
         className: isAdmin() ? '' : 'tableHiddle',
       },
       {
+        text: t('模型部署'),
+        itemKey: 'deployment',
+        to: '/deployment',
+        className: isAdmin() ? '' : 'tableHiddle',
+      },
+      {
         text: t('兑换码管理'),
         itemKey: 'redemption',
         to: '/redemption',

web/src/components/layout/components/SkeletonWrapper.jsx

@@ -52,7 +52,6 @@ const SkeletonWrapper = ({
             active
             placeholder={
               <Skeleton.Title
-                active
                 style={{ width: isMobile ? 40 : width, height }}
               />
             }
@@ -71,7 +70,7 @@ const SkeletonWrapper = ({
           loading={true}
           active
           placeholder={
-            <Skeleton.Avatar active size='extra-small' className='shadow-sm' />
+            <Skeleton.Avatar size='extra-small' className='shadow-sm' />
           }
         />
         <div className='ml-1.5 mr-1'>
@@ -80,7 +79,6 @@ const SkeletonWrapper = ({
             active
             placeholder={
               <Skeleton.Title
-                active
                 style={{ width: isMobile ? 15 : width, height: 12 }}
               />
             }
@@ -98,7 +96,6 @@ const SkeletonWrapper = ({
         active
         placeholder={
           <Skeleton.Image
-            active
             className={`absolute inset-0 !rounded-full ${className}`}
             style={{ width: '100%', height: '100%' }}
           />
@@ -113,7 +110,7 @@ const SkeletonWrapper = ({
       <Skeleton
         loading={true}
         active
-        placeholder={<Skeleton.Title active style={{ width, height: 24 }} />}
+        placeholder={<Skeleton.Title style={{ width, height: 24 }} />}
       />
     );
   };
@@ -125,7 +122,7 @@ const SkeletonWrapper = ({
         <Skeleton
           loading={true}
           active
-          placeholder={<Skeleton.Title active style={{ width, height }} />}
+          placeholder={<Skeleton.Title style={{ width, height }} />}
         />
       </div>
     );
@@ -140,7 +137,6 @@ const SkeletonWrapper = ({
           active
           placeholder={
             <Skeleton.Title
-              active
               style={{ width, height, borderRadius: 9999 }}
             />
           }
@@ -164,7 +160,7 @@ const SkeletonWrapper = ({
               loading={true}
               active
               placeholder={
-                <Skeleton.Avatar active size='extra-small' shape='square' />
+                <Skeleton.Avatar size='extra-small' shape='square' />
               }
             />
           </div>
@@ -174,7 +170,6 @@ const SkeletonWrapper = ({
             active
             placeholder={
               <Skeleton.Title
-                active
                 style={{ width: width || 80, height: height || 14 }}
               />
             }
@@ -191,10 +186,7 @@ const SkeletonWrapper = ({
           loading={true}
           active
           placeholder={
-            <Skeleton.Title
-              active
-              style={{ width: width || 60, height: height || 12 }}
-            />
+            <Skeleton.Title style={{ width: width || 60, height: height || 12 }} />
           }
         />
       </div>
@@ -217,7 +209,6 @@ const SkeletonWrapper = ({
         active
         placeholder={
           <Skeleton.Avatar
-            active
             shape='square'
             style={{ width: ICON_SIZE, height: ICON_SIZE }}
           />
@@ -231,7 +222,6 @@ const SkeletonWrapper = ({
         active
         placeholder={
           <Skeleton.Title
-            active
             style={{ width: labelWidth, height: TEXT_HEIGHT }}
           />
         }
@@ -269,7 +259,6 @@ const SkeletonWrapper = ({
           active
           placeholder={
             <Skeleton.Avatar
-              active
               shape='square'
               style={{ width: ICON_SIZE, height: ICON_SIZE }}
             />
@@ -329,7 +318,6 @@ const SkeletonWrapper = ({
                     active
                     placeholder={
                       <Skeleton.Title
-                        active
                         style={{ width: sec.titleWidth, height: TITLE_HEIGHT }}
                       />
                     }
@@ -350,7 +338,6 @@ const SkeletonWrapper = ({
                     active
                     placeholder={
                       <Skeleton.Title
-                        active
                         style={{ width: sec.titleWidth, height: TITLE_HEIGHT }}
                       />
                     }

web/src/components/settings/ModelDeploymentSetting.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useEffect, useState } from 'react';
+import { Card, Spin } from '@douyinfe/semi-ui';
+import { API, showError, toBoolean } from '../../helpers';
+import { useTranslation } from 'react-i18next';
+import SettingModelDeployment from '../../pages/Setting/Model/SettingModelDeployment';
+
+const ModelDeploymentSetting = () => {
+  const { t } = useTranslation();
+  let [inputs, setInputs] = useState({
+    'model_deployment.ionet.api_key': '',
+    'model_deployment.ionet.enabled': false,
+  });
+
+  let [loading, setLoading] = useState(false);
+
+  const getOptions = async () => {
+    const res = await API.get('/api/option/');
+    const { success, message, data } = res.data;
+    if (success) {
+      let newInputs = {
+        'model_deployment.ionet.api_key': '',
+        'model_deployment.ionet.enabled': false,
+      };
+      
+      data.forEach((item) => {
+        if (item.key.endsWith('Enabled') || item.key.endsWith('enabled')) {
+          newInputs[item.key] = toBoolean(item.value);
+        } else {
+          newInputs[item.key] = item.value;
+        }
+      });
+
+      setInputs(newInputs);
+    } else {
+      showError(message);
+    }
+  };
+
+  async function onRefresh() {
+    try {
+      setLoading(true);
+      await getOptions();
+    } catch (error) {
+      showError('刷新失败');
+      console.error(error);
+    } finally {
+      setLoading(false);
+    }
+  }
+
+  useEffect(() => {
+    onRefresh();
+  }, []);
+
+  return (
+    <>
+      <Spin spinning={loading} size='large'>
+        <Card style={{ marginTop: '10px' }}>
+          <SettingModelDeployment options={inputs} refresh={onRefresh} />
+        </Card>
+      </Spin>
+    </>
+  );
+};
+
+export default ModelDeploymentSetting;
\ No newline at end of file

web/src/components/table/channels/ChannelsColumnDefs.jsx

@@ -47,7 +47,8 @@ import {
 import { FaRandom } from 'react-icons/fa';
 
 // Render functions
-const renderType = (type, channelInfo = undefined, t) => {
+const renderType = (type, record = {}, t) => {
+  const channelInfo = record?.channel_info;
   let type2label = new Map();
   for (let i = 0; i < CHANNEL_OPTIONS.length; i++) {
     type2label[CHANNEL_OPTIONS[i].value] = CHANNEL_OPTIONS[i];
@@ -71,11 +72,65 @@ const renderType = (type, channelInfo = undefined, t) => {
       );
   }
 
-  return (
+  const typeTag = (
     <Tag color={type2label[type]?.color} shape='circle' prefixIcon={icon}>
       {type2label[type]?.label}
     </Tag>
   );
+
+  let ionetMeta = null;
+  if (record?.other_info) {
+    try {
+      const parsed = JSON.parse(record.other_info);
+      if (parsed && typeof parsed === 'object' && parsed.source === 'ionet') {
+        ionetMeta = parsed;
+      }
+    } catch (error) {
+      // ignore invalid metadata
+    }
+  }
+
+  if (!ionetMeta) {
+    return typeTag;
+  }
+
+  const handleNavigate = (event) => {
+    event?.stopPropagation?.();
+    if (!ionetMeta?.deployment_id) {
+      return;
+    }
+    const targetUrl = `/console/deployment?deployment_id=${ionetMeta.deployment_id}`;
+    window.open(targetUrl, '_blank', 'noopener');
+  };
+
+  return (
+    <Space spacing={6}>
+      {typeTag}
+      <Tooltip
+        content={
+          <div className='max-w-xs'>
+            <div className='text-xs text-gray-600'>{t('来源于 IO.NET 部署')}</div>
+            {ionetMeta?.deployment_id && (
+              <div className='text-xs text-gray-500 mt-1'>
+                {t('部署 ID')}: {ionetMeta.deployment_id}
+              </div>
+            )}
+          </div>
+        }
+      >
+        <span>
+          <Tag
+            color='purple'
+            type='light'
+            className='cursor-pointer'
+            onClick={handleNavigate}
+          >
+            IO.NET
+          </Tag>
+        </span>
+      </Tooltip>
+    </Space>
+  );
 };
 
 const renderTagType = (t) => {
@@ -231,6 +286,7 @@ export const getChannelsColumns = ({
   refresh,
   activePage,
   channels,
+  checkOllamaVersion,
   setShowMultiKeyManageModal,
   setCurrentMultiKeyChannel,
 }) => {
@@ -330,12 +386,7 @@ export const getChannelsColumns = ({
       dataIndex: 'type',
       render: (text, record, index) => {
         if (record.children === undefined) {
-          if (record.channel_info) {
-            if (record.channel_info.is_multi_key) {
-              return <>{renderType(text, record.channel_info, t)}</>;
-            }
-          }
-          return <>{renderType(text, undefined, t)}</>;
+          return <>{renderType(text, record, t)}</>;
         } else {
           return <>{renderTagType(t)}</>;
         }
@@ -569,6 +620,15 @@ export const getChannelsColumns = ({
             },
           ];
 
+          if (record.type === 4) {
+            moreMenuItems.unshift({
+              node: 'item',
+              name: t('测活'),
+              type: 'tertiary',
+              onClick: () => checkOllamaVersion(record),
+            });
+          }
+
           return (
             <Space wrap>
               <SplitButtonGroup

web/src/components/table/channels/ChannelsTable.jsx

@@ -57,6 +57,7 @@ const ChannelsTable = (channelsData) => {
     setEditingTag,
     copySelectedChannel,
     refresh,
+    checkOllamaVersion,
     // Multi-key management
     setShowMultiKeyManageModal,
     setCurrentMultiKeyChannel,
@@ -82,6 +83,7 @@ const ChannelsTable = (channelsData) => {
       refresh,
       activePage,
       channels,
+      checkOllamaVersion,
       setShowMultiKeyManageModal,
       setCurrentMultiKeyChannel,
     });
@@ -103,6 +105,7 @@ const ChannelsTable = (channelsData) => {
     refresh,
     activePage,
     channels,
+    checkOllamaVersion,
     setShowMultiKeyManageModal,
     setCurrentMultiKeyChannel,
   ]);

web/src/components/table/channels/modals/ModelSelectModal.jsx

@@ -47,7 +47,20 @@ const ModelSelectModal = ({
   onCancel,
 }) => {
   const { t } = useTranslation();
-  const [checkedList, setCheckedList] = useState(selected);
+
+  const getModelName = (model) => {
+    if (!model) return '';
+    if (typeof model === 'string') return model;
+    if (typeof model === 'object' && model.model_name) return model.model_name;
+    return String(model ?? '');
+  };
+
+  const normalizedSelected = useMemo(
+    () => (selected || []).map(getModelName),
+    [selected],
+  );
+
+  const [checkedList, setCheckedList] = useState(normalizedSelected);
   const [keyword, setKeyword] = useState('');
   const [activeTab, setActiveTab] = useState('new');
 
@@ -105,9 +118,9 @@ const ModelSelectModal = ({
   // 同步外部选中值
   useEffect(() => {
     if (visible) {
-      setCheckedList(selected);
+      setCheckedList(normalizedSelected);
     }
-  }, [visible, selected]);
+  }, [visible, normalizedSelected]);
 
   // 当模型列表变化时，设置默认tab
   useEffect(() => {

web/src/components/table/model-deployments/DeploymentsActions.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React from 'react';
+import { Button, Popconfirm } from '@douyinfe/semi-ui';
+import CompactModeToggle from '../../common/ui/CompactModeToggle';
+
+const DeploymentsActions = ({
+  selectedKeys,
+  setSelectedKeys,
+  setEditingDeployment,
+  setShowEdit,
+  batchDeleteDeployments,
+  compactMode,
+  setCompactMode,
+  showCreateModal,
+  setShowCreateModal,
+  t,
+}) => {
+  const hasSelected = selectedKeys.length > 0;
+
+  const handleAddDeployment = () => {
+    if (setShowCreateModal) {
+      setShowCreateModal(true);
+    } else {
+      // Fallback to old behavior if setShowCreateModal is not provided
+      setEditingDeployment({ id: undefined });
+      setShowEdit(true);
+    }
+  };
+
+  const handleBatchDelete = () => {
+    batchDeleteDeployments();
+  };
+
+  const handleDeselectAll = () => {
+    setSelectedKeys([]);
+  };
+
+
+  return (
+    <div className='flex flex-wrap gap-2 w-full md:w-auto order-2 md:order-1'>
+      <Button
+        type='primary'
+        className='flex-1 md:flex-initial'
+        onClick={handleAddDeployment}
+        size='small'
+      >
+        {t('新建容器')}
+      </Button>
+
+      {hasSelected && (
+        <>
+          <Popconfirm
+            title={t('确认删除')}
+            content={`${t('确定要删除选中的')} ${selectedKeys.length} ${t('个部署吗？此操作不可逆。')}`}
+            okText={t('删除')}
+            cancelText={t('取消')}
+            okType='danger'
+            onConfirm={handleBatchDelete}
+          >
+            <Button
+              type='danger'
+              className='flex-1 md:flex-initial'
+              disabled={selectedKeys.length === 0}
+              size='small'
+            >
+              {t('批量删除')} ({selectedKeys.length})
+            </Button>
+          </Popconfirm>
+
+          <Button
+            type='tertiary'
+            className='flex-1 md:flex-initial'
+            onClick={handleDeselectAll}
+            size='small'
+          >
+            {t('取消选择')}
+          </Button>
+        </>
+      )}
+
+      {/* Compact Mode */}
+      <CompactModeToggle
+        compactMode={compactMode}
+        setCompactMode={setCompactMode}
+        t={t}
+      />
+    </div>
+  );
+};
+
+export default DeploymentsActions;

web/src/components/table/model-deployments/DeploymentsFilters.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useRef } from 'react';
+import { Form, Button } from '@douyinfe/semi-ui';
+import { IconSearch, IconRefresh } from '@douyinfe/semi-icons';
+
+const DeploymentsFilters = ({
+  formInitValues,
+  setFormApi,
+  searchDeployments,
+  loading,
+  searching,
+  setShowColumnSelector,
+  t,
+}) => {
+  const formApiRef = useRef(null);
+
+  const handleSubmit = (values) => {
+    searchDeployments(values);
+  };
+
+  const handleReset = () => {
+    if (!formApiRef.current) return;
+    formApiRef.current.reset();
+    setTimeout(() => {
+      formApiRef.current.submitForm();
+    }, 0);
+  };
+
+  const statusOptions = [
+    { label: t('全部状态'), value: '' },
+    { label: t('运行中'), value: 'running' },
+    { label: t('已完成'), value: 'completed' },
+    { label: t('失败'), value: 'failed' },
+    { label: t('部署请求中'), value: 'deployment requested' },
+    { label: t('终止请求中'), value: 'termination requested' },
+    { label: t('已销毁'), value: 'destroyed' },
+  ];
+
+  return (
+    <Form
+      layout='horizontal'
+      onSubmit={handleSubmit}
+      initValues={formInitValues}
+      getFormApi={(formApi) => {
+        setFormApi(formApi);
+        formApiRef.current = formApi;
+      }}
+      className='w-full md:w-auto order-1 md:order-2'
+    >
+      <div className='flex flex-col md:flex-row items-center gap-2 w-full md:w-auto'>
+        <div className='w-full md:w-64'>
+          <Form.Input
+            field='searchKeyword'
+            placeholder={t('搜索部署名称')}
+            prefix={<IconSearch />}
+            showClear
+            size='small'
+            pure
+          />
+        </div>
+
+        <div className='w-full md:w-48'>
+          <Form.Select
+            field='searchStatus'
+            placeholder={t('选择状态')}
+            optionList={statusOptions}
+            className='w-full'
+            showClear
+            size='small'
+            pure
+          />
+        </div>
+
+        <div className='flex gap-2 w-full md:w-auto'>
+          <Button
+            htmlType='submit'
+            type='tertiary'
+            icon={<IconSearch />}
+            loading={searching}
+            disabled={loading}
+            size='small'
+            className='flex-1 md:flex-initial md:w-auto'
+          >
+            {t('查询')}
+          </Button>
+
+          <Button
+            type='tertiary'
+            icon={<IconRefresh />}
+            onClick={handleReset}
+            disabled={loading || searching}
+            size='small'
+            className='flex-1 md:flex-initial md:w-auto'
+          >
+            {t('重置')}
+          </Button>
+
+          <Button
+            type='tertiary'
+            onClick={() => setShowColumnSelector(true)}
+            size='small'
+            className='flex-1 md:flex-initial md:w-auto'
+          >
+            {t('列设置')}
+          </Button>
+        </div>
+      </div>
+    </Form>
+  );
+};
+
+export default DeploymentsFilters;

web/src/components/table/model-deployments/DeploymentsTable.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useMemo, useState } from 'react';
+import { Empty } from '@douyinfe/semi-ui';
+import CardTable from '../../common/ui/CardTable';
+import {
+  IllustrationNoResult,
+  IllustrationNoResultDark,
+} from '@douyinfe/semi-illustrations';
+import { getDeploymentsColumns } from './DeploymentsColumnDefs';
+
+// Import all the new modals
+import ViewLogsModal from './modals/ViewLogsModal';
+import ExtendDurationModal from './modals/ExtendDurationModal';
+import ViewDetailsModal from './modals/ViewDetailsModal';
+import UpdateConfigModal from './modals/UpdateConfigModal';
+import ConfirmationDialog from './modals/ConfirmationDialog';
+
+const DeploymentsTable = (deploymentsData) => {
+  const {
+    deployments,
+    loading,
+    searching,
+    activePage,
+    pageSize,
+    deploymentCount,
+    compactMode,
+    visibleColumns,
+    setSelectedKeys,
+    handlePageChange,
+    handlePageSizeChange,
+    handleRow,
+    t,
+    COLUMN_KEYS,
+    // Column functions and data
+    startDeployment,
+    restartDeployment,
+    deleteDeployment,
+    syncDeploymentToChannel,
+    setEditingDeployment,
+    setShowEdit,
+    refresh,
+  } = deploymentsData;
+
+  // Modal states
+  const [selectedDeployment, setSelectedDeployment] = useState(null);
+  const [showLogsModal, setShowLogsModal] = useState(false);
+  const [showExtendModal, setShowExtendModal] = useState(false);
+  const [showDetailsModal, setShowDetailsModal] = useState(false);
+  const [showConfigModal, setShowConfigModal] = useState(false);
+  const [showConfirmDialog, setShowConfirmDialog] = useState(false);
+  const [confirmOperation, setConfirmOperation] = useState('delete');
+
+  // Enhanced modal handlers
+  const handleViewLogs = (deployment) => {
+    setSelectedDeployment(deployment);
+    setShowLogsModal(true);
+  };
+
+  const handleExtendDuration = (deployment) => {
+    setSelectedDeployment(deployment);
+    setShowExtendModal(true);
+  };
+
+  const handleViewDetails = (deployment) => {
+    setSelectedDeployment(deployment);
+    setShowDetailsModal(true);
+  };
+
+  const handleUpdateConfig = (deployment, operation = 'update') => {
+    setSelectedDeployment(deployment);
+    if (operation === 'delete' || operation === 'destroy') {
+      setConfirmOperation(operation);
+      setShowConfirmDialog(true);
+    } else {
+      setShowConfigModal(true);
+    }
+  };
+
+  const handleConfirmAction = () => {
+    if (selectedDeployment && confirmOperation === 'delete') {
+      deleteDeployment(selectedDeployment.id);
+    }
+    setShowConfirmDialog(false);
+    setSelectedDeployment(null);
+  };
+
+  const handleModalSuccess = (updatedDeployment) => {
+    // Refresh the deployments list
+    refresh?.();
+  };
+
+  // Get all columns
+  const allColumns = useMemo(() => {
+    return getDeploymentsColumns({
+      t,
+      COLUMN_KEYS,
+      startDeployment,
+      restartDeployment,
+      deleteDeployment,
+      setEditingDeployment,
+      setShowEdit,
+      refresh,
+      activePage,
+      deployments,
+      // Enhanced handlers
+      onViewLogs: handleViewLogs,
+      onExtendDuration: handleExtendDuration,
+      onViewDetails: handleViewDetails,
+      onUpdateConfig: handleUpdateConfig,
+      onSyncToChannel: syncDeploymentToChannel,
+    });
+  }, [
+    t,
+    COLUMN_KEYS,
+    startDeployment,
+    restartDeployment,
+    deleteDeployment,
+    syncDeploymentToChannel,
+    setEditingDeployment,
+    setShowEdit,
+    refresh,
+    activePage,
+    deployments,
+  ]);
+
+  // Filter columns based on visibility settings
+  const getVisibleColumns = () => {
+    return allColumns.filter((column) => visibleColumns[column.key]);
+  };
+
+  const visibleColumnsList = useMemo(() => {
+    return getVisibleColumns();
+  }, [visibleColumns, allColumns]);
+
+  const tableColumns = useMemo(() => {
+    if (compactMode) {
+      // In compact mode, remove fixed columns and adjust widths
+      return visibleColumnsList.map(({ fixed, width, ...rest }) => ({
+        ...rest,
+        width: width ? Math.max(width * 0.8, 80) : undefined, // Reduce width by 20% but keep minimum
+      }));
+    }
+    return visibleColumnsList;
+  }, [compactMode, visibleColumnsList]);
+
+  return (
+    <>
+      <CardTable
+        columns={tableColumns}
+        dataSource={deployments}
+        scroll={compactMode ? { x: 800 } : { x: 1200 }}
+        pagination={{
+          currentPage: activePage,
+          pageSize: pageSize,
+          total: deploymentCount,
+          pageSizeOpts: [10, 20, 50, 100],
+          showSizeChanger: true,
+          onPageSizeChange: handlePageSizeChange,
+          onPageChange: handlePageChange,
+        }}
+        hidePagination={true}
+        expandAllRows={false}
+        onRow={handleRow}
+        rowSelection={{
+          onChange: (selectedRowKeys, selectedRows) => {
+            setSelectedKeys(selectedRows);
+          },
+        }}
+        empty={
+          <Empty
+            image={<IllustrationNoResult style={{ width: 150, height: 150 }} />}
+            darkModeImage={
+              <IllustrationNoResultDark style={{ width: 150, height: 150 }} />
+            }
+            description={t('搜索无结果')}
+            style={{ padding: 30 }}
+          />
+        }
+        className='rounded-xl overflow-hidden'
+        size='middle'
+        loading={loading || searching}
+      />
+
+      {/* Enhanced Modals */}
+      <ViewLogsModal
+        visible={showLogsModal}
+        onCancel={() => setShowLogsModal(false)}
+        deployment={selectedDeployment}
+        t={t}
+      />
+
+      <ExtendDurationModal
+        visible={showExtendModal}
+        onCancel={() => setShowExtendModal(false)}
+        deployment={selectedDeployment}
+        onSuccess={handleModalSuccess}
+        t={t}
+      />
+
+      <ViewDetailsModal
+        visible={showDetailsModal}
+        onCancel={() => setShowDetailsModal(false)}
+        deployment={selectedDeployment}
+        t={t}
+      />
+
+      <UpdateConfigModal
+        visible={showConfigModal}
+        onCancel={() => setShowConfigModal(false)}
+        deployment={selectedDeployment}
+        onSuccess={handleModalSuccess}
+        t={t}
+      />
+
+      <ConfirmationDialog
+        visible={showConfirmDialog}
+        onCancel={() => setShowConfirmDialog(false)}
+        onConfirm={handleConfirmAction}
+        title={t('确认操作')}
+        type="danger"
+        deployment={selectedDeployment}
+        operation={confirmOperation}
+        t={t}
+      />
+    </>
+  );
+};
+
+export default DeploymentsTable;

web/src/components/table/model-deployments/index.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useState } from 'react';
+import CardPro from '../../common/ui/CardPro';
+import DeploymentsTable from './DeploymentsTable';
+import DeploymentsActions from './DeploymentsActions';
+import DeploymentsFilters from './DeploymentsFilters';
+import EditDeploymentModal from './modals/EditDeploymentModal';
+import CreateDeploymentModal from './modals/CreateDeploymentModal';
+import ColumnSelectorModal from './modals/ColumnSelectorModal';
+import { useDeploymentsData } from '../../../hooks/model-deployments/useDeploymentsData';
+import { useIsMobile } from '../../../hooks/common/useIsMobile';
+import { createCardProPagination } from '../../../helpers/utils';
+
+const DeploymentsPage = () => {
+  const deploymentsData = useDeploymentsData();
+  const isMobile = useIsMobile();
+  
+  // Create deployment modal state
+  const [showCreateModal, setShowCreateModal] = useState(false);
+
+  const {
+    // Edit state
+    showEdit,
+    editingDeployment,
+    closeEdit,
+    refresh,
+
+    // Actions state
+    selectedKeys,
+    setSelectedKeys,
+    setEditingDeployment,
+    setShowEdit,
+    batchDeleteDeployments,
+
+    // Filters state
+    formInitValues,
+    setFormApi,
+    searchDeployments,
+    loading,
+    searching,
+
+    // Column visibility
+    showColumnSelector,
+    setShowColumnSelector,
+    visibleColumns,
+    setVisibleColumns,
+    COLUMN_KEYS,
+
+    // Description state
+    compactMode,
+    setCompactMode,
+
+    // Translation
+    t,
+  } = deploymentsData;
+
+  return (
+    <>
+      {/* Modals */}
+      <EditDeploymentModal
+        refresh={refresh}
+        editingDeployment={editingDeployment}
+        visible={showEdit}
+        handleClose={closeEdit}
+      />
+      
+      <CreateDeploymentModal
+        visible={showCreateModal}
+        onCancel={() => setShowCreateModal(false)}
+        onSuccess={refresh}
+        t={t}
+      />
+
+      <ColumnSelectorModal
+        visible={showColumnSelector}
+        onCancel={() => setShowColumnSelector(false)}
+        visibleColumns={visibleColumns}
+        onVisibleColumnsChange={setVisibleColumns}
+        columnKeys={COLUMN_KEYS}
+        t={t}
+      />
+
+      {/* Main Content */}
+      <CardPro
+        type='type3'
+        actionsArea={
+          <div className='flex flex-col md:flex-row justify-between items-center gap-2 w-full'>
+            <DeploymentsActions
+              selectedKeys={selectedKeys}
+              setSelectedKeys={setSelectedKeys}
+              setEditingDeployment={setEditingDeployment}
+              setShowEdit={setShowEdit}
+              batchDeleteDeployments={batchDeleteDeployments}
+              compactMode={compactMode}
+              setCompactMode={setCompactMode}
+              showCreateModal={showCreateModal}
+              setShowCreateModal={setShowCreateModal}
+              setShowColumnSelector={setShowColumnSelector}
+              t={t}
+            />
+            <DeploymentsFilters
+              formInitValues={formInitValues}
+              setFormApi={setFormApi}
+              searchDeployments={searchDeployments}
+              loading={loading}
+              searching={searching}
+              setShowColumnSelector={setShowColumnSelector}
+              t={t}
+            />
+          </div>
+        }
+        paginationArea={createCardProPagination({
+          currentPage: deploymentsData.activePage,
+          pageSize: deploymentsData.pageSize,
+          total: deploymentsData.deploymentCount,
+          onPageChange: deploymentsData.handlePageChange,
+          onPageSizeChange: deploymentsData.handlePageSizeChange,
+          isMobile: isMobile,
+          t: deploymentsData.t,
+        })}
+        t={deploymentsData.t}
+      >
+        <DeploymentsTable {...deploymentsData} />
+      </CardPro>
+    </>
+  );
+};
+
+export default DeploymentsPage;

web/src/components/table/model-deployments/modals/ColumnSelectorModal.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useMemo } from 'react';
+import { Modal, Button, Checkbox } from '@douyinfe/semi-ui';
+
+const ColumnSelectorModal = ({
+  visible,
+  onCancel,
+  visibleColumns,
+  onVisibleColumnsChange,
+  columnKeys,
+  t,
+}) => {
+  const columnOptions = useMemo(
+    () => [
+      { key: columnKeys.container_name, label: t('容器名称'), required: true },
+      { key: columnKeys.status, label: t('状态') },
+      { key: columnKeys.time_remaining, label: t('剩余时间') },
+      { key: columnKeys.hardware_info, label: t('硬件配置') },
+      { key: columnKeys.created_at, label: t('创建时间') },
+      { key: columnKeys.actions, label: t('操作'), required: true },
+    ],
+    [columnKeys, t],
+  );
+
+  const handleColumnVisibilityChange = (key, checked) => {
+    const column = columnOptions.find((option) => option.key === key);
+    if (column?.required) return;
+    onVisibleColumnsChange({
+      ...visibleColumns,
+      [key]: checked,
+    });
+  };
+
+  const handleSelectAll = (checked) => {
+    const updated = { ...visibleColumns };
+    columnOptions.forEach(({ key, required }) => {
+      updated[key] = required ? true : checked;
+    });
+    onVisibleColumnsChange(updated);
+  };
+
+  const handleReset = () => {
+    const defaults = columnOptions.reduce((acc, { key }) => {
+      acc[key] = true;
+      return acc;
+    }, {});
+    onVisibleColumnsChange({
+      ...visibleColumns,
+      ...defaults,
+    });
+  };
+
+  const allSelected = columnOptions.every(
+    ({ key, required }) => required || visibleColumns[key],
+  );
+  const indeterminate =
+    columnOptions.some(
+      ({ key, required }) => !required && visibleColumns[key],
+    ) && !allSelected;
+
+  const handleConfirm = () => onCancel();
+
+  return (
+    <Modal
+      title={t('列设置')}
+      visible={visible}
+      onCancel={onCancel}
+      footer={
+        <div className='flex justify-end gap-2'>
+          <Button onClick={handleReset}>{t('重置')}</Button>
+          <Button onClick={onCancel}>{t('取消')}</Button>
+          <Button type='primary' onClick={handleConfirm}>
+            {t('确定')}
+          </Button>
+        </div>
+      }
+    >
+      <div style={{ marginBottom: 20 }}>
+        <Checkbox
+          checked={allSelected}
+          indeterminate={indeterminate}
+          onChange={(e) => handleSelectAll(e.target.checked)}
+        >
+          {t('全选')}
+        </Checkbox>
+      </div>
+      <div
+        className='flex flex-wrap max-h-96 overflow-y-auto rounded-lg p-4'
+        style={{ border: '1px solid var(--semi-color-border)' }}
+      >
+        {columnOptions.map(({ key, label, required }) => (
+          <div key={key} className='w-1/2 mb-4 pr-2'>
+            <Checkbox
+              checked={!!visibleColumns[key]}
+              disabled={required}
+              onChange={(e) =>
+                handleColumnVisibilityChange(key, e.target.checked)
+              }
+            >
+              {label}
+            </Checkbox>
+          </div>
+        ))}
+      </div>
+    </Modal>
+  );
+};
+
+export default ColumnSelectorModal;

web/src/components/table/model-deployments/modals/ConfirmationDialog.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useState, useEffect } from 'react';
+import { Modal, Typography, Input } from '@douyinfe/semi-ui';
+
+const { Text } = Typography;
+
+const ConfirmationDialog = ({
+  visible,
+  onCancel,
+  onConfirm,
+  title,
+  type = 'danger',
+  deployment,
+  t,
+  loading = false
+}) => {
+  const [confirmText, setConfirmText] = useState('');
+
+  useEffect(() => {
+    if (!visible) {
+      setConfirmText('');
+    }
+  }, [visible]);
+
+  const requiredText = deployment?.container_name || deployment?.id || '';
+  const isConfirmed = Boolean(requiredText) && confirmText === requiredText;
+
+  const handleCancel = () => {
+    setConfirmText('');
+    onCancel();
+  };
+
+  const handleConfirm = () => {
+    if (isConfirmed) {
+      onConfirm();
+      handleCancel();
+    }
+  };
+
+  return (
+    <Modal
+      title={title}
+      visible={visible}
+      onCancel={handleCancel}
+      onOk={handleConfirm}
+      okText={t('确认')}
+      cancelText={t('取消')}
+      okButtonProps={{
+        disabled: !isConfirmed,
+        type: type === 'danger' ? 'danger' : 'primary',
+        loading
+      }}
+      width={480}
+    >
+      <div className="space-y-4">
+        <Text type="danger" strong>
+          {t('此操作具有风险，请确认要继续执行')}。
+        </Text>
+        <Text>
+          {t('请输入部署名称以完成二次确认')}：
+          <Text code className="ml-1">
+            {requiredText || t('未知部署')}
+          </Text>
+        </Text>
+        <Input
+          value={confirmText}
+          onChange={setConfirmText}
+          placeholder={t('再次输入部署名称')}
+          autoFocus
+        />
+        {!isConfirmed && confirmText && (
+          <Text type="danger" size="small">
+            {t('部署名称不匹配，请检查后重新输入')}
+          </Text>
+        )}
+      </div>
+    </Modal>
+  );
+};
+
+export default ConfirmationDialog;

web/src/components/table/model-deployments/modals/EditDeploymentModal.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React, { useState, useEffect, useRef } from 'react';
+import {
+  SideSheet,
+  Form,
+  Button,
+  Space,
+  Spin,
+  Typography,
+  Card,
+  InputNumber,
+  Select,
+  Input,
+  Row,
+  Col,
+  Divider,
+  Tag,
+} from '@douyinfe/semi-ui';
+import { Save, X, Server } from 'lucide-react';
+import { API, showError, showSuccess } from '../../../../helpers';
+import { useTranslation } from 'react-i18next';
+import { useIsMobile } from '../../../../hooks/common/useIsMobile';
+
+const { Text, Title } = Typography;
+
+const EditDeploymentModal = ({
+  refresh,
+  editingDeployment,
+  visible,
+  handleClose,
+}) => {
+  const { t } = useTranslation();
+  const isMobile = useIsMobile();
+  const [loading, setLoading] = useState(false);
+  const [models, setModels] = useState([]);
+  const [loadingModels, setLoadingModels] = useState(false);
+  const formRef = useRef();
+
+  const isEdit = Boolean(editingDeployment?.id);
+  const title = t('重命名部署');
+
+  // Resource configuration options
+  const cpuOptions = [
+    { label: '0.5 Core', value: '0.5' },
+    { label: '1 Core', value: '1' },
+    { label: '2 Cores', value: '2' },
+    { label: '4 Cores', value: '4' },
+    { label: '8 Cores', value: '8' },
+  ];
+
+  const memoryOptions = [
+    { label: '1GB', value: '1Gi' },
+    { label: '2GB', value: '2Gi' },
+    { label: '4GB', value: '4Gi' },
+    { label: '8GB', value: '8Gi' },
+    { label: '16GB', value: '16Gi' },
+    { label: '32GB', value: '32Gi' },
+  ];
+
+  const gpuOptions = [
+    { label: t('无GPU'), value: '' },
+    { label: '1 GPU', value: '1' },
+    { label: '2 GPUs', value: '2' },
+    { label: '4 GPUs', value: '4' },
+  ];
+
+  // Load available models
+  const loadModels = async () => {
+    setLoadingModels(true);
+    try {
+      const res = await API.get('/api/models/?page_size=1000');
+      if (res.data.success) {
+        const items = res.data.data.items || res.data.data || [];
+        const modelOptions = items.map((model) => ({
+          label: `${model.model_name} (${model.vendor?.name || 'Unknown'})`,
+          value: model.model_name,
+          model_id: model.id,
+        }));
+        setModels(modelOptions);
+      }
+    } catch (error) {
+      console.error('Failed to load models:', error);
+      showError(t('加载模型列表失败'));
+    }
+    setLoadingModels(false);
+  };
+
+  // Form submission
+  const handleSubmit = async (values) => {
+    if (!isEdit || !editingDeployment?.id) {
+      showError(t('无效的部署信息'));
+      return;
+    }
+
+    setLoading(true);
+    try {
+      // Only handle name update for now
+      const res = await API.put(
+        `/api/deployments/${editingDeployment.id}/name`,
+        {
+          name: values.deployment_name,
+        },
+      );
+
+      if (res.data.success) {
+        showSuccess(t('部署名称更新成功'));
+        handleClose();
+        refresh();
+      } else {
+        showError(res.data.message || t('更新失败'));
+      }
+    } catch (error) {
+      console.error('Submit error:', error);
+      showError(t('更新失败，请检查输入信息'));
+    }
+    setLoading(false);
+  };
+
+  // Load models when modal opens
+  useEffect(() => {
+    if (visible) {
+      loadModels();
+    }
+  }, [visible]);
+
+  // Set form values when editing
+  useEffect(() => {
+    if (formRef.current && editingDeployment && visible && isEdit) {
+      formRef.current.setValues({
+        deployment_name: editingDeployment.deployment_name || '',
+      });
+    }
+  }, [editingDeployment, visible, isEdit]);
+
+  return (
+    <SideSheet
+      title={
+        <div className='flex items-center gap-2'>
+          <Server size={20} />
+          <span>{title}</span>
+        </div>
+      }
+      visible={visible}
+      onCancel={handleClose}
+      width={isMobile ? '100%' : 600}
+      bodyStyle={{ padding: 0 }}
+      maskClosable={false}
+      closeOnEsc={true}
+    >
+      <div className='p-6 h-full overflow-auto'>
+        <Spin spinning={loading} style={{ width: '100%' }}>
+          <Form
+            ref={formRef}
+            onSubmit={handleSubmit}
+            labelPosition='top'
+            style={{ width: '100%' }}
+          >
+            <Card>
+              <Title heading={5} style={{ marginBottom: 16 }}>
+                {t('修改部署名称')}
+              </Title>
+
+              <Row gutter={16}>
+                <Col span={24}>
+                  <Form.Input
+                    field='deployment_name'
+                    label={t('部署名称')}
+                    placeholder={t('请输入新的部署名称')}
+                    rules={[
+                      { required: true, message: t('请输入部署名称') },
+                      {
+                        pattern: /^[a-zA-Z0-9-_\u4e00-\u9fa5]+$/,
+                        message: t(
+                          '部署名称只能包含字母、数字、横线、下划线和中文',
+                        ),
+                      },
+                    ]}
+                  />
+                </Col>
+              </Row>
+
+              {isEdit && (
+                <div className='mt-4 p-3 bg-gray-50 rounded'>
+                  <Text type='secondary'>{t('部署ID')}: </Text>
+                  <Text code>{editingDeployment.id}</Text>
+                  <br />
+                  <Text type='secondary'>{t('当前状态')}: </Text>
+                  <Tag
+                    color={
+                      editingDeployment.status === 'running' ? 'green' : 'grey'
+                    }
+                  >
+                    {editingDeployment.status}
+                  </Tag>
+                </div>
+              )}
+            </Card>
+          </Form>
+        </Spin>
+      </div>
+
+      <div className='p-4 border-t border-gray-200 bg-gray-50 flex justify-end'>
+        <Space>
+          <Button theme='outline' onClick={handleClose} disabled={loading}>
+            <X size={16} className='mr-1' />
+            {t('取消')}
+          </Button>
+          <Button
+            theme='solid'
+            type='primary'
+            loading={loading}
+            onClick={() => formRef.current?.submitForm()}
+          >
+            <Save size={16} className='mr-1' />
+            {isEdit ? t('更新') : t('创建')}
+          </Button>
+        </Space>
+      </div>
+    </SideSheet>
+  );
+};
+
+export default EditDeploymentModal;

web/src/helpers/render.jsx

@@ -73,6 +73,7 @@ import {
   Settings,
   CircleUser,
   Package,
+  Server,
 } from 'lucide-react';
 
 // 获取侧边栏Lucide图标组件
@@ -114,6 +115,8 @@ export function getLucideIcon(key, selected = false) {
       return <User {...commonProps} color={iconColor} />;
     case 'models':
       return <Package {...commonProps} color={iconColor} />;
+    case 'deployment':
+      return <Server {...commonProps} color={iconColor} />;
     case 'setting':
       return <Settings {...commonProps} color={iconColor} />;
     default:

web/src/hooks/channels/useChannelsData.jsx

@@ -35,7 +35,7 @@ import {
 } from '../../constants';
 import { useIsMobile } from '../common/useIsMobile';
 import { useTableCompactMode } from '../common/useTableCompactMode';
-import { Modal } from '@douyinfe/semi-ui';
+import { Modal, Button } from '@douyinfe/semi-ui';
 
 export const useChannelsData = () => {
   const { t } = useTranslation();
@@ -775,6 +775,67 @@ export const useChannelsData = () => {
     }
   };
 
+  const checkOllamaVersion = async (record) => {
+    try {
+      const res = await API.get(`/api/channel/ollama/version/${record.id}`);
+      const { success, message, data } = res.data;
+
+      if (success) {
+        const version = data?.version || '-';
+        const infoMessage = t('当前 Ollama 版本为 ${version}').replace(
+          '${version}',
+          version,
+        );
+
+        const handleCopyVersion = async () => {
+          if (!version || version === '-') {
+            showInfo(t('暂无可复制的版本信息'));
+            return;
+          }
+
+          const copied = await copy(version);
+          if (copied) {
+            showSuccess(t('已复制版本号'));
+          } else {
+            showError(t('复制失败，请手动复制'));
+          }
+        };
+
+        Modal.info({
+          title: t('Ollama 版本信息'),
+          content: infoMessage,
+          centered: true,
+          footer: (
+            <div className='flex justify-end gap-2'>
+              <Button type='tertiary' onClick={handleCopyVersion}>
+                {t('复制版本号')}
+              </Button>
+              <Button
+                type='primary'
+                theme='solid'
+                onClick={() => Modal.destroyAll()}
+              >
+                {t('关闭')}
+              </Button>
+            </div>
+          ),
+          hasCancel: false,
+          hasOk: false,
+          closable: true,
+          maskClosable: true,
+        });
+      } else {
+        showError(message || t('获取 Ollama 版本失败'));
+      }
+    } catch (error) {
+      const errMsg =
+        error?.response?.data?.message ||
+        error?.message ||
+        t('获取 Ollama 版本失败');
+      showError(errMsg);
+    }
+  };
+
   // Test channel - 单个模型测试，参考旧版实现
   const testChannel = async (record, model, endpointType = '') => {
     const testKey = `${record.id}-${model}`;
@@ -1132,6 +1193,7 @@ export const useChannelsData = () => {
     updateAllChannelsBalance,
     updateChannelBalance,
     fixChannelsAbilities,
+    checkOllamaVersion,
     testChannel,
     batchTestModels,
     handleCloseModal,

web/src/hooks/common/useSidebar.js

@@ -61,6 +61,7 @@ export const useSidebar = () => {
       enabled: true,
       channel: true,
       models: true,
+      deployment: true,
       redemption: true,
       user: true,
       setting: true,

web/src/hooks/model-deployments/useDeploymentResources.js

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import { useState, useCallback } from 'react';
+import { API } from '../../helpers';
+import { showError } from '../../helpers';
+
+export const useDeploymentResources = () => {
+  const [hardwareTypes, setHardwareTypes] = useState([]);
+  const [hardwareTotalAvailable, setHardwareTotalAvailable] = useState(0);
+  const [locations, setLocations] = useState([]);
+  const [locationsTotalAvailable, setLocationsTotalAvailable] = useState(0);
+  const [availableReplicas, setAvailableReplicas] = useState([]);
+  const [priceEstimation, setPriceEstimation] = useState(null);
+
+  const [loadingHardware, setLoadingHardware] = useState(false);
+  const [loadingLocations, setLoadingLocations] = useState(false);
+  const [loadingReplicas, setLoadingReplicas] = useState(false);
+  const [loadingPrice, setLoadingPrice] = useState(false);
+
+  const fetchHardwareTypes = useCallback(async () => {
+    try {
+      setLoadingHardware(true);
+      const response = await API.get('/api/deployments/hardware-types');
+      if (response.data.success) {
+        const { hardware_types: hardwareList = [], total_available } = response.data.data || {};
+        const normalizedHardware = hardwareList.map((hardware) => {
+          const availableCountValue = Number(hardware.available_count);
+          const availableCount = Number.isNaN(availableCountValue) ? 0 : availableCountValue;
+          const availableBool =
+            typeof hardware.available === 'boolean'
+              ? hardware.available
+              : availableCount > 0;
+
+          return {
+            ...hardware,
+            available: availableBool,
+            available_count: availableCount,
+          };
+        });
+
+        const providedTotal = Number(total_available);
+        const fallbackTotal = normalizedHardware.reduce(
+          (acc, item) => acc + (Number.isNaN(item.available_count) ? 0 : item.available_count),
+          0,
+        );
+        const hasProvidedTotal =
+          total_available !== undefined &&
+          total_available !== null &&
+          total_available !== '' &&
+          !Number.isNaN(providedTotal);
+
+        setHardwareTypes(normalizedHardware);
+        setHardwareTotalAvailable(
+          hasProvidedTotal ? providedTotal : fallbackTotal,
+        );
+        return normalizedHardware;
+      } else {
+        showError('获取硬件类型失败: ' + response.data.message);
+        setHardwareTotalAvailable(0);
+        return [];
+      }
+    } catch (error) {
+      showError('获取硬件类型失败: ' + error.message);
+      setHardwareTotalAvailable(0);
+      return [];
+    } finally {
+      setLoadingHardware(false);
+    }
+  }, []);
+
+  const fetchLocations = useCallback(async () => {
+    try {
+      setLoadingLocations(true);
+      const response = await API.get('/api/deployments/locations');
+      if (response.data.success) {
+        const { locations: locationsList = [], total } = response.data.data || {};
+        const normalizedLocations = locationsList.map((location) => {
+          const iso2 = (location.iso2 || '').toString().toUpperCase();
+          const availableValue = Number(location.available);
+          const available = Number.isNaN(availableValue) ? 0 : availableValue;
+
+          return {
+            ...location,
+            iso2,
+            available,
+          };
+        });
+        const providedTotal = Number(total);
+        const fallbackTotal = normalizedLocations.reduce(
+          (acc, item) => acc + (Number.isNaN(item.available) ? 0 : item.available),
+          0,
+        );
+        const hasProvidedTotal =
+          total !== undefined &&
+          total !== null &&
+          total !== '' &&
+          !Number.isNaN(providedTotal);
+
+        setLocations(normalizedLocations);
+        setLocationsTotalAvailable(
+          hasProvidedTotal ? providedTotal : fallbackTotal,
+        );
+        return normalizedLocations;
+      } else {
+        showError('获取部署位置失败: ' + response.data.message);
+        setLocationsTotalAvailable(0);
+        return [];
+      }
+    } catch (error) {
+      showError('获取部署位置失败: ' + error.message);
+      setLocationsTotalAvailable(0);
+      return [];
+    } finally {
+      setLoadingLocations(false);
+    }
+  }, []);
+
+  const fetchAvailableReplicas = useCallback(async (hardwareId, gpuCount = 1) => {
+    if (!hardwareId) {
+      setAvailableReplicas([]);
+      return [];
+    }
+
+    try {
+      setLoadingReplicas(true);
+      const response = await API.get(
+        `/api/deployments/available-replicas?hardware_id=${hardwareId}&gpu_count=${gpuCount}`
+      );
+      if (response.data.success) {
+        const replicas = response.data.data.replicas || [];
+        setAvailableReplicas(replicas);
+        return replicas;
+      } else {
+        showError('获取可用资源失败: ' + response.data.message);
+        setAvailableReplicas([]);
+        return [];
+      }
+    } catch (error) {
+      console.error('Load available replicas error:', error);
+      setAvailableReplicas([]);
+      return [];
+    } finally {
+      setLoadingReplicas(false);
+    }
+  }, []);
+
+  const calculatePrice = useCallback(async (params) => {
+    const {
+      locationIds,
+      hardwareId,
+      gpusPerContainer,
+      durationHours,
+      replicaCount
+    } = params;
+
+    if (!locationIds?.length || !hardwareId || !gpusPerContainer || !durationHours || !replicaCount) {
+      setPriceEstimation(null);
+      return null;
+    }
+
+    try {
+      setLoadingPrice(true);
+      const requestData = {
+        location_ids: locationIds,
+        hardware_id: hardwareId,
+        gpus_per_container: gpusPerContainer,
+        duration_hours: durationHours,
+        replica_count: replicaCount,
+      };
+
+      const response = await API.post('/api/deployments/price-estimation', requestData);
+      if (response.data.success) {
+        const estimation = response.data.data;
+        setPriceEstimation(estimation);
+        return estimation;
+      } else {
+        showError('价格计算失败: ' + response.data.message);
+        setPriceEstimation(null);
+        return null;
+      }
+    } catch (error) {
+      console.error('Price calculation error:', error);
+      setPriceEstimation(null);
+      return null;
+    } finally {
+      setLoadingPrice(false);
+    }
+  }, []);
+
+  const checkClusterNameAvailability = useCallback(async (name) => {
+    if (!name?.trim()) return false;
+
+    try {
+      const response = await API.get(`/api/deployments/check-name?name=${encodeURIComponent(name.trim())}`);
+      if (response.data.success) {
+        return response.data.data.available;
+      } else {
+        showError('检查名称可用性失败: ' + response.data.message);
+        return false;
+      }
+    } catch (error) {
+      console.error('Check cluster name availability error:', error);
+      return false;
+    }
+  }, []);
+
+  const createDeployment = useCallback(async (deploymentData) => {
+    try {
+      const response = await API.post('/api/deployments', deploymentData);
+      if (response.data.success) {
+        return response.data.data;
+      } else {
+        throw new Error(response.data.message || '创建部署失败');
+      }
+    } catch (error) {
+      throw error;
+    }
+  }, []);
+
+  return {
+    // Data
+    hardwareTypes,
+    hardwareTotalAvailable,
+    locations,
+    locationsTotalAvailable,
+    availableReplicas,
+    priceEstimation,
+
+    // Loading states
+    loadingHardware,
+    loadingLocations,
+    loadingReplicas,
+    loadingPrice,
+
+    // Functions
+    fetchHardwareTypes,
+    fetchLocations,
+    fetchAvailableReplicas,
+    calculatePrice,
+    checkClusterNameAvailability,
+    createDeployment,
+
+    // Clear functions
+    clearPriceEstimation: () => setPriceEstimation(null),
+    clearAvailableReplicas: () => setAvailableReplicas([]),
+  };
+};
+
+export default useDeploymentResources;

web/src/hooks/model-deployments/useEnhancedDeploymentActions.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import { useState } from 'react';
+import { API, showError, showSuccess } from '../../helpers';
+
+export const useEnhancedDeploymentActions = (t) => {
+  const [loading, setLoading] = useState({});
+
+  // Set loading state for specific operation
+  const setOperationLoading = (operation, deploymentId, isLoading) => {
+    setLoading(prev => ({
+      ...prev,
+      [`${operation}_${deploymentId}`]: isLoading
+    }));
+  };
+
+  // Get loading state for specific operation
+  const isOperationLoading = (operation, deploymentId) => {
+    return loading[`${operation}_${deploymentId}`] || false;
+  };
+
+  // Extend deployment duration
+  const extendDeployment = async (deploymentId, durationHours) => {
+    const operationKey = `extend_${deploymentId}`;
+    try {
+      setOperationLoading('extend', deploymentId, true);
+      
+      const response = await API.post(`/api/deployments/${deploymentId}/extend`, {
+        duration_hours: durationHours
+      });
+
+      if (response.data.success) {
+        showSuccess(t('容器时长延长成功'));
+        return response.data.data;
+      }
+    } catch (error) {
+      showError(t('延长时长失败') + ': ' + (error.response?.data?.message || error.message));
+      throw error;
+    } finally {
+      setOperationLoading('extend', deploymentId, false);
+    }
+  };
+
+  // Get deployment details
+  const getDeploymentDetails = async (deploymentId) => {
+    try {
+      setOperationLoading('details', deploymentId, true);
+      
+      const response = await API.get(`/api/deployments/${deploymentId}`);
+      
+      if (response.data.success) {
+        return response.data.data;
+      }
+    } catch (error) {
+      showError(t('获取详情失败') + ': ' + (error.response?.data?.message || error.message));
+      throw error;
+    } finally {
+      setOperationLoading('details', deploymentId, false);
+    }
+  };
+
+  // Get deployment logs
+  const getDeploymentLogs = async (deploymentId, options = {}) => {
+    try {
+      setOperationLoading('logs', deploymentId, true);
+      
+      const params = new URLSearchParams();
+      
+      if (options.containerId) params.append('container_id', options.containerId);
+      if (options.level) params.append('level', options.level);
+      if (options.limit) params.append('limit', options.limit.toString());
+      if (options.cursor) params.append('cursor', options.cursor);
+      if (options.follow) params.append('follow', 'true');
+      if (options.startTime) params.append('start_time', options.startTime);
+      if (options.endTime) params.append('end_time', options.endTime);
+      
+      const response = await API.get(`/api/deployments/${deploymentId}/logs?${params}`);
+      
+      if (response.data.success) {
+        return response.data.data;
+      }
+    } catch (error) {
+      showError(t('获取日志失败') + ': ' + (error.response?.data?.message || error.message));
+      throw error;
+    } finally {
+      setOperationLoading('logs', deploymentId, false);
+    }
+  };
+
+  // Update deployment configuration
+  const updateDeploymentConfig = async (deploymentId, config) => {
+    try {
+      setOperationLoading('config', deploymentId, true);
+      
+      const response = await API.put(`/api/deployments/${deploymentId}`, config);
+      
+      if (response.data.success) {
+        showSuccess(t('容器配置更新成功'));
+        return response.data.data;
+      }
+    } catch (error) {
+      showError(t('更新配置失败') + ': ' + (error.response?.data?.message || error.message));
+      throw error;
+    } finally {
+      setOperationLoading('config', deploymentId, false);
+    }
+  };
+
+  // Delete (destroy) deployment
+  const deleteDeployment = async (deploymentId) => {
+    try {
+      setOperationLoading('delete', deploymentId, true);
+      
+      const response = await API.delete(`/api/deployments/${deploymentId}`);
+      
+      if (response.data.success) {
+        showSuccess(t('容器销毁请求已提交'));
+        return response.data.data;
+      }
+    } catch (error) {
+      showError(t('销毁容器失败') + ': ' + (error.response?.data?.message || error.message));
+      throw error;
+    } finally {
+      setOperationLoading('delete', deploymentId, false);
+    }
+  };
+
+  // Update deployment name
+  const updateDeploymentName = async (deploymentId, newName) => {
+    try {
+      setOperationLoading('rename', deploymentId, true);
+      
+      const response = await API.put(`/api/deployments/${deploymentId}/name`, {
+        name: newName
+      });
+      
+      if (response.data.success) {
+        showSuccess(t('容器名称更新成功'));
+        return response.data.data;
+      }
+    } catch (error) {
+      showError(t('更新名称失败') + ': ' + (error.response?.data?.message || error.message));
+      throw error;
+    } finally {
+      setOperationLoading('rename', deploymentId, false);
+    }
+  };
+
+  // Batch operations
+  const batchDelete = async (deploymentIds) => {
+    try {
+      setOperationLoading('batch_delete', 'all', true);
+      
+      const results = await Promise.allSettled(
+        deploymentIds.map(id => deleteDeployment(id))
+      );
+      
+      const successful = results.filter(r => r.status === 'fulfilled').length;
+      const failed = results.filter(r => r.status === 'rejected').length;
+      
+      if (successful > 0) {
+        showSuccess(t('批量操作完成: {{success}}个成功, {{failed}}个失败', { 
+          success: successful, 
+          failed: failed 
+        }));
+      }
+      
+      return { successful, failed };
+    } catch (error) {
+      showError(t('批量操作失败') + ': ' + error.message);
+      throw error;
+    } finally {
+      setOperationLoading('batch_delete', 'all', false);
+    }
+  };
+
+  // Export logs
+  const exportLogs = async (deploymentId, options = {}) => {
+    try {
+      setOperationLoading('export_logs', deploymentId, true);
+      
+      const logs = await getDeploymentLogs(deploymentId, {
+        ...options,
+        limit: 10000 // Get more logs for export
+      });
+      
+      if (logs && logs.logs) {
+        const logText = logs.logs.map(log => 
+          `[${new Date(log.timestamp).toISOString()}] [${log.level}] ${log.source ? `[${log.source}] ` : ''}${log.message}`
+        ).join('\n');
+        
+        const blob = new Blob([logText], { type: 'text/plain' });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = `deployment-${deploymentId}-logs-${new Date().toISOString().split('T')[0]}.txt`;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+        
+        showSuccess(t('日志导出成功'));
+      }
+    } catch (error) {
+      showError(t('导出日志失败') + ': ' + error.message);
+      throw error;
+    } finally {
+      setOperationLoading('export_logs', deploymentId, false);
+    }
+  };
+
+  return {
+    // Actions
+    extendDeployment,
+    getDeploymentDetails,
+    getDeploymentLogs,
+    updateDeploymentConfig,
+    deleteDeployment,
+    updateDeploymentName,
+    batchDelete,
+    exportLogs,
+    
+    // Loading states
+    isOperationLoading,
+    loading,
+    
+    // Utility
+    setOperationLoading
+  };
+};
+
+export default useEnhancedDeploymentActions;
\ No newline at end of file

web/src/hooks/model-deployments/useModelDeploymentSettings.js

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import { useCallback, useEffect, useState } from 'react';
+import { API, toBoolean } from '../../helpers';
+
+export const useModelDeploymentSettings = () => {
+  const [loading, setLoading] = useState(true);
+  const [settings, setSettings] = useState({
+    'model_deployment.ionet.enabled': false,
+    'model_deployment.ionet.api_key': '',
+  });
+  const [connectionState, setConnectionState] = useState({
+    loading: false,
+    ok: null,
+    error: null,
+  });
+
+  const getSettings = async () => {
+    try {
+      setLoading(true);
+      const res = await API.get('/api/option/');
+      const { success, data } = res.data;
+      
+      if (success) {
+        const newSettings = {
+          'model_deployment.ionet.enabled': false,
+          'model_deployment.ionet.api_key': '',
+        };
+        
+        data.forEach((item) => {
+          if (item.key.endsWith('enabled')) {
+            newSettings[item.key] = toBoolean(item.value);
+          } else if (newSettings.hasOwnProperty(item.key)) {
+            newSettings[item.key] = item.value || '';
+          }
+        });
+        
+        setSettings(newSettings);
+      }
+    } catch (error) {
+      console.error('Failed to get model deployment settings:', error);
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    getSettings();
+  }, []);
+
+  const apiKey = settings['model_deployment.ionet.api_key'];
+  const isIoNetEnabled = settings['model_deployment.ionet.enabled'] && 
+                        apiKey && 
+                        apiKey.trim() !== '';
+
+  const buildConnectionError = (rawMessage, fallbackMessage = 'Connection failed') => {
+    const message = (rawMessage || fallbackMessage).trim();
+    const normalized = message.toLowerCase();
+    if (normalized.includes('expired') || normalized.includes('expire')) {
+      return { type: 'expired', message };
+    }
+    if (normalized.includes('invalid') || normalized.includes('unauthorized') || normalized.includes('api key')) {
+      return { type: 'invalid', message };
+    }
+    if (normalized.includes('network') || normalized.includes('timeout')) {
+      return { type: 'network', message };
+    }
+    return { type: 'unknown', message };
+  };
+
+  const testConnection = useCallback(async (apiKey) => {
+    const key = (apiKey || '').trim();
+    if (key === '') {
+      setConnectionState({ loading: false, ok: null, error: null });
+      return;
+    }
+
+    setConnectionState({ loading: true, ok: null, error: null });
+    try {
+      const response = await API.post(
+        '/api/deployments/test-connection',
+        { api_key: key },
+        { skipErrorHandler: true },
+      );
+
+      if (response?.data?.success) {
+        setConnectionState({ loading: false, ok: true, error: null });
+        return;
+      }
+
+      const message = response?.data?.message || 'Connection failed';
+      setConnectionState({ loading: false, ok: false, error: buildConnectionError(message) });
+    } catch (error) {
+      if (error?.code === 'ERR_NETWORK') {
+        setConnectionState({
+          loading: false,
+          ok: false,
+          error: { type: 'network', message: 'Network connection failed' },
+        });
+        return;
+      }
+      const rawMessage = error?.response?.data?.message || error?.message || 'Unknown error';
+      setConnectionState({ loading: false, ok: false, error: buildConnectionError(rawMessage, 'Connection failed') });
+    }
+  }, []);
+
+  useEffect(() => {
+    if (!loading && isIoNetEnabled) {
+      testConnection(apiKey);
+      return;
+    }
+    setConnectionState({ loading: false, ok: null, error: null });
+  }, [loading, isIoNetEnabled, apiKey, testConnection]);
+
+  return {
+    loading,
+    settings,
+    apiKey,
+    isIoNetEnabled,
+    refresh: getSettings,
+    connectionLoading: connectionState.loading,
+    connectionOk: connectionState.ok,
+    connectionError: connectionState.error,
+    testConnection,
+  };
+};

web/src/pages/ModelDeployment/index.jsx

+/*
+Copyright (C) 2025 QuantumNous
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+For commercial licensing, please contact support@quantumnous.com
+*/
+
+import React from 'react';
+import DeploymentsTable from '../../components/table/model-deployments';
+import DeploymentAccessGuard from '../../components/model-deployments/DeploymentAccessGuard';
+import { useModelDeploymentSettings } from '../../hooks/model-deployments/useModelDeploymentSettings';
+
+const ModelDeploymentPage = () => {
+  const {
+    loading,
+    isIoNetEnabled,
+    connectionLoading,
+    connectionOk,
+    connectionError,
+    apiKey,
+    testConnection,
+  } = useModelDeploymentSettings();
+
+  return (
+    <DeploymentAccessGuard
+      loading={loading}
+      isEnabled={isIoNetEnabled}
+      connectionLoading={connectionLoading}
+      connectionOk={connectionOk}
+      connectionError={connectionError}
+      onRetry={() => testConnection(apiKey)}
+    >
+      <div className='mt-[60px] px-2'>
+        <DeploymentsTable />
+      </div>
+    </DeploymentAccessGuard>
+  );
+};
+
+export default ModelDeploymentPage;

web/src/pages/Setting/Operation/SettingsSidebarModulesAdmin.jsx

@@ -62,6 +62,7 @@ export default function SettingsSidebarModulesAdmin(props) {
       enabled: true,
       channel: true,
       models: true,
+      deployment: true,
       redemption: true,
       user: true,
       setting: true,
@@ -121,6 +122,7 @@ export default function SettingsSidebarModulesAdmin(props) {
         enabled: true,
         channel: true,
         models: true,
+        deployment: true,
         redemption: true,
         user: true,
         setting: true,
@@ -188,6 +190,7 @@ export default function SettingsSidebarModulesAdmin(props) {
             enabled: true,
             channel: true,
             models: true,
+            deployment: true,
             redemption: true,
             user: true,
             setting: true,
@@ -249,6 +252,7 @@ export default function SettingsSidebarModulesAdmin(props) {
       modules: [
         { key: 'channel', title: t('渠道管理'), description: t('API渠道配置') },
         { key: 'models', title: t('模型管理'), description: t('AI模型配置') },
+        { key: 'deployment', title: t('模型部署'), description: t('模型部署管理') },
         {
           key: 'redemption',
           title: t('兑换码管理'),

web/src/pages/Setting/Personal/SettingsSidebarModulesUser.jsx

@@ -104,6 +104,7 @@ export default function SettingsSidebarModulesUser() {
         enabled: true,
         channel: isSidebarModuleAllowed('admin', 'channel'),
         models: isSidebarModuleAllowed('admin', 'models'),
+        deployment: isSidebarModuleAllowed('admin', 'deployment'),
         redemption: isSidebarModuleAllowed('admin', 'redemption'),
         user: isSidebarModuleAllowed('admin', 'user'),
         setting: isSidebarModuleAllowed('admin', 'setting'),

web/src/pages/Setting/index.jsx

@@ -32,6 +32,7 @@ import {
   MessageSquare,
   Palette,
   CreditCard,
+  Server,
 } from 'lucide-react';
 
 import SystemSetting from '../../components/settings/SystemSetting';
@@ -45,6 +46,7 @@ import RatioSetting from '../../components/settings/RatioSetting';
 import ChatsSetting from '../../components/settings/ChatsSetting';
 import DrawingSetting from '../../components/settings/DrawingSetting';
 import PaymentSetting from '../../components/settings/PaymentSetting';
+import ModelDeploymentSetting from '../../components/settings/ModelDeploymentSetting';
 
 const Setting = () => {
   const { t } = useTranslation();
@@ -137,6 +139,16 @@ const Setting = () => {
     panes.push({
       tab: (
         <span style={{ display: 'flex', alignItems: 'center', gap: '5px' }}>
+          <Server size={18} />
+          {t('模型部署设置')}
+        </span>
+      ),
+      content: <ModelDeploymentSetting />,
+      itemKey: 'model-deployment',
+    });
+    panes.push({
+      tab: (
+        <span style={{ display: 'flex', alignItems: 'center', gap: '5px' }}>
           <Cog size={18} />
           {t('系统设置')}
         </span>