refactor: split internal package into domain-based sub-packages

Split the flat internal/ package into auth, config, filter, handler,
logger, model, upstream, and version sub-packages by responsibility.

internal/{anonymous.go → auth/anonymous.go}

@@ -1,4 +1,4 @@
-package internal
+package auth
 
 import (
 	"encoding/json"

internal/{jwt.go → auth/jwt.go}

@@ -1,4 +1,4 @@
-package internal
+package auth
 
 import (
 	"encoding/base64"

internal/{signature.go → auth/signature.go}

@@ -1,4 +1,4 @@
-package internal
+package auth
 
 import (
 	"crypto/hmac"
@@ -20,14 +20,8 @@ func GenerateSignature(userID, requestID, userContent string, timestamp int64) s
 	signData := fmt.Sprintf("%s|%s|%d", requestInfo, contentBase64, timestamp)
 
 	period := timestamp / (5 * 60 * 1000)
-	// 两次加密均返回 hex 字符串
 	firstHmac := hmacSha256Hex([]byte("key-@@@@)))()((9))-xxxx&&&%%%%%"), fmt.Sprintf("%d", period))
 	signature := hmacSha256Hex([]byte(firstHmac), signData)
 
-	// LogDebug("[Signature] requestInfo=%s", requestInfo)
-	// LogDebug("[Signature] userContent=%s", userContent)
-	// LogDebug("[Signature] timestamp=%d", timestamp)
-	// LogDebug("[Signature] signature=%s", signature)
-
 	return signature
 }

internal/{config.go → config/config.go}

@@ -1,4 +1,4 @@
-package internal
+package config
 
 import (
 	"os"

internal/{models.go → filter/search.go}

@@ -1,231 +1,29 @@
-package internal
+package filter
 
 import (
 	"encoding/json"
 	"fmt"
 	"regexp"
 	"strings"
-)
-
-// 基础模型映射（不包含标签后缀）
-var BaseModelMapping = map[string]string{
-	"GLM-4.5":      "0727-360B-API",
-	"GLM-4.6":      "GLM-4-6-API-V1",
-	"GLM-4.7":      "glm-4.7",
-	"GLM-4.5-V":    "glm-4.5v",
-	"GLM-4.6-V":    "glm-4.6v",
-	"GLM-4.5-Air":  "0727-106B-API",
-	"0808-360B-DR": "0808-360B-DR",
-}
-
-// v1/models 返回的模型列表（不包含所有标签组合）
-var ModelList = []string{
-	"GLM-4.5",
-	"GLM-4.6",
-	"GLM-4.7",
-	"GLM-4.7-thinking",
-	"GLM-4.7-thinking-search",
-	"GLM-4.5-V",
-	"GLM-4.6-V",
-	"GLM-4.6-V-thinking",
-	"GLM-4.5-Air",
-	// "0808-360B-DR",
-}
-
-// 解析模型名称，提取基础模型名和标签
-// 支持 -thinking 和 -search 标签的任意排列组合
-func ParseModelName(model string) (baseModel string, enableThinking bool, enableSearch bool) {
-	enableThinking = false
-	enableSearch = false
-	baseModel = model
-
-	// 检查并移除 -thinking 和 -search 标签（任意顺序）
-	for {
-		if strings.HasSuffix(baseModel, "-thinking") {
-			enableThinking = true
-			baseModel = strings.TrimSuffix(baseModel, "-thinking")
-		} else if strings.HasSuffix(baseModel, "-search") {
-			enableSearch = true
-			baseModel = strings.TrimSuffix(baseModel, "-search")
-		} else {
-			break
-		}
-	}
-
-	return baseModel, enableThinking, enableSearch
-}
-
-func IsThinkingModel(model string) bool {
-	_, enableThinking, _ := ParseModelName(model)
-	return enableThinking
-}
-
-func IsSearchModel(model string) bool {
-	_, _, enableSearch := ParseModelName(model)
-	return enableSearch
-}
-
-func GetTargetModel(model string) string {
-	baseModel, _, _ := ParseModelName(model)
-	if target, ok := BaseModelMapping[baseModel]; ok {
-		return target
-	}
-	return model
-}
-
-// OpenAI 格式的消息内容项
-type ContentPart struct {
-	Type     string    `json:"type"`
-	Text     string    `json:"text,omitempty"`
-	ImageURL *ImageURL `json:"image_url,omitempty"`
-}
-
-type ImageURL struct {
-	URL string `json:"url"`
-}
-
-// Message 支持纯文本和多模态内容
-type Message struct {
-	Role    string      `json:"role"`
-	Content interface{} `json:"content"` // string 或 []ContentPart
-}
-
-// 解析消息内容，返回文本和图片URL列表
-func (m *Message) ParseContent() (text string, imageURLs []string) {
-	switch content := m.Content.(type) {
-	case string:
-		return content, nil
-	case []interface{}:
-		for _, item := range content {
-			if part, ok := item.(map[string]interface{}); ok {
-				partType, _ := part["type"].(string)
-				if partType == "text" {
-					if t, ok := part["text"].(string); ok {
-						text += t
-					}
-				} else if partType == "image_url" {
-					if imgURL, ok := part["image_url"].(map[string]interface{}); ok {
-						if url, ok := imgURL["url"].(string); ok {
-							imageURLs = append(imageURLs, url)
-						}
-					}
-				}
-			}
-		}
-	}
-	return text, imageURLs
-}
-
-// 转换为上游消息格式，支持多模态
-func (m *Message) ToUpstreamMessage(urlToFileID map[string]string) map[string]interface{} {
-	text, imageURLs := m.ParseContent()
 
-	// 无图片，返回纯文本
-	if len(imageURLs) == 0 {
-		return map[string]interface{}{
-			"role":    m.Role,
-			"content": text,
-		}
-	}
-
-	// 有图片，构建多模态内容
-	var content []interface{}
-	if text != "" {
-		content = append(content, map[string]interface{}{
-			"type": "text",
-			"text": text,
-		})
-	}
-	for _, imgURL := range imageURLs {
-		if fileID, ok := urlToFileID[imgURL]; ok {
-			content = append(content, map[string]interface{}{
-				"type": "image_url",
-				"image_url": map[string]interface{}{
-					"url": fileID,
-				},
-			})
-		}
-	}
-
-	return map[string]interface{}{
-		"role":    m.Role,
-		"content": content,
-	}
-}
-
-type ChatRequest struct {
-	Model    string    `json:"model"`
-	Messages []Message `json:"messages"`
-	Stream   bool      `json:"stream"`
-}
-
-type ChatCompletionChunk struct {
-	ID      string   `json:"id"`
-	Object  string   `json:"object"`
-	Created int64    `json:"created"`
-	Model   string   `json:"model"`
-	Choices []Choice `json:"choices"`
-}
-
-type Choice struct {
-	Index        int          `json:"index"`
-	Delta        Delta        `json:"delta,omitempty"`
-	Message      *MessageResp `json:"message,omitempty"`
-	FinishReason *string      `json:"finish_reason"`
-}
-
-type Delta struct {
-	Content          string `json:"content,omitempty"`
-	ReasoningContent string `json:"reasoning_content,omitempty"`
-}
-
-type MessageResp struct {
-	Role             string `json:"role"`
-	Content          string `json:"content"`
-	ReasoningContent string `json:"reasoning_content,omitempty"`
-}
-
-type ChatCompletionResponse struct {
-	ID      string   `json:"id"`
-	Object  string   `json:"object"`
-	Created int64    `json:"created"`
-	Model   string   `json:"model"`
-	Choices []Choice `json:"choices"`
-}
-
-type ModelsResponse struct {
-	Object string      `json:"object"`
-	Data   []ModelInfo `json:"data"`
-}
-
-type ModelInfo struct {
-	ID      string `json:"id"`
-	Object  string `json:"object"`
-	OwnedBy string `json:"owned_by"`
-}
+	"zai-proxy/internal/model"
+)
 
 var searchRefPattern = regexp.MustCompile(`【turn\d+search(\d+)】`)
 var searchRefPrefixPattern = regexp.MustCompile(`【(t(u(r(n(\d+(s(e(a(r(c(h(\d+)?)?)?)?)?)?)?)?)?)?)?)?$`)
 
-type SearchResult struct {
-	Title string `json:"title"`
-	URL   string `json:"url"`
-	Index int    `json:"index"`
-	RefID string `json:"ref_id"`
-}
-
 type SearchRefFilter struct {
 	buffer        string
-	searchResults map[string]SearchResult
+	searchResults map[string]model.SearchResult
 }
 
 func NewSearchRefFilter() *SearchRefFilter {
 	return &SearchRefFilter{
-		searchResults: make(map[string]SearchResult),
+		searchResults: make(map[string]model.SearchResult),
 	}
 }
 
-func (f *SearchRefFilter) AddSearchResults(results []SearchResult) {
+func (f *SearchRefFilter) AddSearchResults(results []model.SearchResult) {
 	for _, r := range results {
 		f.searchResults[r.RefID] = r
 	}
@@ -296,7 +94,7 @@ func (f *SearchRefFilter) GetSearchResultsMarkdown() string {
 		return ""
 	}
 
-	var results []SearchResult
+	var results []model.SearchResult
 	for _, r := range f.searchResults {
 		results = append(results, r)
 	}
@@ -321,7 +119,7 @@ func IsSearchResultContent(editContent string) bool {
 	return strings.Contains(editContent, `"search_result"`)
 }
 
-func ParseSearchResults(editContent string) []SearchResult {
+func ParseSearchResults(editContent string) []model.SearchResult {
 	searchResultKey := `"search_result":`
 	idx := strings.Index(editContent, searchResultKey)
 	if idx == -1 {
@@ -367,9 +165,9 @@ func ParseSearchResults(editContent string) []SearchResult {
 		return nil
 	}
 
-	var results []SearchResult
+	var results []model.SearchResult
 	for _, r := range rawResults {
-		results = append(results, SearchResult{
+		results = append(results, model.SearchResult{
 			Title: r.Title,
 			URL:   r.URL,
 			Index: r.Index,
@@ -384,17 +182,10 @@ func IsSearchToolCall(editContent string, phase string) bool {
 	if phase != "tool_call" {
 		return false
 	}
-	// tool_call 阶段包含 mcp 相关内容的都跳过
 	return strings.Contains(editContent, `"mcp"`) || strings.Contains(editContent, `mcp-server`)
 }
 
-type ImageSearchResult struct {
-	Title     string `json:"title"`
-	Link      string `json:"link"`
-	Thumbnail string `json:"thumbnail"`
-}
-
-func ParseImageSearchResults(editContent string) []ImageSearchResult {
+func ParseImageSearchResults(editContent string) []model.ImageSearchResult {
 	resultKey := `"result":`
 	idx := strings.Index(editContent, resultKey)
 	if idx == -1 {
@@ -457,7 +248,7 @@ func ParseImageSearchResults(editContent string) []ImageSearchResult {
 		return nil
 	}
 
-	var results []ImageSearchResult
+	var results []model.ImageSearchResult
 	for _, item := range rawResults {
 		if itemType, ok := item["type"].(string); ok && itemType == "text" {
 			if text, ok := item["text"].(string); ok {
@@ -472,8 +263,8 @@ func ParseImageSearchResults(editContent string) []ImageSearchResult {
 	return results
 }
 
-func parseImageSearchText(text string) ImageSearchResult {
-	result := ImageSearchResult{}
+func parseImageSearchText(text string) model.ImageSearchResult {
+	result := model.ImageSearchResult{}
 
 	if titleIdx := strings.Index(text, "Title: "); titleIdx != -1 {
 		titleStart := titleIdx + len("Title: ")
@@ -501,7 +292,7 @@ func parseImageSearchText(text string) ImageSearchResult {
 	return result
 }
 
-func FormatImageSearchResults(results []ImageSearchResult) string {
+func FormatImageSearchResults(results []model.ImageSearchResult) string {
 	if len(results) == 0 {
 		return ""
 	}

internal/filter/thinking.go

@@ -0,0 +1,85 @@
+package filter
+
+import "strings"
+
+type ThinkingFilter struct {
+	HasSeenFirstThinking bool
+	Buffer               string
+	LastOutputChunk      string
+	LastPhase            string
+	ThinkingRoundCount   int
+}
+
+func (f *ThinkingFilter) ProcessThinking(deltaContent string) string {
+	if !f.HasSeenFirstThinking {
+		f.HasSeenFirstThinking = true
+		if idx := strings.Index(deltaContent, "> "); idx != -1 {
+			deltaContent = deltaContent[idx+2:]
+		} else {
+			return ""
+		}
+	}
+
+	content := f.Buffer + deltaContent
+	f.Buffer = ""
+
+	content = strings.ReplaceAll(content, "\n> ", "\n")
+
+	if strings.HasSuffix(content, "\n>") {
+		f.Buffer = "\n>"
+		return content[:len(content)-2]
+	}
+	if strings.HasSuffix(content, "\n") {
+		f.Buffer = "\n"
+		return content[:len(content)-1]
+	}
+
+	return content
+}
+
+func (f *ThinkingFilter) Flush() string {
+	result := f.Buffer
+	f.Buffer = ""
+	return result
+}
+
+func (f *ThinkingFilter) ExtractCompleteThinking(editContent string) string {
+	startIdx := strings.Index(editContent, "> ")
+	if startIdx == -1 {
+		return ""
+	}
+	startIdx += 2
+
+	endIdx := strings.Index(editContent, "\n</details>")
+	if endIdx == -1 {
+		return ""
+	}
+
+	content := editContent[startIdx:endIdx]
+	content = strings.ReplaceAll(content, "\n> ", "\n")
+	return content
+}
+
+func (f *ThinkingFilter) ExtractIncrementalThinking(editContent string) string {
+	completeThinking := f.ExtractCompleteThinking(editContent)
+	if completeThinking == "" {
+		return ""
+	}
+
+	if f.LastOutputChunk == "" {
+		return completeThinking
+	}
+
+	idx := strings.Index(completeThinking, f.LastOutputChunk)
+	if idx == -1 {
+		return completeThinking
+	}
+
+	incrementalPart := completeThinking[idx+len(f.LastOutputChunk):]
+	return incrementalPart
+}
+
+func (f *ThinkingFilter) ResetForNewRound() {
+	f.LastOutputChunk = ""
+	f.HasSeenFirstThinking = false
+}

internal/{chat.go → handler/chat.go}

@@ -1,8 +1,7 @@
-package internal
+package handler
 
 import (
 	"bufio"
-	"bytes"
 	"encoding/json"
 	"fmt"
 	"io"
@@ -10,252 +9,14 @@ import (
 	"strings"
 	"time"
 
-	"github.com/corpix/uarand"
 	"github.com/google/uuid"
-)
-
-func extractLatestUserContent(messages []Message) string {
-	for i := len(messages) - 1; i >= 0; i-- {
-		if messages[i].Role == "user" {
-			text, _ := messages[i].ParseContent()
-			return text
-		}
-	}
-	return ""
-}
-
-func extractAllImageURLs(messages []Message) []string {
-	var allImageURLs []string
-	for _, msg := range messages {
-		_, imageURLs := msg.ParseContent()
-		allImageURLs = append(allImageURLs, imageURLs...)
-	}
-	return allImageURLs
-}
-
-func makeUpstreamRequest(token string, messages []Message, model string) (*http.Response, string, error) {
-	payload, err := DecodeJWTPayload(token)
-	if err != nil || payload == nil {
-		return nil, "", fmt.Errorf("invalid token")
-	}
-
-	userID := payload.ID
-	chatID := uuid.New().String()
-	timestamp := time.Now().UnixMilli()
-	requestID := uuid.New().String()
-	userMsgID := uuid.New().String()
-
-	targetModel := GetTargetModel(model)
-	latestUserContent := extractLatestUserContent(messages)
-	imageURLs := extractAllImageURLs(messages)
-
-	signature := GenerateSignature(userID, requestID, latestUserContent, timestamp)
-
-	url := fmt.Sprintf("https://chat.z.ai/api/v2/chat/completions?timestamp=%d&requestId=%s&user_id=%s&version=0.0.1&platform=web&token=%s&current_url=%s&pathname=%s&signature_timestamp=%d",
-		timestamp, requestID, userID, token,
-		fmt.Sprintf("https://chat.z.ai/c/%s", chatID),
-		fmt.Sprintf("/c/%s", chatID),
-		timestamp)
-
-	enableThinking := IsThinkingModel(model)
-	autoWebSearch := IsSearchModel(model)
-	if targetModel == "glm-4.5v" || targetModel == "glm-4.6v" {
-		autoWebSearch = false
-	}
-
-	var mcpServers []string
-	if targetModel == "glm-4.6v" {
-		mcpServers = []string{"vlm-image-search", "vlm-image-recognition", "vlm-image-processing"}
-	}
-
-	urlToFileID := make(map[string]string)
-	var filesData []map[string]interface{}
-	if len(imageURLs) > 0 {
-		files, _ := UploadImages(token, imageURLs)
-		for i, f := range files {
-			if i < len(imageURLs) {
-				urlToFileID[imageURLs[i]] = f.ID
-			}
-			filesData = append(filesData, map[string]interface{}{
-				"type":            f.Type,
-				"file":            f.File,
-				"id":              f.ID,
-				"url":             f.URL,
-				"name":            f.Name,
-				"status":          f.Status,
-				"size":            f.Size,
-				"error":           f.Error,
-				"itemId":          f.ItemID,
-				"media":           f.Media,
-				"ref_user_msg_id": userMsgID,
-			})
-		}
-	}
-
-	var upstreamMessages []map[string]interface{}
-	for _, msg := range messages {
-		upstreamMessages = append(upstreamMessages, msg.ToUpstreamMessage(urlToFileID))
-	}
-
-	body := map[string]interface{}{
-		"stream":           true,
-		"model":            targetModel,
-		"messages":         upstreamMessages,
-		"signature_prompt": latestUserContent,
-		"params":           map[string]interface{}{},
-		"features": map[string]interface{}{
-			"image_generation": false,
-			"web_search":       false,
-			"auto_web_search":  autoWebSearch,
-			"preview_mode":     true,
-			"enable_thinking":  enableThinking,
-		},
-		"chat_id": chatID,
-		"id":      uuid.New().String(),
-	}
-
-	if len(mcpServers) > 0 {
-		body["mcp_servers"] = mcpServers
-	}
-
-	if len(filesData) > 0 {
-		body["files"] = filesData
-		body["current_user_message_id"] = userMsgID
-	}
-
-	bodyBytes, _ := json.Marshal(body)
-
-	req, err := http.NewRequest("POST", url, bytes.NewReader(bodyBytes))
-	if err != nil {
-		return nil, "", err
-	}
-
-	req.Header.Set("Authorization", "Bearer "+token)
-	req.Header.Set("X-FE-Version", GetFeVersion())
-	req.Header.Set("X-Signature", signature)
-	req.Header.Set("Content-Type", "application/json")
-	req.Header.Set("Connection", "keep-alive")
-	req.Header.Set("Origin", "https://chat.z.ai")
-	req.Header.Set("Referer", fmt.Sprintf("https://chat.z.ai/c/%s", uuid.New().String()))
-	req.Header.Set("User-Agent", uarand.GetRandom())
-
-	client := &http.Client{}
-	resp, err := client.Do(req)
-	if err != nil {
-		return nil, "", err
-	}
-
-	return resp, targetModel, nil
-}
-
-type UpstreamData struct {
-	Type string `json:"type"`
-	Data struct {
-		DeltaContent string `json:"delta_content"`
-		EditContent  string `json:"edit_content"`
-		Phase        string `json:"phase"`
-		Done         bool   `json:"done"`
-	} `json:"data"`
-}
-
-func (u *UpstreamData) GetEditContent() string {
-	editContent := u.Data.EditContent
-	if editContent == "" {
-		return ""
-	}
 
-	if len(editContent) > 0 && editContent[0] == '"' {
-		var unescaped string
-		if err := json.Unmarshal([]byte(editContent), &unescaped); err == nil {
-			LogDebug("[GetEditContent] Unescaped edit_content from JSON string")
-			return unescaped
-		}
-	}
-
-	return editContent
-}
-
-type ThinkingFilter struct {
-	hasSeenFirstThinking bool
-	buffer               string
-	lastOutputChunk      string
-	lastPhase            string
-	thinkingRoundCount   int
-}
-
-func (f *ThinkingFilter) ProcessThinking(deltaContent string) string {
-	if !f.hasSeenFirstThinking {
-		f.hasSeenFirstThinking = true
-		if idx := strings.Index(deltaContent, "> "); idx != -1 {
-			deltaContent = deltaContent[idx+2:]
-		} else {
-			return ""
-		}
-	}
-
-	content := f.buffer + deltaContent
-	f.buffer = ""
-
-	content = strings.ReplaceAll(content, "\n> ", "\n")
-
-	if strings.HasSuffix(content, "\n>") {
-		f.buffer = "\n>"
-		return content[:len(content)-2]
-	}
-	if strings.HasSuffix(content, "\n") {
-		f.buffer = "\n"
-		return content[:len(content)-1]
-	}
-
-	return content
-}
-
-func (f *ThinkingFilter) Flush() string {
-	result := f.buffer
-	f.buffer = ""
-	return result
-}
-
-func (f *ThinkingFilter) ExtractCompleteThinking(editContent string) string {
-	startIdx := strings.Index(editContent, "> ")
-	if startIdx == -1 {
-		return ""
-	}
-	startIdx += 2
-
-	endIdx := strings.Index(editContent, "\n</details>")
-	if endIdx == -1 {
-		return ""
-	}
-
-	content := editContent[startIdx:endIdx]
-	content = strings.ReplaceAll(content, "\n> ", "\n")
-	return content
-}
-
-func (f *ThinkingFilter) ExtractIncrementalThinking(editContent string) string {
-	completeThinking := f.ExtractCompleteThinking(editContent)
-	if completeThinking == "" {
-		return ""
-	}
-
-	if f.lastOutputChunk == "" {
-		return completeThinking
-	}
-
-	idx := strings.Index(completeThinking, f.lastOutputChunk)
-	if idx == -1 {
-		return completeThinking
-	}
-
-	incrementalPart := completeThinking[idx+len(f.lastOutputChunk):]
-	return incrementalPart
-}
-
-func (f *ThinkingFilter) ResetForNewRound() {
-	f.lastOutputChunk = ""
-	f.hasSeenFirstThinking = false
-}
+	"zai-proxy/internal/auth"
+	"zai-proxy/internal/filter"
+	"zai-proxy/internal/logger"
+	"zai-proxy/internal/model"
+	"zai-proxy/internal/upstream"
+)
 
 func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
 	token := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
@@ -265,16 +26,16 @@ func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
 	}
 
 	if token == "free" {
-		anonymousToken, err := GetAnonymousToken()
+		anonymousToken, err := auth.GetAnonymousToken()
 		if err != nil {
-			LogError("Failed to get anonymous token: %v", err)
+			logger.LogError("Failed to get anonymous token: %v", err)
 			http.Error(w, "Failed to get anonymous token", http.StatusInternalServerError)
 			return
 		}
 		token = anonymousToken
 	}
 
-	var req ChatRequest
+	var req model.ChatRequest
 	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
 		http.Error(w, "Invalid request", http.StatusBadRequest)
 		return
@@ -284,9 +45,9 @@ func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		req.Model = "GLM-4.6"
 	}
 
-	resp, modelName, err := makeUpstreamRequest(token, req.Messages, req.Model)
+	resp, modelName, err := upstream.MakeUpstreamRequest(token, req.Messages, req.Model)
 	if err != nil {
-		LogError("Upstream request failed: %v", err)
+		logger.LogError("Upstream request failed: %v", err)
 		http.Error(w, "Upstream error", http.StatusBadGateway)
 		return
 	}
@@ -298,7 +59,7 @@ func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		if len(bodyStr) > 500 {
 			bodyStr = bodyStr[:500]
 		}
-		LogError("Upstream error: status=%d, body=%s", resp.StatusCode, bodyStr)
+		logger.LogError("Upstream error: status=%d, body=%s", resp.StatusCode, bodyStr)
 		http.Error(w, "Upstream error", resp.StatusCode)
 		return
 	}
@@ -326,15 +87,15 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 	scanner := bufio.NewScanner(body)
 	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
 	hasContent := false
-	searchRefFilter := NewSearchRefFilter()
-	thinkingFilter := &ThinkingFilter{}
+	searchRefFilter := filter.NewSearchRefFilter()
+	thinkingFilter := &filter.ThinkingFilter{}
 	pendingSourcesMarkdown := ""
 	pendingImageSearchMarkdown := ""
-	totalContentOutputLength := 0 // 记录已输出的 content 字符长度
+	totalContentOutputLength := 0
 
 	for scanner.Scan() {
 		line := scanner.Text()
-		LogDebug("[Upstream] %s", line)
+		logger.LogDebug("[Upstream] %s", line)
 
 		if !strings.HasPrefix(line, "data: ") {
 			continue
@@ -345,44 +106,44 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 			break
 		}
 
-		var upstream UpstreamData
-		if err := json.Unmarshal([]byte(payload), &upstream); err != nil {
+		var upstreamData model.UpstreamData
+		if err := json.Unmarshal([]byte(payload), &upstreamData); err != nil {
 			continue
 		}
 
-		if upstream.Data.Phase == "done" {
+		if upstreamData.Data.Phase == "done" {
 			break
 		}
 
-		if upstream.Data.Phase == "thinking" && upstream.Data.DeltaContent != "" {
+		if upstreamData.Data.Phase == "thinking" && upstreamData.Data.DeltaContent != "" {
 			isNewThinkingRound := false
-			if thinkingFilter.lastPhase != "" && thinkingFilter.lastPhase != "thinking" {
+			if thinkingFilter.LastPhase != "" && thinkingFilter.LastPhase != "thinking" {
 				thinkingFilter.ResetForNewRound()
-				thinkingFilter.thinkingRoundCount++
+				thinkingFilter.ThinkingRoundCount++
 				isNewThinkingRound = true
 			}
-			thinkingFilter.lastPhase = "thinking"
+			thinkingFilter.LastPhase = "thinking"
 
-			reasoningContent := thinkingFilter.ProcessThinking(upstream.Data.DeltaContent)
+			reasoningContent := thinkingFilter.ProcessThinking(upstreamData.Data.DeltaContent)
 
-			if isNewThinkingRound && thinkingFilter.thinkingRoundCount > 1 && reasoningContent != "" {
+			if isNewThinkingRound && thinkingFilter.ThinkingRoundCount > 1 && reasoningContent != "" {
 				reasoningContent = "\n\n" + reasoningContent
 			}
 
 			if reasoningContent != "" {
-				thinkingFilter.lastOutputChunk = reasoningContent
+				thinkingFilter.LastOutputChunk = reasoningContent
 				reasoningContent = searchRefFilter.Process(reasoningContent)
 
 				if reasoningContent != "" {
 					hasContent = true
-					chunk := ChatCompletionChunk{
+					chunk := model.ChatCompletionChunk{
 						ID:      completionID,
 						Object:  "chat.completion.chunk",
 						Created: time.Now().Unix(),
 						Model:   modelName,
-						Choices: []Choice{{
+						Choices: []model.Choice{{
 							Index:        0,
-							Delta:        Delta{ReasoningContent: reasoningContent},
+							Delta:        model.Delta{ReasoningContent: reasoningContent},
 							FinishReason: nil,
 						}},
 					}
@@ -394,32 +155,32 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 			continue
 		}
 
-		if upstream.Data.Phase != "" {
-			thinkingFilter.lastPhase = upstream.Data.Phase
+		if upstreamData.Data.Phase != "" {
+			thinkingFilter.LastPhase = upstreamData.Data.Phase
 		}
 
-		editContent := upstream.GetEditContent()
-		if editContent != "" && IsSearchResultContent(editContent) {
-			if results := ParseSearchResults(editContent); len(results) > 0 {
+		editContent := upstreamData.GetEditContent()
+		if editContent != "" && filter.IsSearchResultContent(editContent) {
+			if results := filter.ParseSearchResults(editContent); len(results) > 0 {
 				searchRefFilter.AddSearchResults(results)
 				pendingSourcesMarkdown = searchRefFilter.GetSearchResultsMarkdown()
 			}
 			continue
 		}
 		if editContent != "" && strings.Contains(editContent, `"search_image"`) {
-			textBeforeBlock := ExtractTextBeforeGlmBlock(editContent)
+			textBeforeBlock := filter.ExtractTextBeforeGlmBlock(editContent)
 			if textBeforeBlock != "" {
 				textBeforeBlock = searchRefFilter.Process(textBeforeBlock)
 				if textBeforeBlock != "" {
 					hasContent = true
-					chunk := ChatCompletionChunk{
+					chunk := model.ChatCompletionChunk{
 						ID:      completionID,
 						Object:  "chat.completion.chunk",
 						Created: time.Now().Unix(),
 						Model:   modelName,
-						Choices: []Choice{{
+						Choices: []model.Choice{{
 							Index:        0,
-							Delta:        Delta{Content: textBeforeBlock},
+							Delta:        model.Delta{Content: textBeforeBlock},
 							FinishReason: nil,
 						}},
 					}
@@ -428,25 +189,25 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 					flusher.Flush()
 				}
 			}
-			if results := ParseImageSearchResults(editContent); len(results) > 0 {
-				pendingImageSearchMarkdown = FormatImageSearchResults(results)
+			if results := filter.ParseImageSearchResults(editContent); len(results) > 0 {
+				pendingImageSearchMarkdown = filter.FormatImageSearchResults(results)
 			}
 			continue
 		}
 		if editContent != "" && strings.Contains(editContent, `"mcp"`) {
-			textBeforeBlock := ExtractTextBeforeGlmBlock(editContent)
+			textBeforeBlock := filter.ExtractTextBeforeGlmBlock(editContent)
 			if textBeforeBlock != "" {
 				textBeforeBlock = searchRefFilter.Process(textBeforeBlock)
 				if textBeforeBlock != "" {
 					hasContent = true
-					chunk := ChatCompletionChunk{
+					chunk := model.ChatCompletionChunk{
 						ID:      completionID,
 						Object:  "chat.completion.chunk",
 						Created: time.Now().Unix(),
 						Model:   modelName,
-						Choices: []Choice{{
+						Choices: []model.Choice{{
 							Index:        0,
-							Delta:        Delta{Content: textBeforeBlock},
+							Delta:        model.Delta{Content: textBeforeBlock},
 							FinishReason: nil,
 						}},
 					}
@@ -457,20 +218,20 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 			}
 			continue
 		}
-		if editContent != "" && IsSearchToolCall(editContent, upstream.Data.Phase) {
+		if editContent != "" && filter.IsSearchToolCall(editContent, upstreamData.Data.Phase) {
 			continue
 		}
 
 		if pendingSourcesMarkdown != "" {
 			hasContent = true
-			chunk := ChatCompletionChunk{
+			chunk := model.ChatCompletionChunk{
 				ID:      completionID,
 				Object:  "chat.completion.chunk",
 				Created: time.Now().Unix(),
 				Model:   modelName,
-				Choices: []Choice{{
+				Choices: []model.Choice{{
 					Index:        0,
-					Delta:        Delta{Content: pendingSourcesMarkdown},
+					Delta:        model.Delta{Content: pendingSourcesMarkdown},
 					FinishReason: nil,
 				}},
 			}
@@ -481,14 +242,14 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 		}
 		if pendingImageSearchMarkdown != "" {
 			hasContent = true
-			chunk := ChatCompletionChunk{
+			chunk := model.ChatCompletionChunk{
 				ID:      completionID,
 				Object:  "chat.completion.chunk",
 				Created: time.Now().Unix(),
 				Model:   modelName,
-				Choices: []Choice{{
+				Choices: []model.Choice{{
 					Index:        0,
-					Delta:        Delta{Content: pendingImageSearchMarkdown},
+					Delta:        model.Delta{Content: pendingImageSearchMarkdown},
 					FinishReason: nil,
 				}},
 			}
@@ -502,18 +263,18 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 		reasoningContent := ""
 
 		if thinkingRemaining := thinkingFilter.Flush(); thinkingRemaining != "" {
-			thinkingFilter.lastOutputChunk = thinkingRemaining
+			thinkingFilter.LastOutputChunk = thinkingRemaining
 			processedRemaining := searchRefFilter.Process(thinkingRemaining)
 			if processedRemaining != "" {
 				hasContent = true
-				chunk := ChatCompletionChunk{
+				chunk := model.ChatCompletionChunk{
 					ID:      completionID,
 					Object:  "chat.completion.chunk",
 					Created: time.Now().Unix(),
 					Model:   modelName,
-					Choices: []Choice{{
+					Choices: []model.Choice{{
 						Index:        0,
-						Delta:        Delta{ReasoningContent: processedRemaining},
+						Delta:        model.Delta{ReasoningContent: processedRemaining},
 						FinishReason: nil,
 					}},
 				}
@@ -523,16 +284,16 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 			}
 		}
 
-		if pendingSourcesMarkdown != "" && thinkingFilter.hasSeenFirstThinking {
+		if pendingSourcesMarkdown != "" && thinkingFilter.HasSeenFirstThinking {
 			hasContent = true
-			chunk := ChatCompletionChunk{
+			chunk := model.ChatCompletionChunk{
 				ID:      completionID,
 				Object:  "chat.completion.chunk",
 				Created: time.Now().Unix(),
 				Model:   modelName,
-				Choices: []Choice{{
+				Choices: []model.Choice{{
 					Index:        0,
-					Delta:        Delta{ReasoningContent: pendingSourcesMarkdown},
+					Delta:        model.Delta{ReasoningContent: pendingSourcesMarkdown},
 					FinishReason: nil,
 				}},
 			}
@@ -542,9 +303,9 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 			pendingSourcesMarkdown = ""
 		}
 
-		if upstream.Data.Phase == "answer" && upstream.Data.DeltaContent != "" {
-			content = upstream.Data.DeltaContent
-		} else if upstream.Data.Phase == "answer" && editContent != "" {
+		if upstreamData.Data.Phase == "answer" && upstreamData.Data.DeltaContent != "" {
+			content = upstreamData.Data.DeltaContent
+		} else if upstreamData.Data.Phase == "answer" && editContent != "" {
 			if strings.Contains(editContent, "</details>") {
 				reasoningContent = thinkingFilter.ExtractIncrementalThinking(editContent)
 
@@ -558,7 +319,7 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 					totalContentOutputLength = len([]rune(content))
 				}
 			}
-		} else if (upstream.Data.Phase == "other" || upstream.Data.Phase == "tool_call") && editContent != "" {
+		} else if (upstreamData.Data.Phase == "other" || upstreamData.Data.Phase == "tool_call") && editContent != "" {
 			fullContent := editContent
 			fullContentRunes := []rune(fullContent)
 
@@ -575,14 +336,14 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 		}
 		if reasoningContent != "" {
 			hasContent = true
-			chunk := ChatCompletionChunk{
+			chunk := model.ChatCompletionChunk{
 				ID:      completionID,
 				Object:  "chat.completion.chunk",
 				Created: time.Now().Unix(),
 				Model:   modelName,
-				Choices: []Choice{{
+				Choices: []model.Choice{{
 					Index:        0,
-					Delta:        Delta{ReasoningContent: reasoningContent},
+					Delta:        model.Delta{ReasoningContent: reasoningContent},
 					FinishReason: nil,
 				}},
 			}
@@ -601,18 +362,18 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 		}
 
 		hasContent = true
-		if upstream.Data.Phase == "answer" && upstream.Data.DeltaContent != "" {
+		if upstreamData.Data.Phase == "answer" && upstreamData.Data.DeltaContent != "" {
 			totalContentOutputLength += len([]rune(content))
 		}
 
-		chunk := ChatCompletionChunk{
+		chunk := model.ChatCompletionChunk{
 			ID:      completionID,
 			Object:  "chat.completion.chunk",
 			Created: time.Now().Unix(),
 			Model:   modelName,
-			Choices: []Choice{{
+			Choices: []model.Choice{{
 				Index:        0,
-				Delta:        Delta{Content: content},
+				Delta:        model.Delta{Content: content},
 				FinishReason: nil,
 			}},
 		}
@@ -623,19 +384,19 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 	}
 
 	if err := scanner.Err(); err != nil {
-		LogError("[Upstream] scanner error: %v", err)
+		logger.LogError("[Upstream] scanner error: %v", err)
 	}
 
 	if remaining := searchRefFilter.Flush(); remaining != "" {
 		hasContent = true
-		chunk := ChatCompletionChunk{
+		chunk := model.ChatCompletionChunk{
 			ID:      completionID,
 			Object:  "chat.completion.chunk",
 			Created: time.Now().Unix(),
 			Model:   modelName,
-			Choices: []Choice{{
+			Choices: []model.Choice{{
 				Index:        0,
-				Delta:        Delta{Content: remaining},
+				Delta:        model.Delta{Content: remaining},
 				FinishReason: nil,
 			}},
 		}
@@ -645,18 +406,18 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 	}
 
 	if !hasContent {
-		LogError("Stream response 200 but no content received")
+		logger.LogError("Stream response 200 but no content received")
 	}
 
 	stopReason := "stop"
-	finalChunk := ChatCompletionChunk{
+	finalChunk := model.ChatCompletionChunk{
 		ID:      completionID,
 		Object:  "chat.completion.chunk",
 		Created: time.Now().Unix(),
 		Model:   modelName,
-		Choices: []Choice{{
+		Choices: []model.Choice{{
 			Index:        0,
-			Delta:        Delta{},
+			Delta:        model.Delta{},
 			FinishReason: &stopReason,
 		}},
 	}
@@ -672,8 +433,8 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
 	var chunks []string
 	var reasoningChunks []string
-	thinkingFilter := &ThinkingFilter{}
-	searchRefFilter := NewSearchRefFilter()
+	thinkingFilter := &filter.ThinkingFilter{}
+	searchRefFilter := filter.NewSearchRefFilter()
 	hasThinking := false
 	pendingSourcesMarkdown := ""
 	pendingImageSearchMarkdown := ""
@@ -689,65 +450,64 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 			break
 		}
 
-		var upstream UpstreamData
-		if err := json.Unmarshal([]byte(payload), &upstream); err != nil {
+		var upstreamData model.UpstreamData
+		if err := json.Unmarshal([]byte(payload), &upstreamData); err != nil {
 			continue
 		}
 
-		if upstream.Data.Phase == "done" {
+		if upstreamData.Data.Phase == "done" {
 			break
 		}
 
-		if upstream.Data.Phase == "thinking" && upstream.Data.DeltaContent != "" {
-			if thinkingFilter.lastPhase != "" && thinkingFilter.lastPhase != "thinking" {
+		if upstreamData.Data.Phase == "thinking" && upstreamData.Data.DeltaContent != "" {
+			if thinkingFilter.LastPhase != "" && thinkingFilter.LastPhase != "thinking" {
 				thinkingFilter.ResetForNewRound()
-				thinkingFilter.thinkingRoundCount++
-				if thinkingFilter.thinkingRoundCount > 1 {
+				thinkingFilter.ThinkingRoundCount++
+				if thinkingFilter.ThinkingRoundCount > 1 {
 					reasoningChunks = append(reasoningChunks, "\n\n")
 				}
 			}
-			thinkingFilter.lastPhase = "thinking"
+			thinkingFilter.LastPhase = "thinking"
 
 			hasThinking = true
-			reasoningContent := thinkingFilter.ProcessThinking(upstream.Data.DeltaContent)
+			reasoningContent := thinkingFilter.ProcessThinking(upstreamData.Data.DeltaContent)
 			if reasoningContent != "" {
-				thinkingFilter.lastOutputChunk = reasoningContent
+				thinkingFilter.LastOutputChunk = reasoningContent
 				reasoningChunks = append(reasoningChunks, reasoningContent)
 			}
 			continue
 		}
 
-		if upstream.Data.Phase != "" {
-			thinkingFilter.lastPhase = upstream.Data.Phase
+		if upstreamData.Data.Phase != "" {
+			thinkingFilter.LastPhase = upstreamData.Data.Phase
 		}
 
-		editContent := upstream.GetEditContent()
-		if editContent != "" && IsSearchResultContent(editContent) {
-			if results := ParseSearchResults(editContent); len(results) > 0 {
+		editContent := upstreamData.GetEditContent()
+		if editContent != "" && filter.IsSearchResultContent(editContent) {
+			if results := filter.ParseSearchResults(editContent); len(results) > 0 {
 				searchRefFilter.AddSearchResults(results)
 				pendingSourcesMarkdown = searchRefFilter.GetSearchResultsMarkdown()
 			}
 			continue
 		}
 		if editContent != "" && strings.Contains(editContent, `"search_image"`) {
-			textBeforeBlock := ExtractTextBeforeGlmBlock(editContent)
+			textBeforeBlock := filter.ExtractTextBeforeGlmBlock(editContent)
 			if textBeforeBlock != "" {
 				chunks = append(chunks, textBeforeBlock)
 			}
-			// 解析图片搜索结果
-			if results := ParseImageSearchResults(editContent); len(results) > 0 {
-				pendingImageSearchMarkdown = FormatImageSearchResults(results)
+			if results := filter.ParseImageSearchResults(editContent); len(results) > 0 {
+				pendingImageSearchMarkdown = filter.FormatImageSearchResults(results)
 			}
 			continue
 		}
 		if editContent != "" && strings.Contains(editContent, `"mcp"`) {
-			textBeforeBlock := ExtractTextBeforeGlmBlock(editContent)
+			textBeforeBlock := filter.ExtractTextBeforeGlmBlock(editContent)
 			if textBeforeBlock != "" {
 				chunks = append(chunks, textBeforeBlock)
 			}
 			continue
 		}
-		if editContent != "" && IsSearchToolCall(editContent, upstream.Data.Phase) {
+		if editContent != "" && filter.IsSearchToolCall(editContent, upstreamData.Data.Phase) {
 			continue
 		}
 
@@ -765,9 +525,9 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 		}
 
 		content := ""
-		if upstream.Data.Phase == "answer" && upstream.Data.DeltaContent != "" {
-			content = upstream.Data.DeltaContent
-		} else if upstream.Data.Phase == "answer" && editContent != "" {
+		if upstreamData.Data.Phase == "answer" && upstreamData.Data.DeltaContent != "" {
+			content = upstreamData.Data.DeltaContent
+		} else if upstreamData.Data.Phase == "answer" && editContent != "" {
 			if strings.Contains(editContent, "</details>") {
 				reasoningContent := thinkingFilter.ExtractIncrementalThinking(editContent)
 				if reasoningContent != "" {
@@ -783,7 +543,7 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 					}
 				}
 			}
-		} else if (upstream.Data.Phase == "other" || upstream.Data.Phase == "tool_call") && editContent != "" {
+		} else if (upstreamData.Data.Phase == "other" || upstreamData.Data.Phase == "tool_call") && editContent != "" {
 			content = editContent
 		}
 
@@ -798,18 +558,18 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 	fullReasoning = searchRefFilter.Process(fullReasoning) + searchRefFilter.Flush()
 
 	if fullContent == "" {
-		LogError("Non-stream response 200 but no content received")
+		logger.LogError("Non-stream response 200 but no content received")
 	}
 
 	stopReason := "stop"
-	response := ChatCompletionResponse{
+	response := model.ChatCompletionResponse{
 		ID:      completionID,
 		Object:  "chat.completion",
 		Created: time.Now().Unix(),
 		Model:   modelName,
-		Choices: []Choice{{
+		Choices: []model.Choice{{
 			Index: 0,
-			Message: &MessageResp{
+			Message: &model.MessageResp{
 				Role:             "assistant",
 				Content:          fullContent,
 				ReasoningContent: fullReasoning,
@@ -821,22 +581,3 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 	w.Header().Set("Content-Type", "application/json")
 	json.NewEncoder(w).Encode(response)
 }
-
-func HandleModels(w http.ResponseWriter, r *http.Request) {
-	var models []ModelInfo
-	for _, id := range ModelList {
-		models = append(models, ModelInfo{
-			ID:      id,
-			Object:  "model",
-			OwnedBy: "z.ai",
-		})
-	}
-
-	response := ModelsResponse{
-		Object: "list",
-		Data:   models,
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(response)
-}

internal/handler/models.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"encoding/json"
+	"net/http"
+
+	"zai-proxy/internal/model"
+)
+
+func HandleModels(w http.ResponseWriter, r *http.Request) {
+	var models []model.ModelInfo
+	for _, id := range model.ModelList {
+		models = append(models, model.ModelInfo{
+			ID:      id,
+			Object:  "model",
+			OwnedBy: "z.ai",
+		})
+	}
+
+	response := model.ModelsResponse{
+		Object: "list",
+		Data:   models,
+	}
+
+	w.Header().Set("Content-Type", "application/json")
+	json.NewEncoder(w).Encode(response)
+}

internal/{logger.go → logger/logger.go}

@@ -1,4 +1,4 @@
-package internal
+package logger
 
 import (
 	"fmt"

internal/model/mapping.go

@@ -0,0 +1,69 @@
+package model
+
+import "strings"
+
+// 基础模型映射（不包含标签后缀）
+var BaseModelMapping = map[string]string{
+	"GLM-4.5":      "0727-360B-API",
+	"GLM-4.6":      "GLM-4-6-API-V1",
+	"GLM-4.7":      "glm-4.7",
+	"GLM-4.5-V":    "glm-4.5v",
+	"GLM-4.6-V":    "glm-4.6v",
+	"GLM-4.5-Air":  "0727-106B-API",
+	"0808-360B-DR": "0808-360B-DR",
+}
+
+// v1/models 返回的模型列表（不包含所有标签组合）
+var ModelList = []string{
+	"GLM-4.5",
+	"GLM-4.6",
+	"GLM-4.7",
+	"GLM-4.7-thinking",
+	"GLM-4.7-thinking-search",
+	"GLM-4.5-V",
+	"GLM-4.6-V",
+	"GLM-4.6-V-thinking",
+	"GLM-4.5-Air",
+	// "0808-360B-DR",
+}
+
+// 解析模型名称，提取基础模型名和标签
+// 支持 -thinking 和 -search 标签的任意排列组合
+func ParseModelName(model string) (baseModel string, enableThinking bool, enableSearch bool) {
+	enableThinking = false
+	enableSearch = false
+	baseModel = model
+
+	// 检查并移除 -thinking 和 -search 标签（任意顺序）
+	for {
+		if strings.HasSuffix(baseModel, "-thinking") {
+			enableThinking = true
+			baseModel = strings.TrimSuffix(baseModel, "-thinking")
+		} else if strings.HasSuffix(baseModel, "-search") {
+			enableSearch = true
+			baseModel = strings.TrimSuffix(baseModel, "-search")
+		} else {
+			break
+		}
+	}
+
+	return baseModel, enableThinking, enableSearch
+}
+
+func IsThinkingModel(model string) bool {
+	_, enableThinking, _ := ParseModelName(model)
+	return enableThinking
+}
+
+func IsSearchModel(model string) bool {
+	_, _, enableSearch := ParseModelName(model)
+	return enableSearch
+}
+
+func GetTargetModel(model string) string {
+	baseModel, _, _ := ParseModelName(model)
+	if target, ok := BaseModelMapping[baseModel]; ok {
+		return target
+	}
+	return model
+}

internal/model/types.go

@@ -0,0 +1,178 @@
+package model
+
+import "encoding/json"
+
+// OpenAI 格式的消息内容项
+type ContentPart struct {
+	Type     string    `json:"type"`
+	Text     string    `json:"text,omitempty"`
+	ImageURL *ImageURL `json:"image_url,omitempty"`
+}
+
+type ImageURL struct {
+	URL string `json:"url"`
+}
+
+// Message 支持纯文本和多模态内容
+type Message struct {
+	Role    string      `json:"role"`
+	Content interface{} `json:"content"` // string 或 []ContentPart
+}
+
+// 解析消息内容，返回文本和图片URL列表
+func (m *Message) ParseContent() (text string, imageURLs []string) {
+	switch content := m.Content.(type) {
+	case string:
+		return content, nil
+	case []interface{}:
+		for _, item := range content {
+			if part, ok := item.(map[string]interface{}); ok {
+				partType, _ := part["type"].(string)
+				if partType == "text" {
+					if t, ok := part["text"].(string); ok {
+						text += t
+					}
+				} else if partType == "image_url" {
+					if imgURL, ok := part["image_url"].(map[string]interface{}); ok {
+						if url, ok := imgURL["url"].(string); ok {
+							imageURLs = append(imageURLs, url)
+						}
+					}
+				}
+			}
+		}
+	}
+	return text, imageURLs
+}
+
+// 转换为上游消息格式，支持多模态
+func (m *Message) ToUpstreamMessage(urlToFileID map[string]string) map[string]interface{} {
+	text, imageURLs := m.ParseContent()
+
+	// 无图片，返回纯文本
+	if len(imageURLs) == 0 {
+		return map[string]interface{}{
+			"role":    m.Role,
+			"content": text,
+		}
+	}
+
+	// 有图片，构建多模态内容
+	var content []interface{}
+	if text != "" {
+		content = append(content, map[string]interface{}{
+			"type": "text",
+			"text": text,
+		})
+	}
+	for _, imgURL := range imageURLs {
+		if fileID, ok := urlToFileID[imgURL]; ok {
+			content = append(content, map[string]interface{}{
+				"type": "image_url",
+				"image_url": map[string]interface{}{
+					"url": fileID,
+				},
+			})
+		}
+	}
+
+	return map[string]interface{}{
+		"role":    m.Role,
+		"content": content,
+	}
+}
+
+type ChatRequest struct {
+	Model    string    `json:"model"`
+	Messages []Message `json:"messages"`
+	Stream   bool      `json:"stream"`
+}
+
+type ChatCompletionChunk struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+}
+
+type
+
+type Choice struct {
+	Index        int          `json:"index"`
+	Delta        Delta        `json:"delta,omitempty"`
+	Message      *MessageResp `json:"message,omitempty"`
+	FinishReason *string      `json:"finish_reason"`
+}
+
+type Delta struct {
+	Content          string `json:"content,omitempty"`
+	ReasoningContent string `json:"reasoning_content,omitempty"`
+}
+
+type MessageResp struct {
+	Role             string `json:"role"`
+	Content          string `json:"content"`
+	ReasoningContent string `json:"reasoning_content,omitempty"`
+}
+
+type ChatCompletionResponse struct {
+	ID      string   `json:"id"`
+	Object  string   `json:"object"`
+	Created int64    `json:"created"`
+	Model   string   `json:"model"`
+	Choices []Choice `json:"choices"`
+}
+
+type ModelsResponse struct {
+	Object string      `json:"object"`
+	Data   []ModelInfo `json:"data"`
+}
+
+type ModelInfo struct {
+	ID      string `json:"id"`
+	Object  string `json:"object"`
+	OwnedBy string `json:"owned_by"`
+}
+
+// SearchResult 搜索结果
+type SearchResult struct {
+	Title string `json:"title"`
+	URL   string `json:"url"`
+	Index int    `json:"index"`
+	RefID string `json:"ref_id"`
+}
+
+// ImageSearchResult 图片搜索结果
+type ImageSearchResult struct {
+	Title     string `json:"title"`
+	Link      string `json:"link"`
+	Thumbnail string `json:"thumbnail"`
+}
+
+// UpstreamData 上游返回的数据结构
+type UpstreamData struct {
+	Type string `json:"type"`
+	Data struct {
+		DeltaContent string `json:"delta_content"`
+		EditContent  string `json:"edit_content"`
+		Phase        string `json:"phase"`
+		Done         bool   `json:"done"`
+	} `json:"data"`
+}
+
+func (u *UpstreamData) GetEditContent() string {
+	editContent := u.Data.EditContent
+	if editContent == "" {
+		return ""
+	}
+
+	if len(editContent) > 0 && editContent[0] == '"' {
+		var unescaped string
+		if err := json.Unmarshal([]byte(editContent), &unescaped); err == nil {
+			return unescaped
+		}
+	}
+
+	return editContent
+}

internal/upstream/client.go

@@ -0,0 +1,150 @@
+package upstream
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"time"
+
+	"github.com/corpix/uarand"
+	"github.com/google/uuid"
+
+	"zai-proxy/internal/auth"
+	"zai-proxy/internal/model"
+	"zai-proxy/internal/version"
+)
+
+func ExtractLatestUserContent(messages []model.Message) string {
+	for i := len(messages) - 1; i >= 0; i-- {
+		if messages[i].Role == "user" {
+			text, _ := messages[i].ParseContent()
+			return text
+		}
+	}
+	return ""
+}
+
+func ExtractAllImageURLs(messages []model.Message) []string {
+	var allImageURLs []string
+	for _, msg := range messages {
+		_, imageURLs := msg.ParseContent()
+		allImageURLs = append(allImageURLs, imageURLs...)
+	}
+	return allImageURLs
+}
+
+func MakeUpstreamRequest(token string, messages []model.Message, modelName string) (*http.Response, string, error) {
+	payload, err := auth.DecodeJWTPayload(token)
+	if err != nil || payload == nil {
+		return nil, "", fmt.Errorf("invalid token")
+	}
+
+	userID := payload.ID
+	chatID := uuid.New().String()
+	timestamp := time.Now().UnixMilli()
+	requestID := uuid.New().String()
+	userMsgID := uuid.New().String()
+
+	targetModel := model.GetTargetModel(modelName)
+	latestUserContent := ExtractLatestUserContent(messages)
+	imageURLs := ExtractAllImageURLs(messages)
+
+	signature := auth.GenerateSignature(userID, requestID, latestUserContent, timestamp)
+
+	url := fmt.Sprintf("https://chat.z.ai/api/v2/chat/completions?timestamp=%d&requestId=%s&user_id=%s&version=0.0.1&platform=web&token=%s&current_url=%s&pathname=%s&signature_timestamp=%d",
+		timestamp, requestID, userID, token,
+		fmt.Sprintf("https://chat.z.ai/c/%s", chatID),
+		fmt.Sprintf("/c/%s", chatID),
+		timestamp)
+
+	enableThinking := model.IsThinkingModel(modelName)
+	autoWebSearch := model.IsSearchModel(modelName)
+	if targetModel == "glm-4.5v" || targetModel == "glm-4.6v" {
+		autoWebSearch = false
+	}
+
+	var mcpServers []string
+	if targetModel == "glm-4.6v" {
+		mcpServers = []string{"vlm-image-search", "vlm-image-recognition", "vlm-image-processing"}
+	}
+
+	urlToFileID := make(map[string]string)
+	var filesData []map[string]interface{}
+	if len(imageURLs) > 0 {
+		files, _ := UploadImages(token, imageURLs)
+		for i, f := range files {
+			if i < len(imageURLs) {
+				urlToFileID[imageURLs[i]] = f.ID
+			}
+			filesData = append(filesData, map[string]interface{}{
+				"type":            f.Type,
+				"file":            f.File,
+				"id":              f.ID,
+				"url":             f.URL,
+				"name":            f.Name,
+				"status":          f.Status,
+				"size":            f.Size,
+				"error":           f.Error,
+				"itemId":          f.ItemID,
+				"media":           f.Media,
+				"ref_user_msg_id": userMsgID,
+			})
+		}
+	}
+
+	var upstreamMessages []map[string]interface{}
+	for _, msg := range messages {
+		upstreamMessages = append(upstreamMessages, msg.ToUpstreamMessage(urlToFileID))
+	}
+
+	body := map[string]interface{}{
+		"stream":           true,
+		"model":            targetModel,
+		"messages":         upstreamMessages,
+		"signature_prompt": latestUserContent,
+		"params":           map[string]interface{}{},
+		"features": map[string]interface{}{
+			"image_generation": false,
+			"web_search":       false,
+			"auto_web_search":  autoWebSearch,
+			"preview_mode":     true,
+			"enable_thinking":  enableThinking,
+		},
+		"chat_id": chatID,
+		"id":      uuid.New().String(),
+	}
+
+	if len(mcpServers) > 0 {
+		body["mcp_servers"] = mcpServers
+	}
+
+	if len(filesData) > 0 {
+		body["files"] = filesData
+		body["current_user_message_id"] = userMsgID
+	}
+
+	bodyBytes, _ := json.Marshal(body)
+
+	req, err := http.NewRequest("POST", url, bytes.NewReader(bodyBytes))
+	if err != nil {
+		return nil, "", err
+	}
+
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("X-FE-Version", version.GetFeVersion())
+	req.Header.Set("X-Signature", signature)
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Connection", "keep-alive")
+	req.Header.Set("Origin", "https://chat.z.ai")
+	req.Header.Set("Referer", fmt.Sprintf("https://chat.z.ai/c/%s", uuid.New().String()))
+	req.Header.Set("User-Agent", uarand.GetRandom())
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, "", err
+	}
+
+	return resp, targetModel, nil
+}

internal/{upload.go → upstream/upload.go}

@@ -1,4 +1,4 @@
-package internal
+package upstream
 
 import (
 	"bytes"
@@ -12,6 +12,8 @@ import (
 	"strings"
 
 	"github.com/google/uuid"
+
+	"zai-proxy/internal/logger"
 )
 
 // FileUploadResponse z.ai 文件上传响应
@@ -49,14 +51,13 @@ func UploadImageFromURL(token string, imageURL string) (*UpstreamFile, error) {
 
 	if strings.HasPrefix(imageURL, "data:") {
 		// Base64 编码的图片
-		// 格式: data:image/jpeg;base64,/9j/4AAQ...
 		parts := strings.SplitN(imageURL, ",", 2)
 		if len(parts) != 2 {
 			return nil, fmt.Errorf("invalid base64 image format")
 		}
 
 		// 解析 MIME 类型
-		header := parts[0] // data:image/jpeg;base64
+		header := parts[0]
 		if idx := strings.Index(header, ":"); idx != -1 {
 			mimeAndEncoding := header[idx+1:]
 			if semiIdx := strings.Index(mimeAndEncoding, ";"); semiIdx != -1 {
@@ -160,7 +161,6 @@ func UploadImageFromURL(token string, imageURL string) (*UpstreamFile, error) {
 		return nil, fmt.Errorf("failed to parse upload response: %v", err)
 	}
 
-	// 构建上游文件格式
 	return &UpstreamFile{
 		Type:   "image",
 		File:   uploadResp,
@@ -181,7 +181,7 @@ func UploadImages(token string, imageURLs []string) ([]*UpstreamFile, error) {
 	for _, url := range imageURLs {
 		file, err := UploadImageFromURL(token, url)
 		if err != nil {
-			LogError("Failed to upload image %s: %v", url[:min(50, len(url))], err)
+			logger.LogError("Failed to upload image %s: %v", url[:min(50, len(url))], err)
 			continue
 		}
 		files = append(files, file)

internal/{version.go → version/version.go}

@@ -1,4 +1,4 @@
-package internal
+package version
 
 import (
 	"io"
@@ -6,6 +6,8 @@ import (
 	"regexp"
 	"sync"
 	"time"
+
+	"zai-proxy/internal/logger"
 )
 
 var (
@@ -22,14 +24,14 @@ func GetFeVersion() string {
 func fetchFeVersion() {
 	resp, err := http.Get("https://chat.z.ai/")
 	if err != nil {
-		LogError("Failed to fetch fe version: %v", err)
+		logger.LogError("Failed to fetch fe version: %v", err)
 		return
 	}
 	defer resp.Body.Close()
 
 	body, err := io.ReadAll(resp.Body)
 	if err != nil {
-		LogError("Failed to read fe version response: %v", err)
+		logger.LogError("Failed to read fe version response: %v", err)
 		return
 	}
 
@@ -39,7 +41,7 @@ func fetchFeVersion() {
 		versionLock.Lock()
 		feVersion = match
 		versionLock.Unlock()
-		LogInfo("Updated fe version: %s", match)
+		logger.LogInfo("Updated fe version: %s", match)
 	}
 }
 

main.go

@@ -3,20 +3,23 @@ package main
 import (
 	"net/http"
 
-	"zai-proxy/internal"
+	"zai-proxy/internal/config"
+	"zai-proxy/internal/handler"
+	"zai-proxy/internal/logger"
+	"zai-proxy/internal/version"
 )
 
 func main() {
-	internal.LoadConfig()
-	internal.InitLogger()
-	internal.StartVersionUpdater()
+	config.LoadConfig()
+	logger.InitLogger()
+	version.StartVersionUpdater()
 
-	http.HandleFunc("/v1/models", internal.HandleModels)
-	http.HandleFunc("/v1/chat/completions", internal.HandleChatCompletions)
+	http.HandleFunc("/v1/models", handler.HandleModels)
+	http.HandleFunc("/v1/chat/completions", handler.HandleChatCompletions)
 
-	addr := ":" + internal.Cfg.Port
-	internal.LogInfo("Server starting on %s", addr)
+	addr := ":" + config.Cfg.Port
+	logger.LogInfo("Server starting on %s", addr)
 	if err := http.ListenAndServe(addr, nil); err != nil {
-		internal.LogError("Server failed: %v", err)
+		logger.LogError("Server failed: %v", err)
 	}
 }