feat: support tool/function calling (OpenAI compatible)

Add tools and tool_choice fields to chat requests, parse upstream
tool_call responses, and return them in OpenAI-compatible format
with finish_reason=tool_calls. Includes builtin tools, test script,
and unit tests.

README.md

@@ -9,6 +9,7 @@ zai-proxy 是一个基于 Go 语言的代理服务，将 z.ai 网页聊天转换
 - 支持多种 GLM 模型
 - 支持思考模式 (thinking)
 - 支持联网搜索模式 (search)
+- 支持内置工具调用 (tools)
 - 支持多模态图片输入
 - 支持匿名 Token（免登录）
 - **自动生成签名**
@@ -87,13 +88,18 @@ curl http://localhost:8000/v1/chat/completions \
 
 - `-thinking`: 启用思考模式，响应会包含 `reasoning_content` 字段
 - `-search`: 启用联网搜索模式
+- `-tools`: 自动注入内置工具定义，模型会返回 `tool_calls` 进行函数调用
 - (TODO) `-deepsearch`: 启用多轮搜索，深入研究分析
 
+标签可任意组合，顺序不限：
+
 示例：
 
 - `GLM-4.7-thinking`
 - `GLM-4.7-search`
 - `GLM-4.7-thinking-search`
+- `GLM-4.7-tools`
+- `GLM-4.7-tools-thinking`
 
 ## 使用示例
 
@@ -130,3 +136,85 @@ curl http://localhost:8000/v1/chat/completions \
 ### 支持的图片格式：
 - HTTP/HTTPS URL
 - Base64 编码 (data:image/jpeg;base64,...)
