first commit

.env.example

@@ -0,0 +1,2 @@
+PORT=8000
+LOG_LEVEL=info

.gitignore

@@ -0,0 +1,3 @@
+.env
+*.exe
+*.cmd

Dockerfile

@@ -0,0 +1,19 @@
+FROM golang:1.21-alpine AS builder
+
+WORKDIR /app
+
+COPY go.mod go.sum ./
+RUN go mod download
+
+COPY . .
+RUN CGO_ENABLED=0 GOOS=linux go build -o zai-proxy .
+
+FROM alpine:latest
+
+WORKDIR /app
+
+COPY --from=builder /app/zai-proxy .
+
+EXPOSE 8000
+
+CMD ["./zai-proxy"]

README.md

@@ -0,0 +1,116 @@
+# zai-proxy
+
+zai-proxy 是一个基于 Go 语言的代理服务，将 z.ai 网页聊天转换为 OpenAI API 兼容格式。用户使用自己的 z.ai token 进行调用。
+
+## 功能特性
+
+- OpenAI API 兼容格式
+- 支持流式和非流式响应
+- 支持多种 GLM 模型
+- 支持思考模式 (thinking)
+- 支持联网搜索模式 (search)
+- 支持多模态图片输入
+- **自动生成签名**
+- **自动更新签名版本号**
+
+## 快速开始
+
+### 安装运行
+
+```bash
+# 克隆项目
+git clone https://github.com/kao0312/zai-proxy.git
+cd zai-proxy
+
+# 安装依赖
+go mod download
+
+# 运行服务
+go run main.go
+```
+
+### Docker 部署
+
+```bash
+# 构建镜像
+docker build -t zai-proxy .
+
+# 运行容器
+docker run -p 8000:8000 zai-proxy
+
+# 使用环境变量
+docker run -p 8000:8000 -e PORT=8080 -e LOG_LEVEL=debug zai-proxy
+```
+
+## 环境变量
+
+| 变量名 | 说明 | 默认值 |
+|--------|------|--------|
+| PORT | 监听端口 | 8000 |
+| LOG_LEVEL | 日志级别 | info |
+
+## 获取 z.ai Token
+
+1. 登录 https://chat.z.ai
+2. 打开浏览器开发者工具 (F12)
+3. 切换到 Application/Storage 标签
+4. 在 Cookies 中找到 `token` 字段
+5. 复制其值作为 API 调用的 Authorization
+
+## 支持的模型
+
+| 模型名称 | 上游模型 |
+|----------|----------|
+| GLM-4.5 | 0727-360B-API |
+| GLM-4.6 | GLM-4-6-API-V1 |
+| GLM-4.5-V | glm-4.5v |
+| GLM-4.5-Air | 0727-106B-API |
+
+### 模型标签
+
+模型名称支持以下后缀标签（可组合使用）：
+
+- `-thinking`: 启用思考模式，响应会包含 `reasoning_content` 字段
+- `-search`: 启用联网搜索模式
+
+示例：
+
+- `GLM-4.6-thinking`
+- `GLM-4.6-search`
+- `GLM-4.6-thinking-search`
+
+## 使用示例
+
+### curl 测试
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_ZAI_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.6",
+    "messages": [{"role": "user", "content": "hello"}],
+    "stream": true
+  }'
+```
+
+### 多模态请求：
+
+```json
+{
+  "model": "GLM-4.5-V",
+  "messages": [
+    {
+      "role": "user",
+      "content": [
+        {"type": "text", "text": "描述这张图片"},
+        {"type": "image_url", "image_url": {"url": "https://example.com/image.jpg"}}
+      ]
+    }
+  ]
+}
+```
+
+### 支持的图片格式：
+- HTTP/HTTPS URL
+- Base64 编码 (data:image/jpeg;base64,...)

go.mod

@@ -0,0 +1,10 @@
+module zai-proxy
+
+go 1.21
+
+require (
+	github.com/google/uuid v1.6.0
+	github.com/joho/godotenv v1.5.1
+)
+
+require github.com/corpix/uarand v0.2.0 // indirect

go.sum

@@ -0,0 +1,6 @@
+github.com/corpix/uarand v0.2.0 h1:U98xXwud/AVuCpkpgfPF7J5TQgr7R5tqT8VZP5KWbzE=
+github.com/corpix/uarand v0.2.0/go.mod h1:/3Z1QIqWkDIhf6XWn/08/uMHoQ8JUoTIKc2iPchBOmM=
+github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
+github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/joho/godotenv v1.5.1 h1:7eLL/+HRGLY0ldzfGMeQkb7vMd0as4CfYvUVzLqw0N0=
+github.com/joho/godotenv v1.5.1/go.mod h1:f4LDr5Voq0i2e/R5DDNOoa2zzDfwtkZa6DnEwAbqwq4=

internal/chat.go

@@ -0,0 +1,584 @@
+package internal
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"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 ""
+}
+
+// 提取所有消息中的图片URL
+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)
+	// GLM-4.5-V 不支持 auto_web_search
+	if targetModel == "glm-4.5v" {
+		autoWebSearch = false
+	}
+
+	// 转换消息为上游格式
+	var upstreamMessages []map[string]string
+	for _, msg := range messages {
+		upstreamMessages = append(upstreamMessages, msg.ToUpstreamMessage())
+	}
+
+	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(imageURLs) > 0 {
+		files, err := UploadImages(token, imageURLs)
+		if err != nil {
+			LogError("Failed to upload images: %v", err)
+		}
+		if len(files) > 0 {
+			// 设置 ref_user_msg_id
+			var filesData []map[string]interface{}
+			for _, f := range files {
+				fileMap := 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,
+				}
+				filesData = append(filesData, fileMap)
+			}
+			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())
+
+	// LogDebug("[Request] URL: %s", url)
+	// LogDebug("[Request] Headers: %v", req.Header)
+
+	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"`
+}
+
+// 思考内容过滤器状态
+type ThinkingFilter struct {
+	hasSeenFirstThinking bool
+	buffer               string
+}
+
+// 处理思考阶段的内容
+// 第一个 delta_content 包含 <details...>\n<summary>Thinking…</summary>\n> 前缀，需要过滤
+// 后续 delta_content 需要替换 "\n> " 为 "\n"（跨块累积处理）
+func (f *ThinkingFilter) ProcessThinking(deltaContent string) string {
+	if !f.hasSeenFirstThinking {
+		f.hasSeenFirstThinking = true
+		// 第一个 thinking 内容，查找 "> " 之后的内容
+		if idx := strings.Index(deltaContent, "> "); idx != -1 {
+			deltaContent = deltaContent[idx+2:]
+		} else {
+			return ""
+		}
+	}
+
+	// 合并缓冲区内容
+	content := f.buffer + deltaContent
+	f.buffer = ""
+
+	// 替换完整的 "\n> " 为 "\n"
+	content = strings.ReplaceAll(content, "\n> ", "\n")
+
+	// 检查末尾是否有可能是 "\n> " 的前缀
+	// 可能的前缀："\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
+}
+
+// Flush 返回缓冲区中剩余的内容
+func (f *ThinkingFilter) Flush() string {
+	result := f.buffer
+	f.buffer = ""
+	return result
+}
+
+// 从 answer 阶段的 edit_content 中提取完整思考内容
+// 格式：true" duration="0" ...>\n<summary>Thought for 0 seconds</summary>\n> 完整思考内容\n</details>\n你好
+func (f *ThinkingFilter) ExtractCompleteThinking(editContent string) string {
+	// 查找 "> " 到 "</details>" 之间的内容
+	startIdx := strings.Index(editContent, "> ")
+	if startIdx == -1 {
+		return ""
+	}
+	startIdx += 2
+
+	endIdx := strings.Index(editContent, "\n</details>")
+	if endIdx == -1 {
+		return ""
+	}
+
+	content := editContent[startIdx:endIdx]
+	// 替换 "\n> " 为 "\n"
+	content = strings.ReplaceAll(content, "\n> ", "\n")
+	return content
+}
+
+func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
+	token := strings.TrimPrefix(r.Header.Get("Authorization"), "Bearer ")
+	if token == "" {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return
+	}
+
+	var req ChatRequest
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	if req.Model == "" {
+		req.Model = "GLM-4.6"
+	}
+
+	resp, modelName, err := makeUpstreamRequest(token, req.Messages, req.Model)
+	if err != nil {
+		LogError("Upstream request failed: %v", err)
+		http.Error(w, "Upstream error", http.StatusBadGateway)
+		return
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		body, _ := io.ReadAll(resp.Body)
+		bodyStr := string(body)
+		if len(bodyStr) > 500 {
+			bodyStr = bodyStr[:500]
+		}
+		LogError("Upstream error: status=%d, body=%s", resp.StatusCode, bodyStr)
+		http.Error(w, "Upstream error", resp.StatusCode)
+		return
+	}
+
+	completionID := fmt.Sprintf("chatcmpl-%s", uuid.New().String()[:29])
+
+	if req.Stream {
+		handleStreamResponse(w, resp.Body, completionID, modelName)
+	} else {
+		handleNonStreamResponse(w, resp.Body, completionID, modelName)
+	}
+}
+
+func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionID, modelName string) {
+	w.Header().Set("Content-Type", "text/event-stream")
+	w.Header().Set("Cache-Control", "no-cache")
+	w.Header().Set("Connection", "keep-alive")
+
+	flusher, ok := w.(http.Flusher)
+	if !ok {
+		http.Error(w, "Streaming not supported", http.StatusInternalServerError)
+		return
+	}
+
+	scanner := bufio.NewScanner(body)
+	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
+	hasContent := false
+	searchRefFilter := NewSearchRefFilter()
+	thinkingFilter := &ThinkingFilter{}
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		LogDebug("[Upstream] %s", line)
+
+		if !strings.HasPrefix(line, "data: ") {
+			continue
+		}
+
+		payload := strings.TrimPrefix(line, "data: ")
+		if payload == "[DONE]" {
+			break
+		}
+
+		var upstream UpstreamData
+		if err := json.Unmarshal([]byte(payload), &upstream); err != nil {
+			continue
+		}
+
+		if upstream.Data.Phase == "done" {
+			break
+		}
+
+		// 处理思考阶段的增量内容
+		if upstream.Data.Phase == "thinking" && upstream.Data.DeltaContent != "" {
+			reasoningContent := thinkingFilter.ProcessThinking(upstream.Data.DeltaContent)
+			if reasoningContent != "" {
+				hasContent = true
+				chunk := ChatCompletionChunk{
+					ID:      completionID,
+					Object:  "chat.completion.chunk",
+					Created: time.Now().Unix(),
+					Model:   modelName,
+					Choices: []Choice{{
+						Index:        0,
+						Delta:        Delta{ReasoningContent: reasoningContent},
+						FinishReason: nil,
+					}},
+				}
+				data, _ := json.Marshal(chunk)
+				fmt.Fprintf(w, "data: %s\n\n", data)
+				flusher.Flush()
+			}
+			continue
+		}
+
+		// 跳过搜索结果内容和搜索工具调用
+		if upstream.Data.EditContent != "" && (IsSearchResultContent(upstream.Data.EditContent) || IsSearchToolCall(upstream.Data.EditContent, upstream.Data.Phase)) {
+			continue
+		}
+
+		// 解析 answer 阶段内容
+		content := ""
+		reasoningContent := ""
+
+		// 先输出 thinking 缓冲区剩余内容
+		if thinkingRemaining := thinkingFilter.Flush(); thinkingRemaining != "" {
+			hasContent = true
+			chunk := ChatCompletionChunk{
+				ID:      completionID,
+				Object:  "chat.completion.chunk",
+				Created: time.Now().Unix(),
+				Model:   modelName,
+				Choices: []Choice{{
+					Index:        0,
+					Delta:        Delta{ReasoningContent: thinkingRemaining},
+					FinishReason: nil,
+				}},
+			}
+			data, _ := json.Marshal(chunk)
+			fmt.Fprintf(w, "data: %s\n\n", data)
+			flusher.Flush()
+		}
+
+		if upstream.Data.Phase == "answer" && upstream.Data.DeltaContent != "" {
+			content = upstream.Data.DeltaContent
+		} else if upstream.Data.Phase == "answer" && upstream.Data.EditContent != "" {
+			// 思考模型首次 answer：提取完整思考内容 + 正常回复开头
+			if strings.Contains(upstream.Data.EditContent, "</details>") {
+				reasoningContent = thinkingFilter.ExtractCompleteThinking(upstream.Data.EditContent)
+				if idx := strings.Index(upstream.Data.EditContent, "</details>\n"); idx != -1 {
+					content = upstream.Data.EditContent[idx+len("</details>\n"):]
+				}
+			}
+		} else if (upstream.Data.Phase == "other" || upstream.Data.Phase == "tool_call") && upstream.Data.EditContent != "" {
+			// other: 普通最后一个 token; tool_call: 搜索模式最后一个 token
+			content = upstream.Data.EditContent
+		}
+
+		// 输出完整思考内容（如果有）
+		if reasoningContent != "" {
+			hasContent = true
+			chunk := ChatCompletionChunk{
+				ID:      completionID,
+				Object:  "chat.completion.chunk",
+				Created: time.Now().Unix(),
+				Model:   modelName,
+				Choices: []Choice{{
+					Index:        0,
+					Delta:        Delta{ReasoningContent: reasoningContent},
+					FinishReason: nil,
+				}},
+			}
+			data, _ := json.Marshal(chunk)
+			fmt.Fprintf(w, "data: %s\n\n", data)
+			flusher.Flush()
+		}
+
+		if content == "" {
+			continue
+		}
+
+		// 过滤搜索引用标记（跨流累积处理）
+		content = searchRefFilter.Process(content)
+		if content == "" {
+			continue
+		}
+
+		hasContent = true
+		chunk := ChatCompletionChunk{
+			ID:      completionID,
+			Object:  "chat.completion.chunk",
+			Created: time.Now().Unix(),
+			Model:   modelName,
+			Choices: []Choice{{
+				Index:        0,
+				Delta:        Delta{Content: content},
+				FinishReason: nil,
+			}},
+		}
+
+		data, _ := json.Marshal(chunk)
+		fmt.Fprintf(w, "data: %s\n\n", data)
+		flusher.Flush()
+	}
+
+	if err := scanner.Err(); err != nil {
+		LogError("[Upstream] scanner error: %v", err)
+	}
+
+	// 输出过滤器中剩余的内容（非引用标记的部分）
+	if remaining := searchRefFilter.Flush(); remaining != "" {
+		hasContent = true
+		chunk := ChatCompletionChunk{
+			ID:      completionID,
+			Object:  "chat.completion.chunk",
+			Created: time.Now().Unix(),
+			Model:   modelName,
+			Choices: []Choice{{
+				Index:        0,
+				Delta:        Delta{Content: remaining},
+				FinishReason: nil,
+			}},
+		}
+		data, _ := json.Marshal(chunk)
+		fmt.Fprintf(w, "data: %s\n\n", data)
+		flusher.Flush()
+	}
+
+	if !hasContent {
+		LogError("Stream response 200 but no content received")
+	}
+
+	// Final chunk
+	stopReason := "stop"
+	finalChunk := ChatCompletionChunk{
+		ID:      completionID,
+		Object:  "chat.completion.chunk",
+		Created: time.Now().Unix(),
+		Model:   modelName,
+		Choices: []Choice{{
+			Index:        0,
+			Delta:        Delta{},
+			FinishReason: &stopReason,
+		}},
+	}
+
+	data, _ := json.Marshal(finalChunk)
+	fmt.Fprintf(w, "data: %s\n\n", data)
+	fmt.Fprintf(w, "data: [DONE]\n\n")
+	flusher.Flush()
+}
+
+func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionID, modelName string) {
+	scanner := bufio.NewScanner(body)
+	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
+	var chunks []string
+	var reasoningChunks []string
+	thinkingFilter := &ThinkingFilter{}
+
+	for scanner.Scan() {
+		line := scanner.Text()
+		if !strings.HasPrefix(line, "data: ") {
+			continue
+		}
+
+		payload := strings.TrimPrefix(line, "data: ")
+		if payload == "[DONE]" {
+			break
+		}
+
+		var upstream UpstreamData
+		if err := json.Unmarshal([]byte(payload), &upstream); err != nil {
+			continue
+		}
+
+		if upstream.Data.Phase == "done" {
+			break
+		}
+
+		// 处理思考阶段的增量内容
+		if upstream.Data.Phase == "thinking" && upstream.Data.DeltaContent != "" {
+			reasoningContent := thinkingFilter.ProcessThinking(upstream.Data.DeltaContent)
+			if reasoningContent != "" {
+				reasoningChunks = append(reasoningChunks, reasoningContent)
+			}
+			continue
+		}
+
+		// 跳过搜索结果内容和搜索工具调用
+		if upstream.Data.EditContent != "" && (IsSearchResultContent(upstream.Data.EditContent) || IsSearchToolCall(upstream.Data.EditContent, upstream.Data.Phase)) {
+			continue
+		}
+
+		// 解析 answer 阶段内容
+		content := ""
+		if upstream.Data.Phase == "answer" && upstream.Data.DeltaContent != "" {
+			content = upstream.Data.DeltaContent
+		} else if upstream.Data.Phase == "answer" && upstream.Data.EditContent != "" {
+			// 思考模型首次 answer：提取完整思考内容 + 正常回复开头
+			if strings.Contains(upstream.Data.EditContent, "</details>") {
+				reasoningContent := thinkingFilter.ExtractCompleteThinking(upstream.Data.EditContent)
+				if reasoningContent != "" {
+					reasoningChunks = append(reasoningChunks, reasoningContent)
+				}
+				if idx := strings.Index(upstream.Data.EditContent, "</details>\n"); idx != -1 {
+					content = upstream.Data.EditContent[idx+len("</details>\n"):]
+				}
+			}
+		} else if (upstream.Data.Phase == "other" || upstream.Data.Phase == "tool_call") && upstream.Data.EditContent != "" {
+			content = upstream.Data.EditContent
+		}
+
+		if content != "" {
+			chunks = append(chunks, content)
+		}
+	}
+
+	// 合并所有内容后统一过滤搜索引用标记
+	fullContent := strings.Join(chunks, "")
+	fullContent = searchRefPattern.ReplaceAllString(fullContent, "")
+	fullReasoning := strings.Join(reasoningChunks, "")
+
+	if fullContent == "" {
+		LogError("Non-stream response 200 but no content received")
+	}
+
+	stopReason := "stop"
+	response := ChatCompletionResponse{
+		ID:      completionID,
+		Object:  "chat.completion",
+		Created: time.Now().Unix(),
+		Model:   modelName,
+		Choices: []Choice{{
+			Index: 0,
+			Message: &MessageResp{
+				Role:             "assistant",
+				Content:          fullContent,
+				ReasoningContent: fullReasoning,
+			},
+			FinishReason: &stopReason,
+		}},
+	}
+
+	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/config.go

@@ -0,0 +1,26 @@
+package internal
+
+import (
+	"os"
+
+	"github.com/joho/godotenv"
+)
+
+type Config struct {
+	Port string
+}
+
+var Cfg *Config
+
+func LoadConfig() {
+	godotenv.Load()
+
+	port := os.Getenv("PORT")
+	if port == "" {
+		port = "8000"
+	}
+
+	Cfg = &Config{
+		Port: port,
+	}
+}

internal/jwt.go

@@ -0,0 +1,39 @@
+package internal
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"strings"
+)
+
+type JWTPayload struct {
+	ID string `json:"id"`
+}
+
+func DecodeJWTPayload(token string) (*JWTPayload, error) {
+	parts := strings.Split(token, ".")
+	if len(parts) < 2 {
+		return nil, nil
+	}
+
+	payload := parts[1]
+	// Add padding if needed
+	if padding := 4 - len(payload)%4; padding != 4 {
+		payload += strings.Repeat("=", padding)
+	}
+
+	decoded, err := base64.URLEncoding.DecodeString(payload)
+	if err != nil {
+		decoded, err = base64.RawURLEncoding.DecodeString(parts[1])
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	var result JWTPayload
+	if err := json.Unmarshal(decoded, &result); err != nil {
+		return nil, err
+	}
+
+	return &result, nil
+}

internal/logger.go

@@ -0,0 +1,73 @@
+package internal
+
+import (
+	"fmt"
+	"os"
+	"time"
+)
+
+type LogLevel int
+
+const (
+	DEBUG LogLevel = iota
+	INFO
+	WARN
+	ERROR
+)
+
+var (
+	currentLevel LogLevel = INFO
+	levelNames            = map[LogLevel]string{
+		DEBUG: "DEBUG",
+		INFO:  "INFO",
+		WARN:  "WARN",
+		ERROR: "ERROR",
+	}
+	// ANSI 颜色
+	levelColors = map[LogLevel]string{
+		DEBUG: "\033[36m", // 青色
+		INFO:  "\033[32m", // 绿色
+		WARN:  "\033[33m", // 黄色
+		ERROR: "\033[31m", // 红色
+	}
+	resetColor = "\033[0m"
+)
+
+func InitLogger() {
+	level := os.Getenv("LOG_LEVEL")
+	switch level {
+	case "debug", "DEBUG":
+		currentLevel = DEBUG
+	case "warn", "WARN":
+		currentLevel = WARN
+	case "error", "ERROR":
+		currentLevel = ERROR
+	default:
+		currentLevel = INFO
+	}
+}
+
+func log(level LogLevel, format string, v ...interface{}) {
+	if level < currentLevel {
+		return
+	}
+	timestamp := time.Now().Format("2006/01/02 15:04:05")
+	msg := fmt.Sprintf(format, v...)
+	fmt.Printf("%s[%s]%s %s %s\n", levelColors[level], levelNames[level], resetColor, timestamp, msg)
+}
+
+func LogDebug(format string, v ...interface{}) {
+	log(DEBUG, format, v...)
+}
+
+func LogInfo(format string, v ...interface{}) {
+	log(INFO, format, v...)
+}
+
+func LogWarn(format string, v ...interface{}) {
+	log(WARN, format, v...)
+}
+
+func LogError(format string, v ...interface{}) {
+	log(ERROR, format, v...)
+}

internal/models.go

@@ -0,0 +1,238 @@
+package internal
+
+import (
+	"regexp"
+	"strings"
+)
+
+// 基础模型映射（不包含标签后缀）
+var BaseModelMapping = map[string]string{
+	"GLM-4.5":     "0727-360B-API",
+	"GLM-4.6":     "GLM-4-6-API-V1",
+	"GLM-4.5-V":   "glm-4.5v",
+	"GLM-4.5-Air": "0727-106B-API",
+}
+
+// v1/models 返回的模型列表（不包含所有标签组合）
+var ModelList = []string{
+	"GLM-4.5",
+	"GLM-4.6",
+	"GLM-4.5-thinking",
+	"GLM-4.6-thinking",
+	"GLM-4.5-V",
+	"GLM-4.5-Air",
+}
+
+// 解析模型名称，提取基础模型名和标签
+// 支持 -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() map[string]string {
+	text, _ := m.ParseContent()
+	return map[string]string{
+		"role":    m.Role,
+		"content": text,
+	}
+}
+
+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"`
+}
+
+// 搜索引用标记正则：【turn数字search数字】
+var searchRefPattern = regexp.MustCompile(`【turn\d+search\d+】`)
+
+// 搜索引用标记可能的前缀模式
+var searchRefPrefixPattern = regexp.MustCompile(`【(t(u(r(n(\d+(s(e(a(r(c(h(\d+)?)?)?)?)?)?)?)?)?)?)?)?$`)
+
+// SearchRefFilter 用于跨流过滤搜索引用标记
+type SearchRefFilter struct {
+	buffer string
+}
+
+// NewSearchRefFilter 创建新的过滤器
+func NewSearchRefFilter() *SearchRefFilter {
+	return &SearchRefFilter{}
+}
+
+// Process 处理内容，返回可以安全输出的部分
+// 如果末尾有可能是引用标记的前缀，会暂存起来
+func (f *SearchRefFilter) Process(content string) string {
+	// 合并之前暂存的内容
+	content = f.buffer + content
+	f.buffer = ""
+
+	// 先移除完整的引用标记
+	content = searchRefPattern.ReplaceAllString(content, "")
+
+	if content == "" {
+		return ""
+	}
+
+	// 检查末尾是否有可能是引用标记的前缀
+	// 从末尾开始，最多检查【turn999search999】长度（约20字符）
+	maxPrefixLen := 20
+	if len(content) < maxPrefixLen {
+		maxPrefixLen = len(content)
+	}
+
+	for i := 1; i <= maxPrefixLen; i++ {
+		suffix := content[len(content)-i:]
+		if searchRefPrefixPattern.MatchString(suffix) {
+			// 找到可能的前缀，暂存起来
+			f.buffer = suffix
+			return content[:len(content)-i]
+		}
+	}
+
+	return content
+}
+
+// Flush 返回所有暂存的内容（流结束时调用）
+func (f *SearchRefFilter) Flush() string {
+	result := f.buffer
+	f.buffer = ""
+	return result
+}
+
+// 检查是否为搜索结果内容（需要跳过）
+func IsSearchResultContent(editContent string) bool {
+	return strings.Contains(editContent, `"search_result"`)
+}
+
+// 检查是否为搜索工具调用内容（需要跳过）
+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`)
+}

internal/signature.go

@@ -0,0 +1,33 @@
+package internal
+
+import (
+	"crypto/hmac"
+	"crypto/sha256"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+)
+
+func hmacSha256Hex(key []byte, data string) string {
+	h := hmac.New(sha256.New, key)
+	h.Write([]byte(data))
+	return hex.EncodeToString(h.Sum(nil))
+}
+
+func GenerateSignature(userID, requestID, userContent string, timestamp int64) string {
+	requestInfo := fmt.Sprintf("requestId,%s,timestamp,%d,user_id,%s", requestID, timestamp, userID)
+	contentBase64 := base64.StdEncoding.EncodeToString([]byte(userContent))
+	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/upload.go

@@ -0,0 +1,197 @@
+package internal
+
+import (
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"path/filepath"
+	"strings"
+
+	"github.com/google/uuid"
+)
+
+// FileUploadResponse z.ai 文件上传响应
+type FileUploadResponse struct {
+	ID       string `json:"id"`
+	UserID   string `json:"user_id"`
+	Filename string `json:"filename"`
+	Meta     struct {
+		Name        string `json:"name"`
+		ContentType string `json:"content_type"`
+		Size        int64  `json:"size"`
+		CdnURL      string `json:"cdn_url"`
+	} `json:"meta"`
+}
+
+// UpstreamFile 上游请求的文件格式
+type UpstreamFile struct {
+	Type   string             `json:"type"`
+	File   FileUploadResponse `json:"file"`
+	ID     string             `json:"id"`
+	URL    string             `json:"url"`
+	Name   string             `json:"name"`
+	Status string             `json:"status"`
+	Size   int64              `json:"size"`
+	Error  string             `json:"error"`
+	ItemID string             `json:"itemId"`
+	Media  string             `json:"media"`
+}
+
+// UploadImageFromURL 从 URL 或 base64 上传图片到 z.ai
+func UploadImageFromURL(token string, imageURL string) (*UpstreamFile, error) {
+	var imageData []byte
+	var filename string
+	var contentType string
+
+	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
+		if idx := strings.Index(header, ":"); idx != -1 {
+			mimeAndEncoding := header[idx+1:]
+			if semiIdx := strings.Index(mimeAndEncoding, ";"); semiIdx != -1 {
+				contentType = mimeAndEncoding[:semiIdx]
+			}
+		}
+		if contentType == "" {
+			contentType = "image/png"
+		}
+
+		// 解码 base64
+		var err error
+		imageData, err = base64.StdEncoding.DecodeString(parts[1])
+		if err != nil {
+			return nil, fmt.Errorf("failed to decode base64: %v", err)
+		}
+
+		// 生成文件名
+		ext := ".png"
+		if strings.Contains(contentType, "jpeg") || strings.Contains(contentType, "jpg") {
+			ext = ".jpg"
+		} else if strings.Contains(contentType, "gif") {
+			ext = ".gif"
+		} else if strings.Contains(contentType, "webp") {
+			ext = ".webp"
+		}
+		filename = uuid.New().String()[:12] + ext
+	} else {
+		// 从 URL 下载图片
+		resp, err := http.Get(imageURL)
+		if err != nil {
+			return nil, fmt.Errorf("failed to download image: %v", err)
+		}
+		defer resp.Body.Close()
+
+		if resp.StatusCode != http.StatusOK {
+			return nil, fmt.Errorf("failed to download image: status %d", resp.StatusCode)
+		}
+
+		imageData, err = io.ReadAll(resp.Body)
+		if err != nil {
+			return nil, fmt.Errorf("failed to read image data: %v", err)
+		}
+
+		contentType = resp.Header.Get("Content-Type")
+		if contentType == "" {
+			contentType = "image/png"
+		}
+
+		// 从 URL 提取文件名
+		filename = filepath.Base(imageURL)
+		if filename == "" || filename == "." || filename == "/" {
+			ext := ".png"
+			if strings.Contains(contentType, "jpeg") || strings.Contains(contentType, "jpg") {
+				ext = ".jpg"
+			}
+			filename = uuid.New().String()[:12] + ext
+		}
+	}
+
+	// 构建 multipart form 请求
+	var buf bytes.Buffer
+	writer := multipart.NewWriter(&buf)
+
+	part, err := writer.CreateFormFile("file", filename)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create form file: %v", err)
+	}
+
+	if _, err := part.Write(imageData); err != nil {
+		return nil, fmt.Errorf("failed to write image data: %v", err)
+	}
+
+	writer.Close()
+
+	// 发送上传请求
+	req, err := http.NewRequest("POST", "https://chat.z.ai/api/v1/files/", &buf)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create upload request: %v", err)
+	}
+
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Content-Type", writer.FormDataContentType())
+	req.Header.Set("Origin", "https://chat.z.ai")
+	req.Header.Set("Referer", "https://chat.z.ai/")
+
+	client := &http.Client{}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to upload image: %v", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK && resp.StatusCode != http.StatusCreated {
+		body, _ := io.ReadAll(resp.Body)
+		return nil, fmt.Errorf("upload failed: status %d, body: %s", resp.StatusCode, string(body))
+	}
+
+	var uploadResp FileUploadResponse
+	if err := json.NewDecoder(resp.Body).Decode(&uploadResp); err != nil {
+		return nil, fmt.Errorf("failed to parse upload response: %v", err)
+	}
+
+	// 构建上游文件格式
+	return &UpstreamFile{
+		Type:   "image",
+		File:   uploadResp,
+		ID:     uploadResp.ID,
+		URL:    fmt.Sprintf("/api/v1/files/%s/content", uploadResp.ID),
+		Name:   uploadResp.Filename,
+		Status: "uploaded",
+		Size:   uploadResp.Meta.Size,
+		Error:  "",
+		ItemID: uuid.New().String(),
+		Media:  "image",
+	}, nil
+}
+
+// UploadImages 批量上传图片
+func UploadImages(token string, imageURLs []string) ([]*UpstreamFile, error) {
+	var files []*UpstreamFile
+	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)
+			continue
+		}
+		files = append(files, file)
+	}
+	return files, nil
+}
+
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

internal/version.go

@@ -0,0 +1,55 @@
+package internal
+
+import (
+	"io"
+	"net/http"
+	"regexp"
+	"sync"
+	"time"
+)
+
+var (
+	feVersion   string
+	versionLock sync.RWMutex
+)
+
+func GetFeVersion() string {
+	versionLock.RLock()
+	defer versionLock.RUnlock()
+	return feVersion
+}
+
+func fetchFeVersion() {
+	resp, err := http.Get("https://chat.z.ai/")
+	if err != nil {
+		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)
+		return
+	}
+
+	re := regexp.MustCompile(`prod-fe-[\.\d]+`)
+	match := re.FindString(string(body))
+	if match != "" {
+		versionLock.Lock()
+		feVersion = match
+		versionLock.Unlock()
+		LogInfo("Updated fe version: %s", match)
+	}
+}
+
+func StartVersionUpdater() {
+	fetchFeVersion()
+
+	ticker := time.NewTicker(1 * time.Hour)
+	go func() {
+		for range ticker.C {
+			fetchFeVersion()
+		}
+	}()
+}

main.go

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