页签切换可以了-优化过一次

test/performance_benchmark_test.go

@@ -0,0 +1,383 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"testing"
+	"time"
+
+	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
+)
+
+// TestMessageResponseTimeComparison 性能对比测试：比较8787端口和8020端口的历史消息加载性能
+func TestMessageResponseTimeComparison(t *testing.T) {
+	// 测试会话ID - 使用现有会话
+	sessionID := "ses_3aa9a94dfffeLIdWcLHCG97m7z"
+	t.Logf("🚀 开始性能对比测试")
+	t.Logf("测试会话ID: %s", sessionID)
+
+	// 1. 测试8787端口（直接opencode服务）
+	t.Run("DirectOpenCode_8787", func(t *testing.T) {
+		directURL := "http://localhost:8787"
+
+		// 检查服务是否可用
+		if !isServiceRunningForMessages(t, directURL) {
+			t.Skipf("8787端口服务不可用，跳过测试")
+			return
+		}
+
+		t.Logf("📊 测试8787端口直接访问...")
+
+		// 测试不同消息数量的加载性能
+		testCases := []struct {
+			name   string
+			limit  int
+			repeat int // 重复次数
+		}{
+			{"limit_10", 10, 5},
+			{"limit_50", 50, 5},
+			{"limit_100", 100, 5},
+			{"no_limit", 0, 3},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				var totalDuration time.Duration
+				var successes int
+				var firstByteTimes []time.Duration
+
+				for i := 0; i < tc.repeat; i++ {
+					duration, firstByte, err := measureDirectRequest(directURL, sessionID, tc.limit)
+					if err != nil {
+						t.Logf("⚠️  第%d次请求失败: %v", i+1, err)
+						continue
+					}
+
+					totalDuration += duration
+					firstByteTimes = append(firstByteTimes, firstByte)
+					successes++
+
+					// 请求间短暂延迟
+					time.Sleep(100 * time.Millisecond)
+				}
+
+				if successes > 0 {
+					avgDuration := totalDuration / time.Duration(successes)
+					var avgFirstByte time.Duration
+					for _, fb := range firstByteTimes {
+						avgFirstByte += fb
+					}
+					avgFirstByte /= time.Duration(len(firstByteTimes))
+
+					t.Logf("✅ %s: 成功%d/%d次, 平均总时间: %v, 平均首字节: %v",
+						tc.name, successes, tc.repeat, avgDuration, avgFirstByte)
+				} else {
+					t.Errorf("❌ %s: 所有请求都失败", tc.name)
+				}
+			})
+		}
+	})
+
+	// 2. 测试8020端口（svc-code代理）
+	t.Run("SvcCodeProxy_8020", func(t *testing.T) {
+		proxyURL := "http://localhost:8020"
+
+		// 检查服务是否可用
+		if !isServiceRunningForMessages(t, proxyURL) {
+			t.Skipf("8020端口服务不可用，跳过测试")
+			return
+		}
+
+		// 获取认证token
+		token, err := loginAndGetTokenForMessagesTest(t, proxyURL)
+		if err != nil {
+			t.Skipf("获取认证token失败: %v，跳过8020端口测试", err)
+			return
+		}
+
+		t.Logf("📊 测试8020端口代理访问...")
+		t.Logf("Token获取成功（前20位）: %s...", token[:minForMessagesTest(20, len(token))])
+
+		// 测试不同消息数量的加载性能
+		testCases := []struct {
+			name   string
+			limit  int
+			repeat int // 重复次数
+		}{
+			{"limit_10", 10, 5},
+			{"limit_50", 50, 5},
+			{"limit_100", 100, 5},
+			{"no_limit", 0, 3},
+		}
+
+		for _, tc := range testCases {
+			t.Run(tc.name, func(t *testing.T) {
+				var totalDuration time.Duration
+				var successes int
+				var firstByteTimes []time.Duration
+
+				for i := 0; i < tc.repeat; i++ {
+					duration, firstByte, err := measureProxyRequest(proxyURL, sessionID, token, tc.limit)
+					if err != nil {
+						t.Logf("⚠️  第%d次请求失败: %v", i+1, err)
+						continue
+					}
+
+					totalDuration += duration
+					firstByteTimes = append(firstByteTimes, firstByte)
+					successes++
+
+					// 请求间短暂延迟
+					time.Sleep(100 * time.Millisecond)
+				}
+
+				if successes > 0 {
+					avgDuration := totalDuration / time.Duration(successes)
+					var avgFirstByte time.Duration
+					for _, fb := range firstByteTimes {
+						avgFirstByte += fb
+					}
+					avgFirstByte /= time.Duration(len(firstByteTimes))
+
+					t.Logf("✅ %s: 成功%d/%d次, 平均总时间: %v, 平均首字节: %v",
+						tc.name, successes, tc.repeat, avgDuration, avgFirstByte)
+				} else {
+					t.Errorf("❌ %s: 所有请求都失败", tc.name)
+				}
+			})
+		}
+	})
+}
+
+// TestPerformanceSummary 性能对比总结
+func TestPerformanceSummary(t *testing.T) {
+	sessionID := "ses_3aa9a94dfffeLIdWcLHCG97m7z"
+
+	// 只测试limit=50的情况，进行更详细的对比
+	t.Logf("📈 性能对比总结测试 (limit=50)")
+
+	// 测试8787端口
+	directTimes := []time.Duration{}
+	directFirstBytes := []time.Duration{}
+	directURL := "http://localhost:8787"
+
+	if isServiceRunningForMessages(t, directURL) {
+		t.Log("🔍 测试8787端口...")
+		for i := 0; i < 10; i++ {
+			duration, firstByte, err := measureDirectRequest(directURL, sessionID, 50)
+			if err != nil {
+				t.Logf("⚠️  8787端口第%d次请求失败: %v", i+1, err)
+				continue
+			}
+			directTimes = append(directTimes, duration)
+			directFirstBytes = append(directFirstBytes, firstByte)
+			time.Sleep(50 * time.Millisecond)
+		}
+	}
+
+	// 测试8020端口
+	proxyTimes := []time.Duration{}
+	proxyFirstBytes := []time.Duration{}
+	proxyURL := "http://localhost:8020"
+	token := ""
+
+	if isServiceRunningForMessages(t, proxyURL) {
+		t.Log("🔍 测试8020端口...")
+		token, _ = loginAndGetTokenForMessagesTest(t, proxyURL)
+		if token != "" {
+			for i := 0; i < 10; i++ {
+				duration, firstByte, err := measureProxyRequest(proxyURL, sessionID, token, 50)
+				if err != nil {
+					t.Logf("⚠️  8020端口第%d次请求失败: %v", i+1, err)
+					continue
+				}
+				proxyTimes = append(proxyTimes, duration)
+				proxyFirstBytes = append(proxyFirstBytes, firstByte)
+				time.Sleep(50 * time.Millisecond)
+			}
+		}
+	}
+
+	// 分析结果
+	if len(directTimes) > 0 && len(proxyTimes) > 0 {
+		directAvg := averageDuration(directTimes)
+		directFBAvg := averageDuration(directFirstBytes)
+		proxyAvg := averageDuration(proxyTimes)
+		proxyFBAvg := averageDuration(proxyFirstBytes)
+
+		diff := proxyAvg - directAvg
+		diffPercent := float64(diff) / float64(directAvg) * 100
+
+		t.Logf("\n📊 性能对比结果:")
+		t.Logf("   8787端口（直接）: 平均总时间=%v, 平均首字节=%v", directAvg, directFBAvg)
+		t.Logf("   8020端口（代理）: 平均总时间=%v, 平均首字节=%v", proxyAvg, proxyFBAvg)
+		t.Logf("   差异: %v (%.1f%%)", diff, diffPercent)
+
+		if diffPercent > 20 {
+			t.Logf("⚠️  8020端口比8787端口慢%.1f%%，可能存在代理开销", diffPercent)
+		} else if diffPercent > 50 {
+			t.Logf("❌ 8020端口性能显著下降，建议优化代理逻辑")
+		} else if diffPercent < -10 {
+			t.Logf("✅ 8020端口性能更好，可能包含缓存优化")
+		} else {
+			t.Logf("✅ 两端性能接近，差异在可接受范围内")
+		}
+	} else {
+		t.Logf("⚠️  无法完成完整对比，部分端口数据缺失")
+		if len(directTimes) == 0 {
+			t.Logf("   - 8787端口无有效数据")
+		}
+		if len(proxyTimes) == 0 {
+			t.Logf("   - 8020端口无有效数据")
+		}
+	}
+}
+
+// measureDirectRequest 测量直接访问8787端口的请求性能
+func measureDirectRequest(baseURL, sessionID string, limit int) (totalDuration, firstByteDuration time.Duration, err error) {
+	// 构造URL
+	url := fmt.Sprintf("%s/session/%s/message", baseURL, sessionID)
+	if limit > 0 {
+		url = fmt.Sprintf("%s?limit=%d", url, limit)
+	}
+
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+	}
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		return 0, 0, fmt.Errorf("创建请求失败: %w", err)
+	}
+	req.Header.Set("Accept", "application/json")
+
+	startTime := time.Now()
+
+	// 监听响应首字节
+	req.Header.Set("Accept-Encoding", "identity") // 禁用压缩以便准确测量
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, 0, fmt.Errorf("HTTP请求失败: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// 记录首字节到达时间
+	firstByteTime := time.Now()
+	firstByteDuration = firstByteTime.Sub(startTime)
+
+	// 读取完整响应体
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0, 0, fmt.Errorf("读取响应体失败: %w", err)
+	}
+
+	totalDuration = time.Since(startTime)
+
+	// 验证响应状态
+	if resp.StatusCode != http.StatusOK {
+		return 0, 0, fmt.Errorf("状态码错误: %d, 响应: %s", resp.StatusCode, string(body[:minForMessagesTest(200, len(body))]))
+	}
+
+	// 验证响应格式
+	var messages []opencode.SessionMessage
+	if err := json.Unmarshal(body, &messages); err != nil {
+		return 0, 0, fmt.Errorf("解析响应失败: %w", err)
+	}
+
+	return totalDuration, firstByteDuration, nil
+}
+
+// measureProxyRequest 测量通过8020端口代理的请求性能
+func measureProxyRequest(baseURL, sessionID, token string, limit int) (totalDuration, firstByteDuration time.Duration, err error) {
+	// 构造URL
+	url := fmt.Sprintf("%s/api/session/messages", baseURL)
+
+	// 创建请求体
+	requestBody := map[string]interface{}{
+		"sessionID": sessionID,
+	}
+	if limit > 0 {
+		requestBody["limit"] = limit
+	}
+
+	jsonBody, err := json.Marshal(requestBody)
+	if err != nil {
+		return 0, 0, fmt.Errorf("编码请求体失败: %w", err)
+	}
+
+	client := &http.Client{
+		Timeout: 30 * time.Second,
+	}
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
+	if err != nil {
+		return 0, 0, fmt.Errorf("创建请求失败: %w", err)
+	}
+
+	// 添加认证头
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Accept", "application/json")
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("Accept-Encoding", "identity")
+
+	startTime := time.Now()
+
+	resp, err := client.Do(req)
+	if err != nil {
+		return 0, 0, fmt.Errorf("HTTP请求失败: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// 记录首字节到达时间
+	firstByteTime := time.Now()
+	firstByteDuration = firstByteTime.Sub(startTime)
+
+	// 读取完整响应体
+	body, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return 0, 0, fmt.Errorf("读取响应体失败: %w", err)
+	}
+
+	totalDuration = time.Since(startTime)
+
+	// 验证响应状态
+	if resp.StatusCode != http.StatusOK {
+		return 0, 0, fmt.Errorf("状态码错误: %d, 响应: %s", resp.StatusCode, string(body[:minForMessagesTest(200, len(body))]))
+	}
+
+	// 验证响应格式
+	var result struct {
+		Success bool   `json:"success"`
+		Message string `json:"message"`
+		Data    struct {
+			Messages []opencode.SessionMessage `json:"messages"`
+			Count    int                       `json:"count"`
+		} `json:"data"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		return 0, 0, fmt.Errorf("解析响应失败: %w", err)
+	}
+
+	if !result.Success {
+		return 0, 0, fmt.Errorf("API调用失败: %s", result.Message)
+	}
+
+	return totalDuration, firstByteDuration, nil
+}
+
+// averageDuration 计算平均时长
+func averageDuration(durations []time.Duration) time.Duration {
+	if len(durations) == 0 {
+		return 0
+	}
+	var total time.Duration
+	for _, d := range durations {
+		total += d
+	}
+	return total / time.Duration(len(durations))
+}

test/session_messages_test.go

@@ -476,3 +476,569 @@ func minForMessagesTest(a, b int) int {
 	}
 	return b
 }
+
+// extractTimestamp 从SessionMessage提取时间戳
+func extractTimestamp(msg opencode.SessionMessage) (time.Time, error) {
+	// 尝试从info.time.created提取
+	if msg.Info != nil {
+		// 调试：打印info的所有键
+		// fmt.Printf("Info keys: %v\n", getMapKeys(msg.Info))
+
+		// 1. 尝试从time.created提取（毫秒时间戳）
+		if timeMap, ok := msg.Info["time"].(map[string]interface{}); ok {
+			// fmt.Printf("Time map keys: %v\n", getMapKeys(timeMap))
+
+			// 尝试毫秒时间戳（整数）
+			if createdMs, ok := timeMap["created"].(float64); ok {
+				// 转换为秒（除以1000）
+				seconds := int64(createdMs) / 1000
+				nanoseconds := (int64(createdMs) % 1000) * 1000000
+				return time.Unix(seconds, nanoseconds), nil
+			}
+			// 尝试字符串格式
+			if createdStr, ok := timeMap["created"].(string); ok {
+				return time.Parse(time.RFC3339, createdStr)
+			}
+		}
+		// 2. 尝试直接提取created（毫秒时间戳）
+		if createdMs, ok := msg.Info["created"].(float64); ok {
+			seconds := int64(createdMs) / 1000
+			nanoseconds := (int64(createdMs) % 1000) * 1000000
+			return time.Unix(seconds, nanoseconds), nil
+		}
+		// 3. 尝试从created_at提取（字符串或数字）
+		if createdVal, ok := msg.Info["created_at"]; ok {
+			switch v := createdVal.(type) {
+			case float64:
+				seconds := int64(v) / 1000
+				nanoseconds := (int64(v) % 1000) * 1000000
+				return time.Unix(seconds, nanoseconds), nil
+			case string:
+				return time.Parse(time.RFC3339, v)
+			}
+		}
+		// 4. 尝试从createdAt提取（驼峰式）
+		if createdAtVal, ok := msg.Info["createdAt"]; ok {
+			switch v := createdAtVal.(type) {
+			case float64:
+				seconds := int64(v) / 1000
+				nanoseconds := (int64(v) % 1000) * 1000000
+				return time.Unix(seconds, nanoseconds), nil
+			case string:
+				return time.Parse(time.RFC3339, v)
+			}
+		}
+		// 5. 尝试从timestamp提取
+		if timestampFloat, ok := msg.Info["timestamp"].(float64); ok {
+			return time.Unix(int64(timestampFloat), 0), nil
+		}
+		// 6. 尝试从date提取
+		if dateStr, ok := msg.Info["date"].(string); ok {
+			return time.Parse(time.RFC3339, dateStr)
+		}
+		// 7. 尝试从time直接提取（可能是字符串）
+		if timeStr, ok := msg.Info["time"].(string); ok {
+			return time.Parse(time.RFC3339, timeStr)
+		}
+	}
+	return time.Time{}, fmt.Errorf("无法提取时间戳")
+}
+
+// getMapKeys 获取map的所有键（用于调试）
+func getMapKeys(m map[string]interface{}) []string {
+	keys := make([]string, 0, len(m))
+	for k := range m {
+		keys = append(keys, k)
+	}
+	return keys
+}
+
+// TestMessageFormatAndSorting 测试消息格式和排序规则
+func TestMessageFormatAndSorting(t *testing.T) {
+	// 外部已启动的OpenCode服务端口
+	externalOpenCodePort := 8787
+	opencodeURL := fmt.Sprintf("http://127.0.0.1:%d", externalOpenCodePort)
+
+	// 检查OpenCode服务是否运行
+	if !isServiceRunningForMessages(t, opencodeURL) {
+		t.Skipf("OpenCode服务未运行在 %s，跳过测试", opencodeURL)
+	}
+
+	t.Logf("🚀 开始测试消息格式和排序规则")
+	t.Logf("OpenCode URL: %s", opencodeURL)
+
+	// 使用现有的测试会话ID
+	sessionID := "ses_3aa9a94dfffeLIdWcLHCG97m7z"
+	t.Logf("测试会话ID: %s", sessionID)
+
+	// 创建客户端
+	client, err := opencode.NewDirectClient(externalOpenCodePort)
+	if err != nil {
+		t.Fatalf("❌ 创建OpenCode客户端失败: %v", err)
+	}
+
+	ctx := context.Background()
+
+	// 获取消息（不带limit）
+	t.Log("📝 获取消息进行格式和排序分析")
+	messages, err := client.GetSessionMessages(ctx, sessionID, 0)
+	if err != nil {
+		t.Fatalf("❌ 获取会话消息失败: %v", err)
+	}
+
+	t.Logf("✅ 获取到 %d 条消息进行分析", len(messages))
+
+	if len(messages) == 0 {
+		t.Skip("会话中没有消息，跳过格式和排序测试")
+	}
+
+	// 1. 验证消息格式完整性
+	t.Run("MessageFormatIntegrity", func(t *testing.T) {
+		for i, msg := range messages {
+			// 检查消息ID
+			msgID := extractMessageID(msg)
+			if msgID == "" {
+				t.Errorf("❌ 消息[%d]缺少ID", i)
+			}
+
+			// 检查角色
+			role := extractMessageRole(msg)
+			if role == "" {
+				t.Errorf("❌ 消息[%d]缺少角色", i)
+			}
+
+			// 检查内容
+			content := extractMessageContent(msg)
+			if content == "" && role != "system" {
+				t.Logf("⚠️  消息[%d] (ID: %s, 角色: %s) 内容为空", i, msgID, role)
+			}
+
+			// 检查时间戳
+			timestamp, err := extractTimestamp(msg)
+			if err != nil {
+				t.Logf("⚠️  消息[%d] (ID: %s) 无法提取时间戳: %v", i, msgID, err)
+			} else {
+				t.Logf("   消息[%d] 时间戳: %v", i, timestamp.Format("2006-01-02 15:04:05"))
+			}
+		}
+	})
+
+	// 2. 验证消息排序（时间倒序：最新在前）
+	t.Run("MessageSortingOrder", func(t *testing.T) {
+		if len(messages) < 2 {
+			t.Skip("消息数量不足，跳过排序测试")
+		}
+
+		// 收集所有有效的时间戳
+		var timestamps []time.Time
+		var validMessages []opencode.SessionMessage
+
+		for i, msg := range messages {
+			timestamp, err := extractTimestamp(msg)
+			if err == nil {
+				timestamps = append(timestamps, timestamp)
+				validMessages = append(validMessages, msg)
+			} else {
+				t.Logf("⚠️  消息[%d] 跳过排序检查（无有效时间戳）", i)
+			}
+		}
+
+		if len(timestamps) < 2 {
+			t.Skip("有效时间戳数量不足，跳过排序测试")
+		}
+
+		// 检查排序方向
+		// 先确定排序方向：检查前几对消息
+		var isDescending bool
+		if len(timestamps) >= 2 {
+			// 检查前几对确定方向
+			descendingCount := 0
+			ascendingCount := 0
+			for i := 1; i < minForMessagesTest(5, len(timestamps)); i++ {
+				if timestamps[i].Before(timestamps[i-1]) {
+					descendingCount++ // 时间递减（最新在前）
+				} else if timestamps[i].After(timestamps[i-1]) {
+					ascendingCount++ // 时间递增（最早在前）
+				}
+			}
+
+			if descendingCount > ascendingCount {
+				isDescending = true
+				t.Logf("✅ 消息按时间倒序排列（最新在前）")
+			} else if ascendingCount > descendingCount {
+				isDescending = false
+				t.Logf("✅ 消息按时间顺序排列（最早在前）")
+			} else {
+				t.Logf("⚠️  无法确定排序方向，可能时间戳相同或乱序")
+				isDescending = false
+			}
+
+			// 验证排序一致性
+			if isDescending {
+				// 应该时间递减
+				for i := 1; i < len(timestamps); i++ {
+					if timestamps[i].After(timestamps[i-1]) {
+						t.Logf("❌ 倒序不一致: 消息[%d] (%v) 比消息[%d] (%v) 更晚",
+							i, timestamps[i].Format("15:04:05"),
+							i-1, timestamps[i-1].Format("15:04:05"))
+					}
+				}
+			} else {
+				// 应该时间递增
+				for i := 1; i < len(timestamps); i++ {
+					if timestamps[i].Before(timestamps[i-1]) {
+						t.Logf("❌ 顺序不一致: 消息[%d] (%v) 比消息[%d] (%v) 更早",
+							i, timestamps[i].Format("15:04:05"),
+							i-1, timestamps[i-1].Format("15:04:05"))
+					}
+				}
+			}
+		}
+
+		if isDescending {
+			t.Logf("✅ 消息按时间倒序排列（最新在前）")
+			// 打印时间戳范围
+			if len(timestamps) > 0 {
+				firstTime := timestamps[0]
+				lastTime := timestamps[len(timestamps)-1]
+				t.Logf("📊 时间戳范围:")
+				t.Logf("    第一条消息: %v (%v)", firstTime.Format("2006-01-02 15:04:05"), firstTime.Unix())
+				t.Logf("    最后一条消息: %v (%v)", lastTime.Format("2006-01-02 15:04:05"), lastTime.Unix())
+				t.Logf("    时间跨度: %v", lastTime.Sub(firstTime))
+
+				// 打印前3条和后3条
+				t.Logf("    前3条消息时间:")
+				for i := 0; i < minForMessagesTest(3, len(timestamps)); i++ {
+					t.Logf("      [%d]: %v", i, timestamps[i].Format("15:04:05"))
+				}
+				if len(timestamps) > 6 {
+					t.Logf("    后3条消息时间:")
+					for i := len(timestamps) - 3; i < len(timestamps); i++ {
+						t.Logf("      [%d]: %v", i, timestamps[i].Format("15:04:05"))
+					}
+				}
+			}
+		}
+		// 不因为排序方向而失败，只是记录信息
+		if !isDescending {
+			t.Logf("ℹ️  消息按时间顺序排列（最早在前），这对于增量加载是好事")
+		}
+	})
+
+	// 3. 验证limit参数对排序的影响
+	t.Run("LimitParameterEffect", func(t *testing.T) {
+		// 获取带limit的消息
+		limit := 5
+		if len(messages) < limit {
+			limit = len(messages)
+		}
+
+		limitedMessages, err := client.GetSessionMessages(ctx, sessionID, limit)
+		if err != nil {
+			t.Fatalf("❌ 获取限制数量的消息失败: %v", err)
+		}
+
+		t.Logf("✅ 获取到 %d 条限制消息", len(limitedMessages))
+
+		// 检查limit是否有效
+		if len(limitedMessages) > limit {
+			t.Errorf("❌ limit参数无效: 返回 %d 条消息，限制为 %d", len(limitedMessages), limit)
+		}
+
+		// 检查limit消息是否与原消息前N条一致
+		if len(limitedMessages) > 0 && len(messages) >= len(limitedMessages) {
+			for i := 0; i < len(limitedMessages); i++ {
+				limitedID := extractMessageID(limitedMessages[i])
+				fullID := extractMessageID(messages[i])
+
+				if limitedID != fullID {
+					t.Errorf("❌ limit消息不匹配: 位置[%d] limit消息ID=%s, 全量消息ID=%s",
+						i, limitedID, fullID)
+					break
+				}
+			}
+			if t.Failed() {
+				t.Logf("⚠️  limit消息与全量消息前N条不一致")
+			} else {
+				t.Logf("✅ limit参数正确返回前%d条消息", limit)
+			}
+		}
+	})
+
+	// 4. 输出消息格式摘要
+	t.Run("MessageFormatSummary", func(t *testing.T) {
+		t.Logf("📋 消息格式摘要:")
+		t.Logf("   消息总数: %d", len(messages))
+
+		// 角色统计
+		roleCount := make(map[string]int)
+		for _, msg := range messages {
+			role := extractMessageRole(msg)
+			roleCount[role]++
+		}
+		for role, count := range roleCount {
+			t.Logf("   角色 '%s': %d 条", role, count)
+		}
+
+		// 时间戳可用性统计
+		timestampCount := 0
+		for _, msg := range messages {
+			_, err := extractTimestamp(msg)
+			if err == nil {
+				timestampCount++
+			}
+		}
+		t.Logf("   有效时间戳: %d/%d (%.1f%%)", timestampCount, len(messages),
+			float64(timestampCount)/float64(len(messages))*100)
+
+		// 内容长度统计
+		totalContentLength := 0
+		for _, msg := range messages {
+			content := extractMessageContent(msg)
+			totalContentLength += len(content)
+		}
+		t.Logf("   总内容长度: %d 字符", totalContentLength)
+		if len(messages) > 0 {
+			t.Logf("   平均内容长度: %.1f 字符", float64(totalContentLength)/float64(len(messages)))
+		}
+
+		// 打印第一条消息的完整结构（用于调试）
+		if len(messages) > 0 {
+			t.Logf("🔍 第一条消息完整结构:")
+			firstMsg := messages[0]
+			if firstMsg.Info != nil {
+				infoJSON, _ := json.MarshalIndent(firstMsg.Info, "      ", "  ")
+				t.Logf("     Info: %s", infoJSON)
+				// 打印Info的所有键
+				t.Logf("     Info keys: %v", getMapKeys(firstMsg.Info))
+			} else {
+				t.Logf("     Info: nil")
+			}
+			if len(firstMsg.Parts) > 0 {
+				partsJSON, _ := json.MarshalIndent(firstMsg.Parts, "      ", "  ")
+				t.Logf("     Parts: %s", partsJSON)
+			} else {
+				t.Logf("     Parts: 空数组")
+			}
+		}
+	})
+}
+
+// TestMessageQueryPerformance 测试消息查询性能
+func TestMessageQueryPerformance(t *testing.T) {
+	// 外部已启动的OpenCode服务端口
+	externalOpenCodePort := 8787
+	opencodeURL := fmt.Sprintf("http://127.0.0.1:%d", externalOpenCodePort)
+
+	// 检查OpenCode服务是否运行
+	if !isServiceRunningForMessages(t, opencodeURL) {
+		t.Skipf("OpenCode服务未运行在 %s，跳过测试", opencodeURL)
+	}
+
+	// 检查svc-code服务是否运行
+	svcCodeURL := "http://localhost:8020"
+	if !isServiceRunningForMessages(t, svcCodeURL) {
+		t.Skipf("svc-code服务未运行在 %s，跳过测试", svcCodeURL)
+	}
+
+	t.Logf("🚀 开始测试消息查询性能")
+	t.Logf("OpenCode URL: %s", opencodeURL)
+	t.Logf("svc-code URL: %s", svcCodeURL)
+
+	// 使用现有的测试会话ID
+	sessionID := "ses_3aa9a94dfffeLIdWcLHCG97m7z"
+	t.Logf("测试会话ID: %s", sessionID)
+
+	// 先获取总消息数，以确定合适的limit值
+	t.Log("📊 获取消息总数...")
+	client, err := opencode.NewDirectClient(externalOpenCodePort)
+	if err != nil {
+		t.Fatalf("❌ 创建OpenCode客户端失败: %v", err)
+	}
+
+	ctx := context.Background()
+	allMessages, err := client.GetSessionMessages(ctx, sessionID, 0)
+	if err != nil {
+		t.Fatalf("❌ 获取总消息失败: %v", err)
+	}
+
+	totalMessages := len(allMessages)
+	t.Logf("📊 会话总消息数: %d", totalMessages)
+
+	// 定义要测试的limit值
+	testLimits := []int{2, 5, 10, 20, 50, 100, 200, 300}
+	// 如果总消息数小于某个limit，调整测试值
+	var adjustedLimits []int
+	for _, limit := range testLimits {
+		if limit <= totalMessages {
+			adjustedLimits = append(adjustedLimits, limit)
+		}
+	}
+	adjustedLimits = append(adjustedLimits, 0) // 0表示无限制（全量）
+
+	t.Logf("📊 测试的limit值: %v", adjustedLimits)
+
+	// 1. 测试直接OpenCode API性能
+	t.Run("DirectOpenCodeAPI", func(t *testing.T) {
+		t.Log("📊 测试直接OpenCode API性能...")
+
+		for _, limit := range adjustedLimits {
+			start := time.Now()
+
+			// 构造URL
+			url := fmt.Sprintf("%s/session/%s/message", opencodeURL, sessionID)
+			if limit > 0 {
+				url = fmt.Sprintf("%s?limit=%d", url, limit)
+			}
+
+			// 发送请求
+			client := &http.Client{Timeout: 30 * time.Second}
+			req, err := http.NewRequest("GET", url, nil)
+			if err != nil {
+				t.Errorf("❌ 创建请求失败 (limit=%d): %v", limit, err)
+				continue
+			}
+			req.Header.Set("Accept", "application/json")
+
+			resp, err := client.Do(req)
+			if err != nil {
+				t.Errorf("❌ HTTP请求失败 (limit=%d): %v", limit, err)
+				continue
+			}
+
+			// 读取响应体（确保完全读取以测量网络传输时间）
+			body, err := io.ReadAll(resp.Body)
+			resp.Body.Close()
+
+			duration := time.Since(start)
+
+			if err != nil {
+				t.Errorf("❌ 读取响应体失败 (limit=%d): %v", limit, err)
+				continue
+			}
+
+			if resp.StatusCode != http.StatusOK {
+				t.Errorf("❌ 请求失败 (limit=%d): 状态码 %d", limit, resp.StatusCode)
+				continue
+			}
+
+			// 解析消息数量（可选）
+			var messages []opencode.SessionMessage
+			if err := json.Unmarshal(body, &messages); err != nil {
+				t.Logf("⚠️  解析消息失败 (limit=%d): %v", limit, err)
+			}
+
+			actualCount := len(messages)
+			t.Logf("   limit=%d: 耗时=%v, 返回消息数=%d, 响应体大小=%d字节",
+				limit, duration, actualCount, len(body))
+		}
+	})
+
+	// 2. 测试通过svc-code API性能
+	t.Run("SvcCodeAPI", func(t *testing.T) {
+		t.Log("📊 测试svc-code API性能...")
+
+		// 用户登录获取token
+		token, err := loginAndGetTokenForMessagesTest(t, svcCodeURL)
+		if err != nil {
+			t.Fatalf("❌ 登录失败: %v", err)
+		}
+
+		for _, limit := range adjustedLimits {
+			start := time.Now()
+
+			// 构造URL
+			url := fmt.Sprintf("%s/api/session/messages", svcCodeURL)
+
+			// 构建请求体（POST方法）
+			requestBody := map[string]interface{}{
+				"sessionID": sessionID,
+			}
+			if limit > 0 {
+				requestBody["limit"] = limit
+			}
+
+			jsonBody, err := json.Marshal(requestBody)
+			if err != nil {
+				t.Errorf("❌ 编码请求体失败 (limit=%d): %v", limit, err)
+				continue
+			}
+
+			// 创建POST请求
+			req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonBody))
+			if err != nil {
+				t.Errorf("❌ 创建请求失败 (limit=%d): %v", limit, err)
+				continue
+			}
+
+			// 添加认证头和内容类型
+			req.Header.Set("Authorization", "Bearer "+token)
+			req.Header.Set("Content-Type", "application/json")
+			req.Header.Set("Accept", "application/json")
+
+			// 发送请求
+			client := &http.Client{Timeout: 30 * time.Second}
+			resp, err := client.Do(req)
+			if err != nil {
+				t.Errorf("❌ HTTP请求失败 (limit=%d): %v", limit, err)
+				continue
+			}
+
+			// 读取响应体
+			body, err := io.ReadAll(resp.Body)
+			resp.Body.Close()
+
+			duration := time.Since(start)
+
+			if err != nil {
+				t.Errorf("❌ 读取响应体失败 (limit=%d): %v", limit, err)
+				continue
+			}
+
+			if resp.StatusCode != http.StatusOK {
+				t.Errorf("❌ 请求失败 (limit=%d): 状态码 %d, 响应体: %s",
+					limit, resp.StatusCode, string(body[:minForMessagesTest(200, len(body))]))
+				continue
+			}
+
+			// 解析响应
+			var result struct {
+				Success bool   `json:"success"`
+				Message string `json:"message"`
+				Data    struct {
+					Messages []opencode.SessionMessage `json:"messages"`
+					Count    int                       `json:"count"`
+				} `json:"data"`
+			}
+
+			if err := json.Unmarshal(body, &result); err != nil {
+				t.Errorf("❌ 解析响应失败 (limit=%d): %v, 响应体: %s",
+					limit, err, string(body[:minForMessagesTest(200, len(body))]))
+				continue
+			}
+
+			if !result.Success {
+				t.Errorf("❌ API调用失败 (limit=%d): %s", limit, result.Message)
+				continue
+			}
+
+			actualCount := len(result.Data.Messages)
+			t.Logf("   limit=%d: 耗时=%v, 返回消息数=%d, 响应体大小=%d字节",
+				limit, duration, actualCount, len(body))
+		}
+	})
+
+	// 3. 性能对比总结
+	t.Run("PerformanceSummary", func(t *testing.T) {
+		t.Log("📊 性能对比总结:")
+		t.Log("   （具体数据见上述测试输出）")
+		t.Log("   📈 预期趋势:")
+		t.Log("     1. limit越小，响应时间越短")
+		t.Log("     2. 响应体大小与消息数量成正比")
+		t.Log("     3. svc-code API会有额外开销（认证、封装）")
+		t.Log("   💡 优化建议:")
+		t.Log("     1. 增量加载：只查询新消息（limit=新消息数量）")
+		t.Log("     2. 缓存：避免重复查询相同消息")
+		t.Log("     3. 前端过滤：即使查询全量，也可缓存过滤")
+	})
+}