+
+## 工具调用 (Function Calling)
+
+使用 `-tools` 后缀时，代理会自动注入 6 个内置工具定义。模型会根据用户输入决定是否调用工具。
+
+### 内置工具
+
+| 工具名 | 描述 |
+|--------|------|
+| `get_current_time` | 获取当前时间 |
+| `calculate` | 执行数学计算 |
+| `search_web` | 搜索网络信息 |
+| `query_database` | 执行SQL查询 |
+| `file_operations` | 文件读写列表 |
+| `call_external_api` | 调用外部API |
+
+### 基本调用
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_ZAI_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7-tools",
+    "messages": [{"role": "user", "content": "现在几点了？"}],
+    "stream": true
+  }'
+```
+
+模型会返回 `tool_calls`（`finish_reason` 为 `"tool_calls"`），由客户端自行执行工具并将结果发回。
+
+### 多轮调用流程
+
+```
+第1轮：用户提问 → 模型返回 tool_calls
+第2轮：发送工具执行结果 → 模型生成最终回答
+```
+
+```bash
+curl http://localhost:8000/v1/chat/completions \
+  -H "Authorization: Bearer YOUR_ZAI_TOKEN" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7-tools",
+    "messages": [
+      {"role": "user", "content": "现在几点了？"},
+      {"role": "assistant", "content": "", "tool_calls": [
+        {"id": "call_xxx", "type": "function", "function": {"name": "get_current_time", "arguments": "{}"}}
+      ]},
+      {"role": "tool", "tool_call_id": "call_xxx", "content": "{\"time\": \"2026-03-14 15:30:00\"}"}
+    ],
+    "stream": true
+  }'
+```
+
+### 自定义工具
+
+也可以不使用 `-tools` 后缀，直接在请求中传入 `tools` 字段（标准 OpenAI 格式）：
+
+```json
+{
+  "model": "GLM-4.7",
+  "messages": [{"role": "user", "content": "北京天气怎么样？"}],
+  "tools": [{
+    "type": "function",
+    "function": {
+      "name": "get_weather",
+      "description": "获取天气信息",
+      "parameters": {
+        "type": "object",
+        "properties": {
+          "city": {"type": "string", "description": "城市名称"}
+        },
+        "required": ["city"]
+      }
+    }
+  }],
+  "tool_choice": "auto"
+}
+```
+
+两者可混合使用：`-tools` 模型名 + 自定义 `tools` 字段。**客户端自带的同名工具优先**，不会被内置工具覆盖。

internal/filter/toolcall.go

@@ -0,0 +1,103 @@
+package filter
+
+import (
+	"encoding/json"
+	"regexp"
+	"strings"
+
+	"zai-proxy/internal/model"
+)
+
+var glmToolCallBlockPattern = regexp.MustCompile(`<glm_block[^>]*type="tool_call"[^>]*>([\s\S]*?)</glm_block>`)
+
+// IsFunctionToolCall 判断 tool_call 阶段的内容是否是用户定义的函数调用（非 mcp/search）
+func IsFunctionToolCall(editContent string, phase string) bool {
+	if phase != "tool_call" {
+		return false
+	}
+	// 排除 mcp / search 类型的 tool call
+	if strings.Contains(editContent, `"mcp"`) || strings.Contains(editContent, `mcp-server`) {
+		return false
+	}
+	if strings.Contains(editContent, `"search_result"`) || strings.Contains(editContent, `"search_image"`) {
+		return false
+	}
+	// 包含函数调用特征
+	return strings.Contains(editContent, `"function"`) || strings.Contains(editContent, `"arguments"`)
+}
+
+// ParseFunctionToolCalls 从上游 edit_content 解析函数调用
+func ParseFunctionToolCalls(editContent string) []model.ToolCall {
+	// 尝试从 glm_block 中提取
+	matches := glmToolCallBlockPattern.FindAllStringSubmatch(editContent, -1)
+	if len(matches) > 0 {
+		var allCalls []model.ToolCall
+		for _, match := range matches {
+			if calls := parseToolCallJSON(match[1]); len(calls) > 0 {
+				allCalls = append(allCalls, calls...)
+			}
+		}
+		if len(allCalls) > 0 {
+			return allCalls
+		}
+	}
+
+	// 尝试直接解析为 JSON
+	return parseToolCallJSON(editContent)
+}
+
+// parseToolCallJSON 解析 tool call JSON 数据
+func parseToolCallJSON(content string) []model.ToolCall {
+	content = strings.TrimSpace(content)
+	if content == "" {
+		return nil
+	}
+
+	// 尝试解析为单个 tool call 对象
+	var single struct {
+		ID       string `json:"id"`
+		Type     string `json:"type"`
+		Function struct {
+			Name      string `json:"name"`
+			Arguments string `json:"arguments"`
+		} `json:"function"`
+		Name      string `json:"name"`
+		Arguments string `json:"arguments"`
+	}
+	if err := json.Unmarshal([]byte(content), &single); err == nil {
+		if single.Function.Name != "" {
+			return []model.ToolCall{{
+				ID:   single.ID,
+				Type: "function",
+				Function: model.FunctionCall{
+					Name:      single.Function.Name,
+					Arguments: single.Function.Arguments,
+				},
+			}}
+		}
+		if single.Name != "" {
+			return []model.ToolCall{{
+				ID:   single.ID,
+				Type: "function",
+				Function: model.FunctionCall{
+					Name:      single.Name,
+					Arguments: single.Arguments,
+				},
+			}}
+		}
+	}
+
+	// 尝试解析为数组
+	var arr []json.RawMessage
+	if err := json.Unmarshal([]byte(content), &arr); err == nil {
+		var calls []model.ToolCall
+		for _, raw := range arr {
+			if parsed := parseToolCallJSON(string(raw)); len(parsed) > 0 {
+				calls = append(calls, parsed...)
+			}
+		}
+		return calls
+	}
+
+	return nil
+}

internal/filter/toolcall_test.go

@@ -0,0 +1,277 @@
+package filter
+
+import (
+	"testing"
+)
+
+// ===== IsFunctionToolCall =====
+
+func TestIsFunctionToolCall_True(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+		phase   string
+	}{
+		{
+			name:    "标准 function 字段",
+			content: `{"id":"call_1","type":"function","function":{"name":"get_weather","arguments":"{}"}}`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "包含 arguments 字段",
+			content: `{"name":"get_weather","arguments":"{\"location\":\"北京\"}"}`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "glm_block 包裹的函数调用",
+			content: `<glm_block type="tool_call">{"function":{"name":"fn1","arguments":"{}"}}</glm_block>`,
+			phase:   "tool_call",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if !IsFunctionToolCall(tt.content, tt.phase) {
+				t.Error("expected true")
+			}
+		})
+	}
+}
+
+func TestIsFunctionToolCall_False(t *testing.T) {
+	tests := []struct {
+		name    string
+		content string
+		phase   string
+	}{
+		{
+			name:    "非 tool_call 阶段",
+			content: `{"function":{"name":"get_weather","arguments":"{}"}}`,
+			phase:   "answer",
+		},
+		{
+			name:    "mcp tool call",
+			content: `{"type":"mcp","function":{"name":"mcp_tool","arguments":"{}"}}`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "mcp-server tool call",
+			content: `mcp-server something with "arguments"`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "search_result 内容",
+			content: `{"search_result":[...],"function":"x","arguments":"y"}`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "search_image 内容",
+			content: `{"search_image":{},"function":"x","arguments":"y"}`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "无函数调用特征",
+			content: `{"type":"tool_call","data":"hello world"}`,
+			phase:   "tool_call",
+		},
+		{
+			name:    "空阶段",
+			content: `{"function":{"name":"fn","arguments":"{}"}}`,
+			phase:   "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if IsFunctionToolCall(tt.content, tt.phase) {
+				t.Error("expected false")
+			}
+		})
+	}
+}
+
+// ===== ParseFunctionToolCalls =====
+
+func TestParseFunctionToolCalls_StandardFormat(t *testing.T) {
+	content := `{"id":"call_abc","type":"function","function":{"name":"get_weather","arguments":"{\"location\":\"北京\"}"}}`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].ID != "call_abc" {
+		t.Errorf("ID = %q, want %q", calls[0].ID, "call_abc")
+	}
+	if calls[0].Type != "function" {
+		t.Errorf("Type = %q, want %q", calls[0].Type, "function")
+	}
+	if calls[0].Function.Name != "get_weather" {
+		t.Errorf("Function.Name = %q, want %q", calls[0].Function.Name, "get_weather")
+	}
+	if calls[0].Function.Arguments != `{"location":"北京"}` {
+		t.Errorf("Function.Arguments = %q", calls[0].Function.Arguments)
+	}
+}
+
+func TestParseFunctionToolCalls_FlatFormat(t *testing.T) {
+	content := `{"id":"call_flat","name":"get_time","arguments":"{\"timezone\":\"UTC\"}"}`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].Function.Name != "get_time" {
+		t.Errorf("Function.Name = %q, want %q", calls[0].Function.Name, "get_time")
+	}
+	if calls[0].Function.Arguments != `{"timezone":"UTC"}` {
+		t.Errorf("Function.Arguments = %q", calls[0].Function.Arguments)
+	}
+	if calls[0].Type != "function" {
+		t.Errorf("Type = %q, want %q", calls[0].Type, "function")
+	}
+}
+
+func TestParseFunctionToolCalls_GlmBlock(t *testing.T) {
+	content := `一些文本<glm_block type="tool_call">{"id":"call_glm","type":"function","function":{"name":"search","arguments":"{\"q\":\"test\"}"}}</glm_block>后续文本`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].ID != "call_glm" {
+		t.Errorf("ID = %q, want %q", calls[0].ID, "call_glm")
+	}
+	if calls[0].Function.Name != "search" {
+		t.Errorf("Function.Name = %q, want %q", calls[0].Function.Name, "search")
+	}
+}
+
+func TestParseFunctionToolCalls_MultipleGlmBlocks(t *testing.T) {
+	content := `<glm_block type="tool_call">{"function":{"name":"fn1","arguments":"{}"}}</glm_block>` +
+		`<glm_block type="tool_call">{"function":{"name":"fn2","arguments":"{}"}}</glm_block>`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 2 {
+		t.Fatalf("len(calls) = %d, want 2", len(calls))
+	}
+	if calls[0].Function.Name != "fn1" {
+		t.Errorf("calls[0].Function.Name = %q, want %q", calls[0].Function.Name, "fn1")
+	}
+	if calls[1].Function.Name != "fn2" {
+		t.Errorf("calls[1].Function.Name = %q, want %q", calls[1].Function.Name, "fn2")
+	}
+}
+
+func TestParseFunctionToolCalls_Array(t *testing.T) {
+	content := `[{"id":"c1","type":"function","function":{"name":"fn1","arguments":"{}"}},{"id":"c2","type":"function","function":{"name":"fn2","arguments":"{}"}}]`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 2 {
+		t.Fatalf("len(calls) = %d, want 2", len(calls))
+	}
+	if calls[0].Function.Name != "fn1" {
+		t.Errorf("calls[0].Function.Name = %q", calls[0].Function.Name)
+	}
+	if calls[1].Function.Name != "fn2" {
+		t.Errorf("calls[1].Function.Name = %q", calls[1].Function.Name)
+	}
+}
+
+func TestParseFunctionToolCalls_NoID(t *testing.T) {
+	content := `{"type":"function","function":{"name":"get_weather","arguments":"{}"}}`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].ID != "" {
+		t.Errorf("ID = %q, want empty (caller assigns ID)", calls[0].ID)
+	}
+}
+
+func TestParseFunctionToolCalls_EmptyContent(t *testing.T) {
+	calls := ParseFunctionToolCalls("")
+	if len(calls) != 0 {
+		t.Errorf("len(calls) = %d, want 0", len(calls))
+	}
+}
+
+func TestParseFunctionToolCalls_WhitespaceOnly(t *testing.T) {
+	calls := ParseFunctionToolCalls("   \n\t  ")
+	if len(calls) != 0 {
+		t.Errorf("len(calls) = %d, want 0", len(calls))
+	}
+}
+
+func TestParseFunctionToolCalls_InvalidJSON(t *testing.T) {
+	calls := ParseFunctionToolCalls("not json at all {{{")
+	if len(calls) != 0 {
+		t.Errorf("len(calls) = %d, want 0", len(calls))
+	}
+}
+
+func TestParseFunctionToolCalls_JSONWithoutFunctionFields(t *testing.T) {
+	calls := ParseFunctionToolCalls(`{"type":"something","data":"hello"}`)
+	if len(calls) != 0 {
+		t.Errorf("len(calls) = %d, want 0", len(calls))
+	}
+}
+
+func TestParseFunctionToolCalls_EmptyArray(t *testing.T) {
+	calls := ParseFunctionToolCalls(`[]`)
+	if len(calls) != 0 {
+		t.Errorf("len(calls) = %d, want 0", len(calls))
+	}
+}
+
+func TestParseFunctionToolCalls_ComplexArguments(t *testing.T) {
+	content := `{"function":{"name":"create_order","arguments":"{\"items\":[{\"id\":1,\"qty\":2},{\"id\":3,\"qty\":1}],\"user\":\"张三\"}"}}`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].Function.Name != "create_order" {
+		t.Errorf("Function.Name = %q", calls[0].Function.Name)
+	}
+	// 确保复杂 JSON 参数完整保留
+	if calls[0].Function.Arguments == "" {
+		t.Error("Function.Arguments is empty")
+	}
+}
+
+func TestParseFunctionToolCalls_GlmBlockWithExtraAttrs(t *testing.T) {
+	content := `<glm_block id="123" type="tool_call" status="pending">{"function":{"name":"fn1","arguments":"{}"}}</glm_block>`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].Function.Name != "fn1" {
+		t.Errorf("Function.Name = %q, want %q", calls[0].Function.Name, "fn1")
+	}
+}
+
+func TestParseFunctionToolCalls_GlmBlockInvalidJSON(t *testing.T) {
+	content := `<glm_block type="tool_call">not valid json</glm_block>`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 0 {
+		t.Errorf("len(calls) = %d, want 0", len(calls))
+	}
+}
+
+// ===== 优先级：glm_block 优先于原始 JSON =====
+
+func TestParseFunctionToolCalls_GlmBlockPriority(t *testing.T) {
+	// 如果同时存在 glm_block 和外层 JSON，优先从 glm_block 提取
+	content := `<glm_block type="tool_call">{"function":{"name":"from_block","arguments":"{}"}}</glm_block>`
+
+	calls := ParseFunctionToolCalls(content)
+	if len(calls) != 1 {
+		t.Fatalf("len(calls) = %d, want 1", len(calls))
+	}
+	if calls[0].Function.Name != "from_block" {
+		t.Errorf("Function.Name = %q, want %q", calls[0].Function.Name, "from_block")
+	}
+}

internal/handler/chat.go

@@ -45,7 +45,7 @@ func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
 		req.Model = "GLM-4.6"
 	}
 
-	resp, modelName, err := upstream.MakeUpstreamRequest(token, req.Messages, req.Model)
+	resp, modelName, err := upstream.MakeUpstreamRequest(token, req.Messages, req.Model, req.Tools, req.ToolChoice)
 	if err != nil {
 		logger.LogError("Upstream request failed: %v", err)
 		http.Error(w, "Upstream error", http.StatusBadGateway)
@@ -67,13 +67,13 @@ func HandleChatCompletions(w http.ResponseWriter, r *http.Request) {
 	completionID := fmt.Sprintf("chatcmpl-%s", uuid.New().String()[:29])
 
 	if req.Stream {
-		handleStreamResponse(w, resp.Body, completionID, modelName)
+		handleStreamResponse(w, resp.Body, completionID, modelName, req.Tools)
 	} else {
-		handleNonStreamResponse(w, resp.Body, completionID, modelName)
+		handleNonStreamResponse(w, resp.Body, completionID, modelName, req.Tools)
 	}
 }
 
-func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionID, modelName string) {
+func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionID, modelName string, tools []model.Tool) {
 	w.Header().Set("Content-Type", "text/event-stream")
 	w.Header().Set("Cache-Control", "no-cache")
 	w.Header().Set("Connection", "keep-alive")
@@ -92,6 +92,8 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 	pendingSourcesMarkdown := ""
 	pendingImageSearchMarkdown := ""
 	totalContentOutputLength := 0
+	hasToolCalls := false
+	var collectedToolCalls []model.ToolCall
 
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -221,6 +223,43 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 		if editContent != "" && filter.IsSearchToolCall(editContent, upstreamData.Data.Phase) {
 			continue
 		}
+		// 检测用户定义的函数调用（tool_call 阶段，非 mcp/search）
+		if upstreamData.Data.Phase == "tool_call" && editContent != "" {
+			logger.LogInfo("[ToolCall] phase=%s edit_content=%s", upstreamData.Data.Phase, editContent)
+		}
+		if len(tools) > 0 && editContent != "" && filter.IsFunctionToolCall(editContent, upstreamData.Data.Phase) {
+			if toolCalls := filter.ParseFunctionToolCalls(editContent); len(toolCalls) > 0 {
+				for i := range toolCalls {
+					if toolCalls[i].ID == "" {
+						toolCalls[i].ID = fmt.Sprintf("call_%s", uuid.New().String()[:24])
+					}
+					toolCalls[i].Index = i
+				}
+				collectedToolCalls = toolCalls
+				hasToolCalls = true
+
+				for _, tc := range toolCalls {
+					hasContent = true
+					chunk := model.ChatCompletionChunk{
+						ID:      completionID,
+						Object:  "chat.completion.chunk",
+						Created: time.Now().Unix(),
+						Model:   modelName,
+						Choices: []model.Choice{{
+							Index: 0,
+							Delta: model.Delta{
+								ToolCalls: []model.ToolCall{tc},
+							},
+							FinishReason: nil,
+						}},
+					}
+					data, _ := json.Marshal(chunk)
+					fmt.Fprintf(w, "data: %s\n\n", data)
+					flusher.Flush()
+				}
+			}
+			continue
+		}
 
 		if pendingSourcesMarkdown != "" {
 			hasContent = true
@@ -410,6 +449,9 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 	}
 
 	stopReason := "stop"
+	if hasToolCalls && len(collectedToolCalls) > 0 {
+		stopReason = "tool_calls"
+	}
 	finalChunk := model.ChatCompletionChunk{
 		ID:      completionID,
 		Object:  "chat.completion.chunk",
@@ -428,7 +470,7 @@ func handleStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionI
 	flusher.Flush()
 }
 
-func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionID, modelName string) {
+func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completionID, modelName string, tools []model.Tool) {
 	scanner := bufio.NewScanner(body)
 	scanner.Buffer(make([]byte, 1024*1024), 1024*1024)
 	var chunks []string
@@ -438,6 +480,7 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 	hasThinking := false
 	pendingSourcesMarkdown := ""
 	pendingImageSearchMarkdown := ""
+	var collectedToolCalls []model.ToolCall
 
 	for scanner.Scan() {
 		line := scanner.Text()
@@ -510,6 +553,22 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 		if editContent != "" && filter.IsSearchToolCall(editContent, upstreamData.Data.Phase) {
 			continue
 		}
+		// 检测用户定义的函数调用
+		if upstreamData.Data.Phase == "tool_call" && editContent != "" {
+			logger.LogInfo("[ToolCall] phase=%s edit_content=%s", upstreamData.Data.Phase, editContent)
+		}
+		if len(tools) > 0 && editContent != "" && filter.IsFunctionToolCall(editContent, upstreamData.Data.Phase) {
+			if toolCalls := filter.ParseFunctionToolCalls(editContent); len(toolCalls) > 0 {
+				for i := range toolCalls {
+					if toolCalls[i].ID == "" {
+						toolCalls[i].ID = fmt.Sprintf("call_%s", uuid.New().String()[:24])
+					}
+					toolCalls[i].Index = i
+				}
+				collectedToolCalls = toolCalls
+			}
+			continue
+		}
 
 		if pendingSourcesMarkdown != "" {
 			if hasThinking {
@@ -557,11 +616,14 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 	fullReasoning := strings.Join(reasoningChunks, "")
 	fullReasoning = searchRefFilter.Process(fullReasoning) + searchRefFilter.Flush()
 
-	if fullContent == "" {
+	if fullContent == "" && len(collectedToolCalls) == 0 {
 		logger.LogError("Non-stream response 200 but no content received")
 	}
 
 	stopReason := "stop"
+	if len(collectedToolCalls) > 0 {
+		stopReason = "tool_calls"
+	}
 	response := model.ChatCompletionResponse{
 		ID:      completionID,
 		Object:  "chat.completion",
@@ -573,6 +635,7 @@ func handleNonStreamResponse(w http.ResponseWriter, body io.ReadCloser, completi
 				Role:             "assistant",
 				Content:          fullContent,
 				ReasoningContent: fullReasoning,
+				ToolCalls:        collectedToolCalls,
 			},
 			FinishReason: &stopReason,
 		}},

internal/handler/chat_test.go

@@ -0,0 +1,576 @@
+package handler
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"zai-proxy/internal/model"
+)
+
+// fakeReadCloser 将 string 包装为 io.ReadCloser
+type fakeReadCloser struct {
+	io.Reader
+}
+
+func (f *fakeReadCloser) Close() error { return nil }
+
+func newFakeBody(lines ...string) io.ReadCloser {
+	return &fakeReadCloser{Reader: strings.NewReader(strings.Join(lines, "\n"))}
+}
+
+// 构造上游 SSE 数据行
+func sseEvent(phase, deltaContent, editContent string) string {
+	data := model.UpstreamData{}
+	data.Data.Phase = phase
+	data.Data.DeltaContent = deltaContent
+	data.Data.EditContent = editContent
+	b, _ := json.Marshal(data)
+	return fmt.Sprintf("data: %s", string(b))
+}
+
+func sseEventDone() string {
+	return sseEvent("done", "", "")
+}
+
+func dummyTools() []model.Tool {
+	return []model.Tool{{
+		Type: "function",
+		Function: model.ToolFunction{
+			Name:        "get_weather",
+			Description: "获取天气",
+		},
+	}}
+}
+
+// ===== 流式：普通文本回复 =====
+
+func TestStreamResponse_NormalContent(t *testing.T) {
+	body := newFakeBody(
+		sseEvent("answer", "Hello", ""),
+		sseEvent("answer", " World", ""),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	result := w.Body.String()
+
+	// 应包含内容 chunk
+	if !strings.Contains(result, "Hello") {
+		t.Error("missing 'Hello' in stream output")
+	}
+	if !strings.Contains(result, "World") {
+		t.Error("missing 'World' in stream output")
+	}
+
+	// finish_reason 应该是 "stop"
+	if !strings.Contains(result, `"finish_reason":"stop"`) {
+		t.Error("finish_reason should be 'stop'")
+	}
+
+	// 应以 [DONE] 结尾
+	if !strings.Contains(result, "data: [DONE]") {
+		t.Error("missing [DONE]")
+	}
+}
+
+// ===== 流式：tool_call 回复 =====
+
+func TestStreamResponse_ToolCall(t *testing.T) {
+	toolCallJSON := `{"id":"call_test123","type":"function","function":{"name":"get_weather","arguments":"{\"location\":\"北京\"}"}}`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	result := w.Body.String()
+
+	// 应包含 tool_calls
+	if !strings.Contains(result, `"tool_calls"`) {
+		t.Error("missing tool_calls in stream output")
+	}
+	if !strings.Contains(result, `"get_weather"`) {
+		t.Error("missing function name in stream output")
+	}
+	if !strings.Contains(result, `call_test123`) {
+		t.Error("missing tool call ID in stream output")
+	}
+
+	// finish_reason 应该是 "tool_calls"
+	if !strings.Contains(result, `"finish_reason":"tool_calls"`) {
+		t.Error("finish_reason should be 'tool_calls'")
+	}
+}
+
+// ===== 流式：tool_call 无 ID（自动分配）=====
+
+func TestStreamResponse_ToolCallAutoID(t *testing.T) {
+	toolCallJSON := `{"type":"function","function":{"name":"get_weather","arguments":"{}"}}`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	result := w.Body.String()
+
+	// 应自动分配 call_ 前缀的 ID
+	if !strings.Contains(result, `"id":"call_`) {
+		t.Error("missing auto-generated tool call ID")
+	}
+	if !strings.Contains(result, `"finish_reason":"tool_calls"`) {
+		t.Error("finish_reason should be 'tool_calls'")
+	}
+}
+
+// ===== 流式：无 tools 时 tool_call 阶段被忽略 =====
+
+func TestStreamResponse_ToolCallWithoutToolsDef(t *testing.T) {
+	toolCallJSON := `{"type":"function","function":{"name":"get_weather","arguments":"{}"}}`
+
+	body := newFakeBody(
+		sseEvent("answer", "text before", ""),
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	// 不传 tools，tool_call 不应被解析为函数调用
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	result := w.Body.String()
+
+	// finish_reason 应为 "stop"（没有检测到函数调用）
+	if !strings.Contains(result, `"finish_reason":"stop"`) {
+		t.Error("finish_reason should be 'stop' when no tools defined")
+	}
+}
+
+// ===== 流式：mcp tool_call 被跳过 =====
+
+func TestStreamResponse_McpToolCallSkipped(t *testing.T) {
+	mcpContent := `{"type":"mcp","name":"mcp-server-xxx","arguments":"{}"}`
+
+	body := newFakeBody(
+		sseEvent("answer", "response text", ""),
+		sseEvent("tool_call", "", mcpContent),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	result := w.Body.String()
+
+	// mcp 类型的 tool_call 不应出现在输出中
+	if strings.Contains(result, `mcp-server`) {
+		t.Error("mcp tool call should be filtered out")
+	}
+	// 应为 "stop"（mcp 不算用户函数调用）
+	if !strings.Contains(result, `"finish_reason":"stop"`) {
+		t.Error("finish_reason should be 'stop'")
+	}
+}
+
+// ===== 流式：混合内容 + tool_call =====
+
+func TestStreamResponse_ContentThenToolCall(t *testing.T) {
+	toolCallJSON := `{"function":{"name":"get_weather","arguments":"{}"}}`
+
+	body := newFakeBody(
+		sseEvent("answer", "Let me check ", ""),
+		sseEvent("answer", "the weather.", ""),
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	result := w.Body.String()
+
+	if !strings.Contains(result, "Let me check") {
+		t.Error("missing content text")
+	}
+	if !strings.Contains(result, `"get_weather"`) {
+		t.Error("missing tool call")
+	}
+	if !strings.Contains(result, `"finish_reason":"tool_calls"`) {
+		t.Error("finish_reason should be 'tool_calls'")
+	}
+}
+
+// ===== 流式：多个 tool_call =====
+
+func TestStreamResponse_MultipleToolCalls(t *testing.T) {
+	toolCallJSON := `[{"id":"c1","type":"function","function":{"name":"fn1","arguments":"{}"}},{"id":"c2","type":"function","function":{"name":"fn2","arguments":"{}"}}]`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	result := w.Body.String()
+
+	if !strings.Contains(result, `"fn1"`) {
+		t.Error("missing fn1")
+	}
+	if !strings.Contains(result, `"fn2"`) {
+		t.Error("missing fn2")
+	}
+
+	// 验证 chunk 数量：每个 tool_call 一个 delta chunk（包含 "tool_calls" 在 delta 中）
+	chunks := strings.Split(result, "data: ")
+	toolCallDeltaChunks := 0
+	for _, chunk := range chunks {
+		// 只计算 delta 中包含 tool_calls 的 chunk，排除 finish_reason 中的
+		if strings.Contains(chunk, `"tool_calls":[{`) {
+			toolCallDeltaChunks++
+		}
+	}
+	if toolCallDeltaChunks != 2 {
+		t.Errorf("tool_call delta chunks = %d, want 2", toolCallDeltaChunks)
+	}
+}
+
+// ===== 非流式：普通文本回复 =====
+
+func TestNonStreamResponse_NormalContent(t *testing.T) {
+	body := newFakeBody(
+		sseEvent("answer", "Hello World", ""),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	var resp model.ChatCompletionResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode response: %v", err)
+	}
+
+	if len(resp.Choices) != 1 {
+		t.Fatalf("len(Choices) = %d", len(resp.Choices))
+	}
+	if resp.Choices[0].Message == nil {
+		t.Fatal("Message is nil")
+	}
+	if resp.Choices[0].Message.Content != "Hello World" {
+		t.Errorf("Content = %q, want %q", resp.Choices[0].Message.Content, "Hello World")
+	}
+	if *resp.Choices[0].FinishReason != "stop" {
+		t.Errorf("FinishReason = %q, want %q", *resp.Choices[0].FinishReason, "stop")
+	}
+	if len(resp.Choices[0].Message.ToolCalls) != 0 {
+		t.Errorf("len(ToolCalls) = %d, want 0", len(resp.Choices[0].Message.ToolCalls))
+	}
+}
+
+// ===== 非流式：tool_call 回复 =====
+
+func TestNonStreamResponse_ToolCall(t *testing.T) {
+	toolCallJSON := `{"id":"call_ns","type":"function","function":{"name":"get_weather","arguments":"{\"location\":\"上海\"}"}}`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	var resp model.ChatCompletionResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+
+	msg := resp.Choices[0].Message
+	if msg == nil {
+		t.Fatal("Message is nil")
+	}
+	if len(msg.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(msg.ToolCalls))
+	}
+	if msg.ToolCalls[0].Function.Name != "get_weather" {
+		t.Errorf("Function.Name = %q, want %q", msg.ToolCalls[0].Function.Name, "get_weather")
+	}
+	if msg.ToolCalls[0].Function.Arguments != `{"location":"上海"}` {
+		t.Errorf("Function.Arguments = %q", msg.ToolCalls[0].Function.Arguments)
+	}
+	if *resp.Choices[0].FinishReason != "tool_calls" {
+		t.Errorf("FinishReason = %q, want %q", *resp.Choices[0].FinishReason, "tool_calls")
+	}
+}
+
+// ===== 非流式：tool_call 无 ID =====
+
+func TestNonStreamResponse_ToolCallAutoID(t *testing.T) {
+	toolCallJSON := `{"function":{"name":"fn1","arguments":"{}"}}`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	var resp model.ChatCompletionResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	msg := resp.Choices[0].Message
+	if len(msg.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(msg.ToolCalls))
+	}
+	if !strings.HasPrefix(msg.ToolCalls[0].ID, "call_") {
+		t.Errorf("ID = %q, should have 'call_' prefix", msg.ToolCalls[0].ID)
+	}
+}
+
+// ===== 非流式：无 tools 定义时不解析 tool_call =====
+
+func TestNonStreamResponse_ToolCallWithoutToolsDef(t *testing.T) {
+	toolCallJSON := `{"function":{"name":"get_weather","arguments":"{}"}}`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	var resp model.ChatCompletionResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	if *resp.Choices[0].FinishReason != "stop" {
+		t.Errorf("FinishReason = %q, want %q", *resp.Choices[0].FinishReason, "stop")
+	}
+	if len(resp.Choices[0].Message.ToolCalls) != 0 {
+		t.Errorf("len(ToolCalls) = %d, want 0", len(resp.Choices[0].Message.ToolCalls))
+	}
+}
+
+// ===== 非流式：mcp tool_call 被跳过 =====
+
+func TestNonStreamResponse_McpToolCallSkipped(t *testing.T) {
+	mcpContent := `{"type":"mcp","name":"mcp-server-xxx","arguments":"{}"}`
+
+	body := newFakeBody(
+		sseEvent("answer", "response", ""),
+		sseEvent("tool_call", "", mcpContent),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	var resp model.ChatCompletionResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	if *resp.Choices[0].FinishReason != "stop" {
+		t.Errorf("FinishReason = %q, want %q", *resp.Choices[0].FinishReason, "stop")
+	}
+	if len(resp.Choices[0].Message.ToolCalls) != 0 {
+		t.Errorf("should not have tool_calls for mcp")
+	}
+}
+
+// ===== 非流式：内容 + tool_call =====
+
+func TestNonStreamResponse_ContentAndToolCall(t *testing.T) {
+	toolCallJSON := `{"function":{"name":"get_weather","arguments":"{}"}}`
+
+	body := newFakeBody(
+		sseEvent("answer", "checking weather...", ""),
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	var resp model.ChatCompletionResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	msg := resp.Choices[0].Message
+	if msg.Content != "checking weather..." {
+		t.Errorf("Content = %q, want %q", msg.Content, "checking weather...")
+	}
+	if len(msg.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(msg.ToolCalls))
+	}
+	if *resp.Choices[0].FinishReason != "tool_calls" {
+		t.Errorf("FinishReason = %q, want %q", *resp.Choices[0].FinishReason, "tool_calls")
+	}
+}
+
+// ===== 非流式：多个 tool_call =====
+
+func TestNonStreamResponse_MultipleToolCalls(t *testing.T) {
+	toolCallJSON := `[{"id":"c1","type":"function","function":{"name":"fn1","arguments":"{}"}},{"id":"c2","type":"function","function":{"name":"fn2","arguments":"{\"x\":1}"}}]`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", toolCallJSON),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	var resp model.ChatCompletionResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	msg := resp.Choices[0].Message
+	if len(msg.ToolCalls) != 2 {
+		t.Fatalf("len(ToolCalls) = %d, want 2", len(msg.ToolCalls))
+	}
+	if msg.ToolCalls[0].Function.Name != "fn1" {
+		t.Errorf("ToolCalls[0].Function.Name = %q", msg.ToolCalls[0].Function.Name)
+	}
+	if msg.ToolCalls[1].Function.Name != "fn2" {
+		t.Errorf("ToolCalls[1].Function.Name = %q", msg.ToolCalls[1].Function.Name)
+	}
+	if msg.ToolCalls[0].Index != 0 || msg.ToolCalls[1].Index != 1 {
+		t.Errorf("Indices = [%d, %d], want [0, 1]", msg.ToolCalls[0].Index, msg.ToolCalls[1].Index)
+	}
+}
+
+// ===== 非流式：glm_block 包裹的 tool_call =====
+
+func TestNonStreamResponse_GlmBlockToolCall(t *testing.T) {
+	editContent := `<glm_block type="tool_call">{"id":"call_glm","type":"function","function":{"name":"get_weather","arguments":"{\"city\":\"深圳\"}"}}</glm_block>`
+
+	body := newFakeBody(
+		sseEvent("tool_call", "", editContent),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", dummyTools())
+
+	var resp model.ChatCompletionResponse
+	json.NewDecoder(w.Body).Decode(&resp)
+
+	msg := resp.Choices[0].Message
+	if len(msg.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(msg.ToolCalls))
+	}
+	if msg.ToolCalls[0].ID != "call_glm" {
+		t.Errorf("ID = %q, want %q", msg.ToolCalls[0].ID, "call_glm")
+	}
+	if msg.ToolCalls[0].Function.Name != "get_weather" {
+		t.Errorf("Function.Name = %q", msg.ToolCalls[0].Function.Name)
+	}
+	if *resp.Choices[0].FinishReason != "tool_calls" {
+		t.Errorf("FinishReason = %q", *resp.Choices[0].FinishReason)
+	}
+}
+
+// ===== 流式：SSE headers 验证 =====
+
+func TestStreamResponse_Headers(t *testing.T) {
+	body := newFakeBody(sseEventDone())
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	if ct := w.Header().Get("Content-Type"); ct != "text/event-stream" {
+		t.Errorf("Content-Type = %q, want %q", ct, "text/event-stream")
+	}
+	if cc := w.Header().Get("Cache-Control"); cc != "no-cache" {
+		t.Errorf("Cache-Control = %q, want %q", cc, "no-cache")
+	}
+}
+
+// ===== 非流式：response headers 验证 =====
+
+func TestNonStreamResponse_Headers(t *testing.T) {
+	body := newFakeBody(sseEventDone())
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	if ct := w.Header().Get("Content-Type"); ct != "application/json" {
+		t.Errorf("Content-Type = %q, want %q", ct, "application/json")
+	}
+}
+
+// ===== 流式：空数据 =====
+
+func TestStreamResponse_EmptyBody(t *testing.T) {
+	body := newFakeBody(sseEventDone())
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	result := w.Body.String()
+	if !strings.Contains(result, `"finish_reason":"stop"`) {
+		t.Error("should have stop finish_reason")
+	}
+	if !strings.Contains(result, "data: [DONE]") {
+		t.Error("missing [DONE]")
+	}
+}
+
+// ===== 流式：[DONE] 信号 =====
+
+func TestStreamResponse_DoneSignal(t *testing.T) {
+	body := newFakeBody(
+		sseEvent("answer", "hello", ""),
+		"data: [DONE]",
+	)
+
+	w := httptest.NewRecorder()
+	handleStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	result := w.Body.String()
+	if !strings.Contains(result, "hello") {
+		t.Error("missing content")
+	}
+}
+
+// ===== 非流式：response 格式完整性 =====
+
+func TestNonStreamResponse_FullFormat(t *testing.T) {
+	body := newFakeBody(
+		sseEvent("answer", "test response", ""),
+		sseEventDone(),
+	)
+
+	w := httptest.NewRecorder()
+	handleNonStreamResponse(w, body, "chatcmpl-test", "glm-4.7", nil)
+
+	var resp model.ChatCompletionResponse
+	if err := json.NewDecoder(w.Body).Decode(&resp); err != nil {
+		t.Fatalf("decode: %v", err)
+	}
+
+	if resp.ID != "chatcmpl-test" {
+		t.Errorf("ID = %q", resp.ID)
+	}
+	if resp.Object != "chat.completion" {
+		t.Errorf("Object = %q", resp.Object)
+	}
+	if resp.Model != "glm-4.7" {
+		t.Errorf("Model = %q", resp.Model)
+	}
+	if resp.Choices[0].Message.Role != "assistant" {
+		t.Errorf("Role = %q", resp.Choices[0].Message.Role)
+	}
+}

internal/model/mapping.go

@@ -20,6 +20,8 @@ var ModelList = []string{
 	"GLM-4.7",
 	"GLM-4.7-thinking",
 	"GLM-4.7-thinking-search",
+	"GLM-4.7-tools",
+	"GLM-4.7-tools-thinking",
 	"GLM-4.5-V",
 	"GLM-4.6-V",
 	"GLM-4.6-V-thinking",
@@ -28,13 +30,14 @@ var ModelList = []string{
 }
 
 // 解析模型名称，提取基础模型名和标签
-// 支持 -thinking 和 -search 标签的任意排列组合
-func ParseModelName(model string) (baseModel string, enableThinking bool, enableSearch bool) {
+// 支持 -thinking、-search 和 -tools 标签的任意排列组合
+func ParseModelName(model string) (baseModel string, enableThinking bool, enableSearch bool, enableTools bool) {
 	enableThinking = false
 	enableSearch = false
+	enableTools = false
 	baseModel = model
 
-	// 检查并移除 -thinking 和 -search 标签（任意顺序）
+	// 检查并移除 -thinking、-search 和 -tools 标签（任意顺序）
 	for {
 		if strings.HasSuffix(baseModel, "-thinking") {
 			enableThinking = true
@@ -42,26 +45,34 @@ func ParseModelName(model string) (baseModel string, enableThinking bool, enable
 		} else if strings.HasSuffix(baseModel, "-search") {
 			enableSearch = true
 			baseModel = strings.TrimSuffix(baseModel, "-search")
+		} else if strings.HasSuffix(baseModel, "-tools") {
+			enableTools = true
+			baseModel = strings.TrimSuffix(baseModel, "-tools")
 		} else {
 			break
 		}
 	}
 
-	return baseModel, enableThinking, enableSearch
+	return baseModel, enableThinking, enableSearch, enableTools
 }
 
 func IsThinkingModel(model string) bool {
-	_, enableThinking, _ := ParseModelName(model)
+	_, enableThinking, _, _ := ParseModelName(model)
 	return enableThinking
 }
 
 func IsSearchModel(model string) bool {
-	_, _, enableSearch := ParseModelName(model)
+	_, _, enableSearch, _ := ParseModelName(model)
 	return enableSearch
 }
 
+func IsToolsModel(model string) bool {
+	_, _, _, enableTools := ParseModelName(model)
+	return enableTools
+}
+
 func GetTargetModel(model string) string {
-	baseModel, _, _ := ParseModelName(model)
+	baseModel, _, _, _ := ParseModelName(model)
 	if target, ok := BaseModelMapping[baseModel]; ok {
 		return target
 	}

internal/model/mapping_test.go

@@ -0,0 +1,201 @@
+package model
+
+import "testing"
+
+// ===== ParseModelName =====
+
+func TestParseModelName_Plain(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q, want %q", base, "GLM-4.7")
+	}
+	if thinking || search || tools {
+		t.Errorf("flags = (%v, %v, %v), want all false", thinking, search, tools)
+	}
+}
+
+func TestParseModelName_Thinking(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-thinking")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !thinking {
+		t.Error("thinking should be true")
+	}
+	if search || tools {
+		t.Error("search and tools should be false")
+	}
+}
+
+func TestParseModelName_Search(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-search")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !search {
+		t.Error("search should be true")
+	}
+	if thinking || tools {
+		t.Error("thinking and tools should be false")
+	}
+}
+
+func TestParseModelName_Tools(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-tools")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !tools {
+		t.Error("tools should be true")
+	}
+	if thinking || search {
+		t.Error("thinking and search should be false")
+	}
+}
+
+func TestParseModelName_ThinkingSearch(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-thinking-search")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !thinking || !search {
+		t.Error("thinking and search should both be true")
+	}
+	if tools {
+		t.Error("tools should be false")
+	}
+}
+
+func TestParseModelName_ToolsThinking(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-tools-thinking")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !tools || !thinking {
+		t.Error("tools and thinking should both be true")
+	}
+	if search {
+		t.Error("search should be false")
+	}
+}
+
+func TestParseModelName_ToolsSearch(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-tools-search")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !tools || !search {
+		t.Error("tools and search should both be true")
+	}
+	if thinking {
+		t.Error("thinking should be false")
+	}
+}
+
+func TestParseModelName_AllTags(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-tools-thinking-search")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !thinking || !search || !tools {
+		t.Errorf("all flags should be true, got (%v, %v, %v)", thinking, search, tools)
+	}
+}
+
+func TestParseModelName_ReverseOrder(t *testing.T) {
+	base, thinking, search, tools := ParseModelName("GLM-4.7-search-thinking-tools")
+	if base != "GLM-4.7" {
+		t.Errorf("base = %q", base)
+	}
+	if !thinking || !search || !tools {
+		t.Errorf("all flags should be true, got (%v, %v, %v)", thinking, search, tools)
+	}
+}
+
+// ===== IsToolsModel =====
+
+func TestIsToolsModel_True(t *testing.T) {
+	tests := []string{
+		"GLM-4.7-tools",
+		"GLM-4.7-tools-thinking",
+		"GLM-4.7-tools-search",
+		"GLM-4.7-thinking-tools",
+		"GLM-4.5-tools",
+	}
+	for _, m := range tests {
+		if !IsToolsModel(m) {
+			t.Errorf("IsToolsModel(%q) = false, want true", m)
+		}
+	}
+}
+
+func TestIsToolsModel_False(t *testing.T) {
+	tests := []string{
+		"GLM-4.7",
+		"GLM-4.7-thinking",
+		"GLM-4.7-search",
+		"GLM-4.7-thinking-search",
+	}
+	for _, m := range tests {
+		if IsToolsModel(m) {
+			t.Errorf("IsToolsModel(%q) = true, want false", m)
+		}
+	}
+}
+
+// ===== IsThinkingModel / IsSearchModel 不受 -tools 影响 =====
+
+func TestIsThinkingModel_WithTools(t *testing.T) {
+	if !IsThinkingModel("GLM-4.7-tools-thinking") {
+		t.Error("IsThinkingModel should be true for GLM-4.7-tools-thinking")
+	}
+	if IsThinkingModel("GLM-4.7-tools") {
+		t.Error("IsThinkingModel should be false for GLM-4.7-tools")
+	}
+}
+
+func TestIsSearchModel_WithTools(t *testing.T) {
+	if !IsSearchModel("GLM-4.7-tools-search") {
+		t.Error("IsSearchModel should be true for GLM-4.7-tools-search")
+	}
+	if IsSearchModel("GLM-4.7-tools") {
+		t.Error("IsSearchModel should be false for GLM-4.7-tools")
+	}
+}
+
+// ===== GetTargetModel with -tools =====
+
+func TestGetTargetModel_WithTools(t *testing.T) {
+	target := GetTargetModel("GLM-4.7-tools")
+	if target != "glm-4.7" {
+		t.Errorf("GetTargetModel(GLM-4.7-tools) = %q, want %q", target, "glm-4.7")
+	}
+}
+
+func TestGetTargetModel_WithToolsThinking(t *testing.T) {
+	target := GetTargetModel("GLM-4.7-tools-thinking")
+	if target != "glm-4.7" {
+		t.Errorf("GetTargetModel(GLM-4.7-tools-thinking) = %q, want %q", target, "glm-4.7")
+	}
+}
+
+// ===== ModelList 包含 -tools 变体 =====
+
+func TestModelList_ContainsToolsVariants(t *testing.T) {
+	expected := map[string]bool{
+		"GLM-4.7-tools":          false,
+		"GLM-4.7-tools-thinking": false,
+	}
+
+	for _, m := range ModelList {
+		if _, ok := expected[m]; ok {
+			expected[m] = true
+		}
+	}
+
+	for name, found := range expected {
+		if !found {
+			t.Errorf("ModelList missing %q", name)
+		}
+	}
+}

internal/model/types.go

@@ -13,10 +13,39 @@ type ImageURL struct {
 	URL string `json:"url"`
 }
 
+// Tool 工具定义（OpenAI 兼容）
+type Tool struct {
+	Type     string       `json:"type"`
+	Function ToolFunction `json:"function"`
+}
+
+// ToolFunction 函数定义
+type ToolFunction struct {
+	Name        string      `json:"name"`
+	Description string      `json:"description,omitempty"`
+	Parameters  interface{} `json:"parameters,omitempty"`
+}
+
+// ToolCall 模型返回的工具调用
+type ToolCall struct {
+	ID       string       `json:"id"`
+	Type     string       `json:"type"`
+	Function FunctionCall `json:"function"`
+	Index    int          `json:"index"`
+}
+
+// FunctionCall 函数调用（名称 + 参数 JSON 字符串）
+type FunctionCall struct {
+	Name      string `json:"name"`
+	Arguments string `json:"arguments"`
+}
+
 // Message 支持纯文本和多模态内容
 type Message struct {
-	Role    string      `json:"role"`
-	Content interface{} `json:"content"` // string 或 []ContentPart
+	Role       string      `json:"role"`
+	Content    interface{} `json:"content"`              // string 或 []ContentPart
+	ToolCallID string      `json:"tool_call_id,omitempty"` // role: "tool" 时使用
+	ToolCalls  []ToolCall  `json:"tool_calls,omitempty"`   // role: "assistant" 时使用
 }
 
 // 解析消息内容，返回文本和图片URL列表
@@ -47,6 +76,37 @@ func (m *Message) ParseContent() (text string, imageURLs []string) {
 
 // 转换为上游消息格式，支持多模态
 func (m *Message) ToUpstreamMessage(urlToFileID map[string]string) map[string]interface{} {
+	// tool 消息：包含 tool_call_id
+	if m.Role == "tool" {
+		msg := map[string]interface{}{
+			"role":         m.Role,
+			"content":      m.Content,
+			"tool_call_id": m.ToolCallID,
+		}
+		return msg
+	}
+
+	// assistant 消息带 tool_calls
+	if m.Role == "assistant" && len(m.ToolCalls) > 0 {
+		msg := map[string]interface{}{
+			"role":    m.Role,
+			"content": m.Content,
+		}
+		var toolCalls []map[string]interface{}
+		for _, tc := range m.ToolCalls {
+			toolCalls = append(toolCalls, map[string]interface{}{
+				"id":   tc.ID,
+				"type": tc.Type,
+				"function": map[string]interface{}{
+					"name":      tc.Function.Name,
+					"arguments": tc.Function.Arguments,
+				},
+			})
+		}
+		msg["tool_calls"] = toolCalls
+		return msg
+	}
+
 	text, imageURLs := m.ParseContent()
 
 	// 无图片，返回纯文本
@@ -83,9 +143,11 @@ func (m *Message) ToUpstreamMessage(urlToFileID map[string]string) map[string]in
 }
 
 type ChatRequest struct {
-	Model    string    `json:"model"`
-	Messages []Message `json:"messages"`
-	Stream   bool      `json:"stream"`
+	Model      string      `json:"model"`
+	Messages   []Message   `json:"messages"`
+	Stream     bool        `json:"stream"`
+	Tools      []Tool      `json:"tools,omitempty"`
+	ToolChoice interface{} `json:"tool_choice,omitempty"`
 }
 
 type ChatCompletionChunk struct {
@@ -96,8 +158,6 @@ type ChatCompletionChunk struct {
 	Choices []Choice `json:"choices"`
 }
 
-type
-
 type Choice struct {
 	Index        int          `json:"index"`
 	Delta        Delta        `json:"delta,omitempty"`
@@ -106,14 +166,16 @@ type Choice struct {
 }
 
 type Delta struct {
-	Content          string `json:"content,omitempty"`
-	ReasoningContent string `json:"reasoning_content,omitempty"`
+	Content          string     `json:"content,omitempty"`
+	ReasoningContent string     `json:"reasoning_content,omitempty"`
+	ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
 }
 
 type MessageResp struct {
-	Role             string `json:"role"`
-	Content          string `json:"content"`
-	ReasoningContent string `json:"reasoning_content,omitempty"`
+	Role             string     `json:"role"`
+	Content          string     `json:"content"`
+	ReasoningContent string     `json:"reasoning_content,omitempty"`
+	ToolCalls        []ToolCall `json:"tool_calls,omitempty"`
 }
 
 type ChatCompletionResponse struct {

internal/model/types_test.go

@@ -0,0 +1,503 @@
+package model
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+// ===== Tool 类型序列化/反序列化 =====
+
+func TestToolJSON(t *testing.T) {
+	tool := Tool{
+		Type: "function",
+		Function: ToolFunction{
+			Name:        "get_weather",
+			Description: "获取天气信息",
+			Parameters: map[string]interface{}{
+				"type": "object",
+				"properties": map[string]interface{}{
+					"location": map[string]interface{}{
+						"type":        "string",
+						"description": "城市名称",
+					},
+				},
+				"required": []string{"location"},
+			},
+		},
+	}
+
+	data, err := json.Marshal(tool)
+	if err != nil {
+		t.Fatalf("marshal Tool: %v", err)
+	}
+
+	var decoded Tool
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal Tool: %v", err)
+	}
+
+	if decoded.Type != "function" {
+		t.Errorf("Type = %q, want %q", decoded.Type, "function")
+	}
+	if decoded.Function.Name != "get_weather" {
+		t.Errorf("Function.Name = %q, want %q", decoded.Function.Name, "get_weather")
+	}
+	if decoded.Function.Description != "获取天气信息" {
+		t.Errorf("Function.Description = %q, want %q", decoded.Function.Description, "获取天气信息")
+	}
+}
+
+func TestToolCallJSON(t *testing.T) {
+	tc := ToolCall{
+		ID:   "call_abc123",
+		Type: "function",
+		Function: FunctionCall{
+			Name:      "get_weather",
+			Arguments: `{"location":"北京"}`,
+		},
+		Index: 0,
+	}
+
+	data, err := json.Marshal(tc)
+	if err != nil {
+		t.Fatalf("marshal ToolCall: %v", err)
+	}
+
+	var decoded ToolCall
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal ToolCall: %v", err)
+	}
+
+	if decoded.ID != "call_abc123" {
+		t.Errorf("ID = %q, want %q", decoded.ID, "call_abc123")
+	}
+	if decoded.Function.Name != "get_weather" {
+		t.Errorf("Function.Name = %q, want %q", decoded.Function.Name, "get_weather")
+	}
+	if decoded.Function.Arguments != `{"location":"北京"}` {
+		t.Errorf("Function.Arguments = %q, want %q", decoded.Function.Arguments, `{"location":"北京"}`)
+	}
+}
+
+// ===== ChatRequest 带 Tools 序列化 =====
+
+func TestChatRequestWithTools(t *testing.T) {
+	reqJSON := `{
+		"model": "GLM-4.7",
+		"messages": [{"role": "user", "content": "北京天气怎么样？"}],
+		"stream": true,
+		"tools": [{
+			"type": "function",
+			"function": {
+				"name": "get_weather",
+				"description": "获取天气",
+				"parameters": {"type": "object", "properties": {"location": {"type": "string"}}}
+			}
+		}],
+		"tool_choice": "auto"
+	}`
+
+	var req ChatRequest
+	if err := json.Unmarshal([]byte(reqJSON), &req); err != nil {
+		t.Fatalf("unmarshal ChatRequest: %v", err)
+	}
+
+	if req.Model != "GLM-4.7" {
+		t.Errorf("Model = %q, want %q", req.Model, "GLM-4.7")
+	}
+	if len(req.Tools) != 1 {
+		t.Fatalf("len(Tools) = %d, want 1", len(req.Tools))
+	}
+	if req.Tools[0].Function.Name != "get_weather" {
+		t.Errorf("Tools[0].Function.Name = %q, want %q", req.Tools[0].Function.Name, "get_weather")
+	}
+	if req.ToolChoice != "auto" {
+		t.Errorf("ToolChoice = %v, want %q", req.ToolChoice, "auto")
+	}
+}
+
+func TestChatRequestWithoutTools(t *testing.T) {
+	reqJSON := `{
+		"model": "GLM-4.6",
+		"messages": [{"role": "user", "content": "hello"}],
+		"stream": false
+	}`
+
+	var req ChatRequest
+	if err := json.Unmarshal([]byte(reqJSON), &req); err != nil {
+		t.Fatalf("unmarshal ChatRequest: %v", err)
+	}
+
+	if len(req.Tools) != 0 {
+		t.Errorf("len(Tools) = %d, want 0", len(req.Tools))
+	}
+	if req.ToolChoice != nil {
+		t.Errorf("ToolChoice = %v, want nil", req.ToolChoice)
+	}
+}
+
+func TestChatRequestToolChoiceObject(t *testing.T) {
+	reqJSON := `{
+		"model": "GLM-4.7",
+		"messages": [{"role": "user", "content": "test"}],
+		"stream": false,
+		"tools": [{"type": "function", "function": {"name": "fn1"}}],
+		"tool_choice": {"type": "function", "function": {"name": "fn1"}}
+	}`
+
+	var req ChatRequest
+	if err := json.Unmarshal([]byte(reqJSON), &req); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	tc, ok := req.ToolChoice.(map[string]interface{})
+	if !ok {
+		t.Fatalf("ToolChoice type = %T, want map[string]interface{}", req.ToolChoice)
+	}
+	if tc["type"] != "function" {
+		t.Errorf("ToolChoice.type = %v, want %q", tc["type"], "function")
+	}
+}
+
+// ===== Message 带 ToolCallID / ToolCalls 序列化 =====
+
+func TestMessageWithToolCallID(t *testing.T) {
+	msgJSON := `{
+		"role": "tool",
+		"content": "{\"temperature\": 25}",
+		"tool_call_id": "call_abc123"
+	}`
+
+	var msg Message
+	if err := json.Unmarshal([]byte(msgJSON), &msg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if msg.Role != "tool" {
+		t.Errorf("Role = %q, want %q", msg.Role, "tool")
+	}
+	if msg.ToolCallID != "call_abc123" {
+		t.Errorf("ToolCallID = %q, want %q", msg.ToolCallID, "call_abc123")
+	}
+}
+
+func TestMessageWithToolCalls(t *testing.T) {
+	msgJSON := `{
+		"role": "assistant",
+		"content": "",
+		"tool_calls": [{
+			"id": "call_xyz",
+			"type": "function",
+			"function": {"name": "get_weather", "arguments": "{\"location\":\"上海\"}"},
+			"index": 0
+		}]
+	}`
+
+	var msg Message
+	if err := json.Unmarshal([]byte(msgJSON), &msg); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if len(msg.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(msg.ToolCalls))
+	}
+	if msg.ToolCalls[0].Function.Name != "get_weather" {
+		t.Errorf("ToolCalls[0].Function.Name = %q, want %q", msg.ToolCalls[0].Function.Name, "get_weather")
+	}
+}
+
+// ===== ToUpstreamMessage =====
+
+func TestToUpstreamMessage_ToolRole(t *testing.T) {
+	msg := Message{
+		Role:       "tool",
+		Content:    `{"temperature": 25}`,
+		ToolCallID: "call_abc",
+	}
+
+	result := msg.ToUpstreamMessage(nil)
+
+	if result["role"] != "tool" {
+		t.Errorf("role = %v, want %q", result["role"], "tool")
+	}
+	if result["tool_call_id"] != "call_abc" {
+		t.Errorf("tool_call_id = %v, want %q", result["tool_call_id"], "call_abc")
+	}
+	if result["content"] != `{"temperature": 25}` {
+		t.Errorf("content = %v, want %q", result["content"], `{"temperature": 25}`)
+	}
+}
+
+func TestToUpstreamMessage_AssistantWithToolCalls(t *testing.T) {
+	msg := Message{
+		Role:    "assistant",
+		Content: "",
+		ToolCalls: []ToolCall{
+			{
+				ID:   "call_1",
+				Type: "function",
+				Function: FunctionCall{
+					Name:      "get_weather",
+					Arguments: `{"location":"北京"}`,
+				},
+			},
+			{
+				ID:   "call_2",
+				Type: "function",
+				Function: FunctionCall{
+					Name:      "get_time",
+					Arguments: `{"timezone":"Asia/Shanghai"}`,
+				},
+			},
+		},
+	}
+
+	result := msg.ToUpstreamMessage(nil)
+
+	if result["role"] != "assistant" {
+		t.Errorf("role = %v, want %q", result["role"], "assistant")
+	}
+
+	toolCalls, ok := result["tool_calls"].([]map[string]interface{})
+	if !ok {
+		t.Fatalf("tool_calls type = %T, want []map[string]interface{}", result["tool_calls"])
+	}
+	if len(toolCalls) != 2 {
+		t.Fatalf("len(tool_calls) = %d, want 2", len(toolCalls))
+	}
+	if toolCalls[0]["id"] != "call_1" {
+		t.Errorf("tool_calls[0].id = %v, want %q", toolCalls[0]["id"], "call_1")
+	}
+	fn, ok := toolCalls[0]["function"].(map[string]interface{})
+	if !ok {
+		t.Fatalf("function type = %T", toolCalls[0]["function"])
+	}
+	if fn["name"] != "get_weather" {
+		t.Errorf("function.name = %v, want %q", fn["name"], "get_weather")
+	}
+}
+
+func TestToUpstreamMessage_PlainUser(t *testing.T) {
+	msg := Message{
+		Role:    "user",
+		Content: "hello",
+	}
+
+	result := msg.ToUpstreamMessage(nil)
+	if result["role"] != "user" {
+		t.Errorf("role = %v, want %q", result["role"], "user")
+	}
+	if result["content"] != "hello" {
+		t.Errorf("content = %v, want %q", result["content"], "hello")
+	}
+	if _, exists := result["tool_call_id"]; exists {
+		t.Error("tool_call_id should not be present for user messages")
+	}
+	if _, exists := result["tool_calls"]; exists {
+		t.Error("tool_calls should not be present for user messages")
+	}
+}
+
+func TestToUpstreamMessage_AssistantWithoutToolCalls(t *testing.T) {
+	msg := Message{
+		Role:    "assistant",
+		Content: "你好！",
+	}
+
+	result := msg.ToUpstreamMessage(nil)
+	if result["role"] != "assistant" {
+		t.Errorf("role = %v, want %q", result["role"], "assistant")
+	}
+	if result["content"] != "你好！" {
+		t.Errorf("content = %v, want %q", result["content"], "你好！")
+	}
+	if _, exists := result["tool_calls"]; exists {
+		t.Error("tool_calls should not be present when empty")
+	}
+}
+
+// ===== Delta / MessageResp 带 ToolCalls =====
+
+func TestDeltaWithToolCalls(t *testing.T) {
+	delta := Delta{
+		ToolCalls: []ToolCall{{
+			ID:    "call_1",
+			Type:  "function",
+			Index: 0,
+			Function: FunctionCall{
+				Name:      "get_weather",
+				Arguments: `{"location":"北京"}`,
+			},
+		}},
+	}
+
+	data, err := json.Marshal(delta)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	var decoded Delta
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if len(decoded.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(decoded.ToolCalls))
+	}
+	if decoded.ToolCalls[0].Function.Name != "get_weather" {
+		t.Errorf("Name = %q, want %q", decoded.ToolCalls[0].Function.Name, "get_weather")
+	}
+}
+
+func TestDeltaOmitsEmptyToolCalls(t *testing.T) {
+	delta := Delta{Content: "hello"}
+
+	data, err := json.Marshal(delta)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	// tool_calls 为空时应被 omitempty 省略
+	var raw map[string]interface{}
+	json.Unmarshal(data, &raw)
+	if _, exists := raw["tool_calls"]; exists {
+		t.Error("tool_calls should be omitted when empty")
+	}
+}
+
+func TestMessageRespWithToolCalls(t *testing.T) {
+	resp := MessageResp{
+		Role:    "assistant",
+		Content: "",
+		ToolCalls: []ToolCall{{
+			ID:    "call_1",
+			Type:  "function",
+			Index: 0,
+			Function: FunctionCall{
+				Name:      "search",
+				Arguments: `{"query":"test"}`,
+			},
+		}},
+	}
+
+	data, err := json.Marshal(resp)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	var decoded MessageResp
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if len(decoded.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(decoded.ToolCalls))
+	}
+	if decoded.ToolCalls[0].Function.Arguments != `{"query":"test"}` {
+		t.Errorf("Arguments = %q", decoded.ToolCalls[0].Function.Arguments)
+	}
+}
+
+func TestMessageRespOmitsEmptyToolCalls(t *testing.T) {
+	resp := MessageResp{
+		Role:    "assistant",
+		Content: "hello world",
+	}
+
+	data, _ := json.Marshal(resp)
+	var raw map[string]interface{}
+	json.Unmarshal(data, &raw)
+	if _, exists := raw["tool_calls"]; exists {
+		t.Error("tool_calls should be omitted when empty")
+	}
+}
+
+// ===== ChatCompletionChunk 带 tool_calls finish_reason =====
+
+func TestChunkWithToolCallsFinishReason(t *testing.T) {
+	reason := "tool_calls"
+	chunk := ChatCompletionChunk{
+		ID:      "chatcmpl-test",
+		Object:  "chat.completion.chunk",
+		Created: 1000,
+		Model:   "glm-4.7",
+		Choices: []Choice{{
+			Index:        0,
+			Delta:        Delta{},
+			FinishReason: &reason,
+		}},
+	}
+
+	data, err := json.Marshal(chunk)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	var decoded ChatCompletionChunk
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if decoded.Choices[0].FinishReason == nil {
+		t.Fatal("FinishReason is nil")
+	}
+	if *decoded.Choices[0].FinishReason != "tool_calls" {
+		t.Errorf("FinishReason = %q, want %q", *decoded.Choices[0].FinishReason, "tool_calls")
+	}
+}
+
+// ===== ChatCompletionResponse 带 tool_calls =====
+
+func TestCompletionResponseWithToolCalls(t *testing.T) {
+	reason := "tool_calls"
+	resp := ChatCompletionResponse{
+		ID:      "chatcmpl-test",
+		Object:  "chat.completion",
+		Created: 1000,
+		Model:   "glm-4.7",
+		Choices: []Choice{{
+			Index: 0,
+			Message: &MessageResp{
+				Role:    "assistant",
+				Content: "",
+				ToolCalls: []ToolCall{{
+					ID:    "call_1",
+					Type:  "function",
+					Index: 0,
+					Function: FunctionCall{
+						Name:      "get_weather",
+						Arguments: `{"location":"北京"}`,
+					},
+				}},
+			},
+			FinishReason: &reason,
+		}},
+	}
+
+	data, err := json.Marshal(resp)
+	if err != nil {
+		t.Fatalf("marshal: %v", err)
+	}
+
+	var decoded ChatCompletionResponse
+	if err := json.Unmarshal(data, &decoded); err != nil {
+		t.Fatalf("unmarshal: %v", err)
+	}
+
+	if len(decoded.Choices) != 1 {
+		t.Fatalf("len(Choices) = %d", len(decoded.Choices))
+	}
+	msg := decoded.Choices[0].Message
+	if msg == nil {
+		t.Fatal("Message is nil")
+	}
+	if len(msg.ToolCalls) != 1 {
+		t.Fatalf("len(ToolCalls) = %d, want 1", len(msg.ToolCalls))
+	}
+	if msg.ToolCalls[0].Function.Name != "get_weather" {
+		t.Errorf("Function.Name = %q", msg.ToolCalls[0].Function.Name)
+	}
+	if *decoded.Choices[0].FinishReason != "tool_calls" {
+		t.Errorf("FinishReason = %q", *decoded.Choices[0].FinishReason)
+	}
+}

internal/tools/builtin.go

@@ -0,0 +1,149 @@
+package tools
+
+import "zai-proxy/internal/model"
+
+// GetBuiltinTools 返回所有内置工具定义
+func GetBuiltinTools() []model.Tool {
+	return []model.Tool{
+		// 多功能助手
+		{
+			Type: "function",
+			Function: model.ToolFunction{
+				Name:        "get_current_time",
+				Description: "获取当前时间，支持不同时区和格式",
+				Parameters: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"timezone": map[string]interface{}{
+							"type":        "string",
+							"description": "时区名称（如 Asia/Shanghai, America/New_York）",
+						},
+						"format": map[string]interface{}{
+							"type":        "string",
+							"description": "时间格式（如 2006-01-02 15:04:05）",
+						},
+					},
+					"required": []string{},
+				},
+			},
+		},
+		{
+			Type: "function",
+			Function: model.ToolFunction{
+				Name:        "calculate",
+				Description: "执行数学计算，支持基本运算和高级数学函数",
+				Parameters: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"expression": map[string]interface{}{
+							"type":        "string",
+							"description": "数学表达式（如 2+3*4, sqrt(16), sin(pi/2)）",
+						},
+					},
+					"required": []string{"expression"},
+				},
+			},
+		},
+		{
+			Type: "function",
+			Function: model.ToolFunction{
+				Name:        "search_web",
+				Description: "搜索网络获取实时信息",
+				Parameters: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"query": map[string]interface{}{
+							"type":        "string",
+							"description": "搜索关键词",
+						},
+						"num_results": map[string]interface{}{
+							"type":        "integer",
+							"description": "返回结果数量，默认5",
+						},
+					},
+					"required": []string{"query"},
+				},
+			},
+		},
+		// 数据库查询
+		{
+			Type: "function",
+			Function: model.ToolFunction{
+				Name:        "query_database",
+				Description: "执行SQL查询获取数据",
+				Parameters: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"sql": map[string]interface{}{
+							"type":        "string",
+							"description": "SQL查询语句",
+						},
+						"database": map[string]interface{}{
+							"type":        "string",
+							"description": "目标数据库名称",
+						},
+					},
+					"required": []string{"sql"},
+				},
+			},
+		},
+		// 文件操作
+		{
+			Type: "function",
+			Function: model.ToolFunction{
+				Name:        "file_operations",
+				Description: "执行文件操作，支持读取、写入和列出文件",
+				Parameters: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"operation": map[string]interface{}{
+							"type":        "string",
+							"enum":        []string{"read", "write", "list"},
+							"description": "操作类型：read（读取）、write（写入）、list（列出）",
+						},
+						"path": map[string]interface{}{
+							"type":        "string",
+							"description": "文件或目录路径",
+						},
+						"content": map[string]interface{}{
+							"type":        "string",
+							"description": "写入内容（仅 write 操作需要）",
+						},
+					},
+					"required": []string{"operation", "path"},
+				},
+			},
+		},
+		// API集成
+		{
+			Type: "function",
+			Function: model.ToolFunction{
+				Name:        "call_external_api",
+				Description: "调用外部API接口",
+				Parameters: map[string]interface{}{
+					"type": "object",
+					"properties": map[string]interface{}{
+						"url": map[string]interface{}{
+							"type":        "string",
+							"description": "API请求URL",
+						},
+						"method": map[string]interface{}{
+							"type":        "string",
+							"enum":        []string{"GET", "POST", "PUT", "DELETE"},
+							"description": "HTTP请求方法",
+						},
+						"headers": map[string]interface{}{
+							"type":        "object",
+							"description": "请求头",
+						},
+						"body": map[string]interface{}{
+							"type":        "string",
+							"description": "请求体（JSON字符串）",
+						},
+					},
+					"required": []string{"url", "method"},
+				},
+			},
+		},
+	}
+}

internal/tools/builtin_test.go

@@ -0,0 +1,89 @@
+package tools
+
+import (
+	"testing"
+)
+
+func TestGetBuiltinTools_Count(t *testing.T) {
+	tools := GetBuiltinTools()
+	if len(tools) != 6 {
+		t.Errorf("len(GetBuiltinTools()) = %d, want 6", len(tools))
+	}
+}
+
+func TestGetBuiltinTools_AllFunction(t *testing.T) {
+	for _, tool := range GetBuiltinTools() {
+		if tool.Type != "function" {
+			t.Errorf("tool %q Type = %q, want %q", tool.Function.Name, tool.Type, "function")
+		}
+	}
+}
+
+func TestGetBuiltinTools_Names(t *testing.T) {
+	expected := map[string]bool{
+		"get_current_time":  true,
+		"calculate":         true,
+		"search_web":        true,
+		"query_database":    true,
+		"file_operations":   true,
+		"call_external_api": true,
+	}
+
+	tools := GetBuiltinTools()
+	for _, tool := range tools {
+		name := tool.Function.Name
+		if !expected[name] {
+			t.Errorf("unexpected tool name: %q", name)
+		}
+		delete(expected, name)
+	}
+
+	for name := range expected {
+		t.Errorf("missing tool: %q", name)
+	}
+}
+
+func TestGetBuiltinTools_HaveDescriptions(t *testing.T) {
+	for _, tool := range GetBuiltinTools() {
+		if tool.Function.Description == "" {
+			t.Errorf("tool %q has empty description", tool.Function.Name)
+		}
+	}
+}
+
+func TestGetBuiltinTools_HaveParameters(t *testing.T) {
+	for _, tool := range GetBuiltinTools() {
+		if tool.Function.Parameters == nil {
+			t.Errorf("tool %q has nil parameters", tool.Function.Name)
+		}
+		params, ok := tool.Function.Parameters.(map[string]interface{})
+		if !ok {
+			t.Errorf("tool %q parameters is not a map", tool.Function.Name)
+			continue
+		}
+		if params["type"] != "object" {
+			t.Errorf("tool %q parameters.type = %v, want %q", tool.Function.Name, params["type"], "object")
+		}
+		if _, ok := params["properties"]; !ok {
+			t.Errorf("tool %q parameters missing 'properties'", tool.Function.Name)
+		}
+	}
+}
+
+func TestGetBuiltinTools_NoDuplicateNames(t *testing.T) {
+	seen := make(map[string]bool)
+	for _, tool := range GetBuiltinTools() {
+		if seen[tool.Function.Name] {
+			t.Errorf("duplicate tool name: %q", tool.Function.Name)
+		}
+		seen[tool.Function.Name] = true
+	}
+}
+
+func TestGetBuiltinTools_ReturnsNewSlice(t *testing.T) {
+	a := GetBuiltinTools()
+	b := GetBuiltinTools()
+	if &a[0] == &b[0] {
+		t.Error("GetBuiltinTools should return a new slice each call")
+	}
+}

internal/upstream/client.go

@@ -12,6 +12,7 @@ import (
 
 	"zai-proxy/internal/auth"
 	"zai-proxy/internal/model"
+	builtintools "zai-proxy/internal/tools"
 	"zai-proxy/internal/version"
 )
 
@@ -34,7 +35,7 @@ func ExtractAllImageURLs(messages []model.Message) []string {
 	return allImageURLs
 }
 
-func MakeUpstreamRequest(token string, messages []model.Message, modelName string) (*http.Response, string, error) {
+func MakeUpstreamRequest(token string, messages []model.Message, modelName string, tools []model.Tool, toolChoice interface{}) (*http.Response, string, error) {
 	payload, err := auth.DecodeJWTPayload(token)
 	if err != nil || payload == nil {
 		return nil, "", fmt.Errorf("invalid token")
@@ -119,6 +120,26 @@ func MakeUpstreamRequest(token string, messages []model.Message, modelName strin
 		body["mcp_servers"] = mcpServers
 	}
 
+	// 当使用 -tools 模型时，自动注入内置工具（客户端自带工具优先）
+	if model.IsToolsModel(modelName) {
+		clientToolNames := make(map[string]bool)
+		for _, t := range tools {
+			clientToolNames[t.Function.Name] = true
+		}
+		for _, bt := range builtintools.GetBuiltinTools() {
+			if !clientToolNames[bt.Function.Name] {
+				tools = append(tools, bt)
+			}
+		}
+	}
+
+	if len(tools) > 0 {
+		body["tools"] = tools
+		if toolChoice != nil {
+			body["tool_choice"] = toolChoice
+		}
+	}
+
 	if len(filesData) > 0 {
 		body["files"] = filesData
 		body["current_user_message_id"] = userMsgID

scripts/test_tool_call.sh

@@ -0,0 +1,174 @@
+#!/bin/bash
+# 测试 tool/function calling 功能
+# 用法: ./scripts/test_tool_call.sh [TOKEN] [BASE_URL]
+#
+# TOKEN 可以是你的 z.ai token 或 "free"（匿名）
+# BASE_URL 默认 http://localhost:8000
+
+TOKEN="${1:-free}"
+BASE_URL="${2:-http://localhost:8000}"
+
+echo "=== 测试 Tool/Function Calling ==="
+echo "BASE_URL: $BASE_URL"
+echo "TOKEN: ${TOKEN:0:10}..."
+echo ""
+
+# ===== 测试 1: 带 tools 的流式请求 =====
+echo "--- 测试 1: 流式 tool calling ---"
+curl -sS "${BASE_URL}/v1/chat/completions" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7",
+    "stream": true,
+    "messages": [
+      {"role": "user", "content": "北京今天天气怎么样？请调用 get_weather 函数查询。"}
+    ],
+    "tools": [{
+      "type": "function",
+      "function": {
+        "name": "get_weather",
+        "description": "获取指定城市的当前天气信息",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "location": {
+              "type": "string",
+              "description": "城市名称，如：北京"
+            }
+          },
+          "required": ["location"]
+        }
+      }
+    }],
+    "tool_choice": "auto"
+  }' 2>&1
+echo ""
+echo ""
+
+# ===== 测试 2: 带 tools 的非流式请求 =====
+echo "--- 测试 2: 非流式 tool calling ---"
+curl -sS "${BASE_URL}/v1/chat/completions" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7",
+    "stream": false,
+    "messages": [
+      {"role": "user", "content": "帮我查一下上海的天气，用 get_weather 工具。"}
+    ],
+    "tools": [{
+      "type": "function",
+      "function": {
+        "name": "get_weather",
+        "description": "获取指定城市的当前天气信息",
+        "parameters": {
+          "type": "object",
+          "properties": {
+            "location": {
+              "type": "string",
+              "description": "城市名称"
+            }
+          },
+          "required": ["location"]
+        }
+      }
+    }],
+    "tool_choice": "auto"
+  }' 2>&1 | python3 -m json.tool 2>/dev/null || cat
+echo ""
+echo ""
+
+# ===== 测试 3: 多工具 =====
+echo "--- 测试 3: 多工具非流式 ---"
+curl -sS "${BASE_URL}/v1/chat/completions" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7",
+    "stream": false,
+    "messages": [
+      {"role": "user", "content": "北京天气怎么样？现在几点了？请分别调用对应的工具。"}
+    ],
+    "tools": [
+      {
+        "type": "function",
+        "function": {
+          "name": "get_weather",
+          "description": "获取天气",
+          "parameters": {"type": "object", "properties": {"location": {"type": "string"}}, "required": ["location"]}
+        }
+      },
+      {
+        "type": "function",
+        "function": {
+          "name": "get_current_time",
+          "description": "获取当前时间",
+          "parameters": {"type": "object", "properties": {"timezone": {"type": "string"}}, "required": ["timezone"]}
+        }
+      }
+    ],
+    "tool_choice": "auto"
+  }' 2>&1 | python3 -m json.tool 2>/dev/null || cat
+echo ""
+echo ""
+
+# ===== 测试 4: 完整多轮对话（tool result 回传）=====
+echo "--- 测试 4: 多轮对话 (tool result 回传) ---"
+curl -sS "${BASE_URL}/v1/chat/completions" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7",
+    "stream": false,
+    "messages": [
+      {"role": "user", "content": "北京天气怎么样？"},
+      {
+        "role": "assistant",
+        "content": "",
+        "tool_calls": [{
+          "id": "call_abc123",
+          "type": "function",
+          "function": {"name": "get_weather", "arguments": "{\"location\":\"北京\"}"}
+        }]
+      },
+      {
+        "role": "tool",
+        "tool_call_id": "call_abc123",
+        "content": "{\"temperature\": 25, \"condition\": \"晴\", \"humidity\": 40}"
+      }
+    ],
+    "tools": [{
+      "type": "function",
+      "function": {
+        "name": "get_weather",
+        "description": "获取天气",
+        "parameters": {"type": "object", "properties": {"location": {"type": "string"}}, "required": ["location"]}
+      }
+    }]
+  }' 2>&1 | python3 -m json.tool 2>/dev/null || cat
+echo ""
+echo ""
+
+# ===== 测试 5: 不带 tools 的普通请求（回归测试）=====
+echo "--- 测试 5: 不带 tools 的普通请求（回归）---"
+curl -sS "${BASE_URL}/v1/chat/completions" \
+  -H "Authorization: Bearer ${TOKEN}" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "GLM-4.7",
+    "stream": false,
+    "messages": [
+      {"role": "user", "content": "你好，1+1等于几？"}
+    ]
+  }' 2>&1 | python3 -m json.tool 2>/dev/null || cat
+echo ""
+
+echo "=== 测试完成 ==="
+echo ""
+echo "检查要点："
+echo "  1. 测试 1/2: 查看响应中是否有 tool_calls 字段和 finish_reason=tool_calls"
+echo "  2. 测试 3: 是否返回多个 tool_calls"
+echo "  3. 测试 4: 模型是否基于 tool result 生成了自然语言回复"
+echo "  4. 测试 5: 不带 tools 时是否正常返回文本（无 tool_calls 字段）"
+echo "  5. 查看服务端日志中的 [ToolCall] 行，确认上游返回的原始格式"