添加项目管理api

internal/model/session.go

@@ -0,0 +1,124 @@
+package model
+
+import (
+	"time"
+
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+// SessionStatus 会话状态枚举
+const (
+	StatusRequirementDocument = "requirement_document" // 需求文档
+	StatusTechnicalDocument   = "technical_document"   // 技术文档
+	StatusCode                = "code"                 // 代码
+	StatusTest                = "test"                 // 测试
+	StatusRelease             = "release"              // 发布
+)
+
+// IsValidStatus 验证状态是否有效
+func IsValidStatus(status string) bool {
+	validStatuses := []string{
+		StatusRequirementDocument,
+		StatusTechnicalDocument,
+		StatusCode,
+		StatusTest,
+		StatusRelease,
+	}
+	for _, s := range validStatuses {
+		if s == status {
+			return true
+		}
+	}
+	return false
+}
+
+// Agent 智能体枚举
+const (
+	AgentReplenish  = "replenish"  // 补货
+	AgentTransfer   = "transfer"   // 调拨
+	AgentAllocation = "allocation" // 配货
+	AgentReport     = "report"     // 报表
+)
+
+// AgentDisplayName 智能体显示名称映射
+var AgentDisplayName = map[string]string{
+	AgentReplenish:  "补货",
+	AgentTransfer:   "调拨",
+	AgentAllocation: "配货",
+	AgentReport:     "报表",
+}
+
+// GetAllAgents 获取所有智能体列表
+func GetAllAgents() []map[string]string {
+	agents := []map[string]string{}
+	for id, name := range AgentDisplayName {
+		agents = append(agents, map[string]string{
+			"id":   id,
+			"name": name,
+		})
+	}
+	return agents
+}
+
+// IsValidAgent 验证智能体名称是否有效
+func IsValidAgent(agentName string) bool {
+	_, exists := AgentDisplayName[agentName]
+	return exists
+}
+
+// Session 主会话文档
+type Session struct {
+	ID          string    `bson:"_id" json:"id"`                  // opencode会话ID，作为主键
+	ProjectID   string    `bson:"project_id" json:"project_id"`   // 项目ID（新增）
+	Title       string    `bson:"title" json:"title"`             // 标题
+	AgentName   string    `bson:"agent_name" json:"agent_name"`   // 智能体名称
+	Description string    `bson:"description" json:"description"` // 项目描述（新增）
+	Status      string    `bson:"status" json:"status"`           // 状态
+	UserID      string    `bson:"user_id" json:"user_id"`         // 用户ID
+	TenantID    string    `bson:"tenant_id" json:"tenant_id"`     // 租户ID
+	CreatedAt   time.Time `bson:"created_at" json:"created_at"`   // 创建时间
+	UpdatedAt   time.Time `bson:"updated_at" json:"updated_at"`   // 更新时间
+}
+
+// CodeItem 代码项
+type CodeItem struct {
+	Order         int                    `bson:"order" json:"order"`                     // 执行次序
+	Title         string                 `bson:"title" json:"title"`                     // 步骤标题（新增）
+	SelectPart    string                 `bson:"select_part" json:"select_part"`         // select 部分SQL代码
+	FromPart      string                 `bson:"from_part" json:"from_part"`             // from 部分代码
+	WherePart     string                 `bson:"where_part" json:"where_part"`           // where 部分
+	GroupByPart   string                 `bson:"group_by_part" json:"group_by_part"`     // group by 部分
+	OrderByPart   string                 `bson:"order_by_part" json:"order_by_part"`     // order by 部分
+	TempTableName string                 `bson:"temp_table_name" json:"temp_table_name"` // 临时表名称
+	Parameters    map[string]interface{} `bson:"parameters" json:"parameters"`           // 参数集合
+	ReturnColumns map[string]string      `bson:"return_columns" json:"return_columns"`   // 返回的列名称和对应的中文名称（映射）
+}
+
+// SessionDetail 明细文档
+type SessionDetail struct {
+	ID              primitive.ObjectID `bson:"_id,omitempty" json:"id,omitempty"`        // MongoDB自动生成的ID
+	SessionID       string             `bson:"session_id" json:"session_id"`             // 关联的会话ID
+	RequirementDoc  string             `bson:"requirement_doc" json:"requirement_doc"`   // 需求文档
+	TechnicalDoc    string             `bson:"technical_doc" json:"technical_doc"`       // 技术文档
+	CodeItems       []CodeItem         `bson:"code_items" json:"code_items"`             // 代码数组
+	HistorySessions []string           `bson:"history_sessions" json:"history_sessions"` // 历史会话ID数组（新增）
+	CreatedAt       time.Time          `bson:"created_at" json:"created_at"`             // 创建时间
+	UpdatedAt       time.Time          `bson:"updated_at" json:"updated_at"`             // 更新时间
+}
+
+// SessionWithDetail 包含主会话和明细的完整响应
+type SessionWithDetail struct {
+	Session      *Session       `json:"session"`
+	Detail       *SessionDetail `json:"detail,omitempty"`
+	HistoryCount int            `json:"history_count,omitempty"` // 历史消息数量
+}
+
+// SessionCollectionName 返回会话集合名称
+func (Session) CollectionName() string {
+	return "code_sessions"
+}
+
+// SessionDetailCollectionName 返回会话明细集合名称
+func (SessionDetail) CollectionName() string {
+	return "code_session_details"
+}

internal/model/session_test.go

@@ -0,0 +1,79 @@
+package model
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSessionStatusConstants(t *testing.T) {
+	assert.Equal(t, "requirement_document", StatusRequirementDocument)
+	assert.Equal(t, "technical_document", StatusTechnicalDocument)
+	assert.Equal(t, "code", StatusCode)
+	assert.Equal(t, "test", StatusTest)
+	assert.Equal(t, "release", StatusRelease)
+}
+
+func TestSessionCollectionName(t *testing.T) {
+	s := Session{}
+	assert.Equal(t, "code_sessions", s.CollectionName())
+}
+
+func TestSessionDetailCollectionName(t *testing.T) {
+	d := SessionDetail{}
+	assert.Equal(t, "code_session_details", d.CollectionName())
+}
+
+func TestSessionWithDetail(t *testing.T) {
+	session := &Session{
+		ID:        "test-session-123",
+		Title:     "测试会话",
+		AgentName: "replenish",
+		Status:    StatusRequirementDocument,
+		UserID:    "user-001",
+		TenantID:  "tenant-001",
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	detail := &SessionDetail{
+		SessionID:      "test-session-123",
+		RequirementDoc: "需求文档内容",
+		TechnicalDoc:   "技术文档内容",
+		CodeItems: []CodeItem{
+			{
+				Order:         1,
+				SelectPart:    "SELECT *",
+				FromPart:      "FROM users",
+				WherePart:     "WHERE active = true",
+				GroupByPart:   "GROUP BY type",
+				OrderByPart:   "ORDER BY created_at DESC",
+				TempTableName: "temp_users",
+				Parameters: map[string]interface{}{
+					"active": true,
+					"limit":  100,
+				},
+				ReturnColumns: map[string]string{
+					"id":       "用户ID",
+					"username": "用户名",
+					"email":    "邮箱",
+				},
+			},
+		},
+		CreatedAt: time.Now(),
+		UpdatedAt: time.Now(),
+	}
+
+	sessionWithDetail := &SessionWithDetail{
+		Session:      session,
+		Detail:       detail,
+		HistoryCount: 5,
+	}
+
+	assert.Equal(t, "test-session-123", sessionWithDetail.Session.ID)
+	assert.Equal(t, "test-session-123", sessionWithDetail.Detail.SessionID)
+	assert.Equal(t, 5, sessionWithDetail.HistoryCount)
+	assert.Equal(t, 1, len(sessionWithDetail.Detail.CodeItems))
+	assert.Equal(t, "SELECT *", sessionWithDetail.Detail.CodeItems[0].SelectPart)
+}

internal/routes/agent_routes.go

@@ -0,0 +1,21 @@
+package routes
+
+import (
+	"context"
+
+	"git.x2erp.com/qdy/go-base/authbase"
+	"git.x2erp.com/qdy/go-base/ctx"
+	"git.x2erp.com/qdy/go-base/model/response"
+	"git.x2erp.com/qdy/go-base/webx/router"
+	"git.x2erp.com/qdy/go-svc-code/internal/service"
+)
+
+// RegisterAgentRoutes 注册智能体路由
+func RegisterAgentRoutes(ws *router.RouterService) {
+	// 获取智能体列表（需要Token认证）
+	ws.GET("/api/agents",
+		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]service.AgentItem], error) {
+			return service.GetAgents(ctx, reqCtx), nil
+		},
+	).Use(authbase.TokenAuth).Desc("获取智能体列表").Register()
+}

internal/routes/menu_routes.go

@@ -1,57 +0,0 @@
-package routes
-
-import (
-	"context"
-
-	"git.x2erp.com/qdy/go-base/authbase"
-	"git.x2erp.com/qdy/go-base/ctx"
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-base/model/response"
-	"git.x2erp.com/qdy/go-base/util"
-	"git.x2erp.com/qdy/go-base/webx/router"
-	"git.x2erp.com/qdy/go-svc-code/internal/service/menu"
-)
-
-// RegisterMenuRoutes 注册菜单路由
-func RegisterMenuRoutes(ws *router.RouterService, mappingService *menu.MappingService) {
-	// 获取顶部菜单（需要Token认证）
-	ws.GET("/api/menu/top",
-		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]menu.MenuItem], error) {
-			return menu.GetTopMenu(ctx, reqCtx), nil
-		},
-	).Use(authbase.TokenAuth).Desc("获取顶部菜单").Register()
-
-	// 获取菜单项的所有会话ID（需要Token认证）
-	ws.GET("/api/menu/sessions/{menuItemID}",
-		func(menuItemID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]string], error) {
-			if menuItemID == "" {
-				return &response.QueryResult[[]string]{
-					Success: false,
-					Message: "参数 menu_item_id 不能为空",
-				}, nil
-			}
-
-			// 获取用户ID
-			userID := reqCtx.UserID
-			if userID == "" {
-				logger.Warn("无法从请求上下文获取用户ID")
-				return &response.QueryResult[[]string]{
-					Success: false,
-					Message: "用户认证信息不完整",
-				}, nil
-			}
-
-			// 获取菜单项的所有会话ID
-			sessionIDs, err := mappingService.GetSessionIDsByMenuItemID(ctx, menuItemID, userID)
-			if err != nil {
-				logger.Error("获取菜单项会话ID失败", "menu_item_id", menuItemID, "user_id", userID, "error", err)
-				return &response.QueryResult[[]string]{
-					Success: false,
-					Message: "获取菜单项会话ID失败: " + err.Error(),
-				}, nil
-			}
-
-			return util.CreateSuccessResultData(sessionIDs, reqCtx), nil
-		},
-	).Use(authbase.TokenAuth).Desc("获取菜单项的所有会话ID").Register()
-}

internal/routes/session_routes.go

@@ -2,145 +2,308 @@ package routes
 
 import (
 	"context"
+	"strings"
 
 	"git.x2erp.com/qdy/go-base/authbase"
 	"git.x2erp.com/qdy/go-base/ctx"
 	"git.x2erp.com/qdy/go-base/logger"
 	"git.x2erp.com/qdy/go-base/model/response"
+	"git.x2erp.com/qdy/go-base/util"
 	"git.x2erp.com/qdy/go-base/webx/router"
+	"git.x2erp.com/qdy/go-svc-code/internal/model"
 	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
-	"git.x2erp.com/qdy/go-svc-code/internal/service/menu"
+	"git.x2erp.com/qdy/go-svc-code/internal/service"
 )
 
 // SessionCreateRequest 创建会话请求
 type SessionCreateRequest struct {
-	Title      string `json:"title" binding:"required"`
-	MenuItemID string `json:"menu_item_id" binding:"required"` // 菜单项ID，必填
+	Title       string `json:"title" binding:"required"`
+	AgentName   string `json:"agent_name" binding:"required"` // 智能体名称
+	ProjectID   string `json:"project_id,omitempty"`          // 项目ID（新增，前端生成proj_前缀UUID）
+	Description string `json:"description,omitempty"`         // 项目描述（新增）
 }
 
-// SessionResponse 会话响应
-type SessionResponse struct {
-	ID      string `json:"id"`
-	Title   string `json:"title"`
-	Port    int    `json:"port"`
-	BaseURL string `json:"baseURL"`
+// SessionUpdateRequest 更新会话请求
+type SessionUpdateRequest struct {
+	Title  string `json:"title,omitempty"`
+	Status string `json:"status,omitempty"`
+}
+
+// SessionListQuery 会话列表查询参数
+type SessionListQuery struct {
+	Page     int    `form:"page" binding:"min=1"`             // 页码，从1开始
+	PageSize int    `form:"pageSize" binding:"min=1,max=100"` // 每页大小，最大100
+	Title    string `form:"title,omitempty"`                  // 标题搜索（模糊匹配）
+	Status   string `form:"status,omitempty"`                 // 状态筛选
 }
 
 // RegisterSessionRoutes 注册会话管理路由
-func RegisterSessionRoutes(ws *router.RouterService, client opencode.OpenCodeClient, mappingService *menu.MappingService) {
+func RegisterSessionRoutes(ws *router.RouterService, client opencode.OpenCodeClient, sessionStore *service.SessionStore, detailStore *service.SessionDetailStore) {
 	// 创建会话（需要Token认证）
 	ws.POST("/api/session/create",
-		func(req *SessionCreateRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[SessionResponse], error) {
+		func(req *SessionCreateRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[*model.Session], error) {
+			// 从认证信息中获取用户ID和租户ID
+			userID := reqCtx.UserID
+			tenantID := reqCtx.TenantID
+			if userID == "" {
+				userID = "unknown_user"
+				logger.Warn("无法从请求上下文获取用户ID，使用默认值")
+			}
+			if tenantID == "" {
+				tenantID = "default"
+			}
+
+			// 1. 验证智能体名称是否有效
+			if !model.IsValidAgent(req.AgentName) {
+				// 构建支持智能体列表的错误信息
+				supportedAgents := ""
+				for id, name := range model.AgentDisplayName {
+					supportedAgents += id + "（" + name + "）、"
+				}
+				// 移除最后一个"、"
+				if len(supportedAgents) > 0 {
+					supportedAgents = supportedAgents[:len(supportedAgents)-len("、")]
+				}
+				return &response.QueryResult[*model.Session]{
+					Success: false,
+					Message: "无效的智能体名称，支持的智能体有：" + supportedAgents,
+				}, nil
+			}
+
+			// 2. 首先使用opencodeapi创建一个会话ID
 			session, err := client.CreateSession(ctx, req.Title)
 			if err != nil {
-				return &response.QueryResult[SessionResponse]{
+				logger.Error("创建opencode会话失败", "title", req.Title, "error", err)
+				return &response.QueryResult[*model.Session]{
 					Success: false,
-					Message: err.Error(),
+					Message: "创建会话失败: " + err.Error(),
 				}, nil
 			}
 
+			// 2. 保存到MongoDB
+			projectID := req.ProjectID
+			if projectID == "" {
+				// 向后兼容：如果没有提供项目ID，使用会话ID作为项目ID
+				projectID = session.ID
+			}
+			dbSession := &model.Session{
+				ID:          session.ID,
+				ProjectID:   projectID,
+				Title:       req.Title,
+				AgentName:   req.AgentName,
+				Description: req.Description,
+				Status:      model.StatusRequirementDocument, // 默认状态为需求文档
+				UserID:      userID,
+				TenantID:    tenantID,
+			}
+
+			if err := sessionStore.Create(ctx, dbSession); err != nil {
+				logger.Error("保存会话到数据库失败", "session_id", session.ID, "error", err)
+				// 注意：opencode会话已创建，但数据库保存失败
+				// 可以考虑回滚（删除opencode会话），但先记录错误
+				return &response.QueryResult[*model.Session]{
+					Success: false,
+					Message: "保存会话信息失败: " + err.Error(),
+				}, nil
+			}
+
+			// 3. 创建空的明细文档
+			detail := &model.SessionDetail{
+				SessionID:       session.ID,
+				RequirementDoc:  "",
+				TechnicalDoc:    "",
+				CodeItems:       []model.CodeItem{},
+				HistorySessions: []string{session.ID}, // 初始化历史会话数组
+			}
+
+			if err := detailStore.Create(ctx, detail); err != nil {
+				logger.Warn("创建会话明细失败", "session_id", session.ID, "error", err)
+				// 明细创建失败不影响主流程，但记录警告
+			}
+
+			logger.Debug("创建会话成功", "session_id", session.ID, "title", req.Title, "agent", req.AgentName)
+			return util.CreateSuccessResultData(dbSession, reqCtx), nil
+		},
+	).Use(authbase.TokenAuth).Desc("创建新的会话").Register()
+
+	// 分页查询会话列表（需要Token认证）
+	ws.GET("/api/sessions",
+		func(query *SessionListQuery, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[*service.ListResult], error) {
+			// 处理nil查询参数
+			if query == nil {
+				logger.Warn("查询参数为nil，使用默认值")
+				query = &SessionListQuery{
+					Page:     1,
+					PageSize: 20,
+				}
+			}
+			// 设置默认值
+			if query.Page == 0 {
+				query.Page = 1
+			}
+			if query.PageSize == 0 {
+				query.PageSize = 20
+			}
+
 			// 从认证信息中获取用户ID和租户ID
-			// TokenAuth中间件已经在reqCtx中设置了UserID和TenantID
 			userID := reqCtx.UserID
 			tenantID := reqCtx.TenantID
-
-			// 如果无法获取，使用占位符（实际生产环境应该确保认证信息正确设置）
 			if userID == "" {
-				userID = "unknown_user"
-				logger.Warn("无法从请求上下文获取用户ID，使用默认值", "session_id", session.ID)
+				return &response.QueryResult[*service.ListResult]{
+					Success: false,
+					Message: "用户认证信息不完整",
+				}, nil
 			}
 			if tenantID == "" {
 				tenantID = "default"
 			}
-			if tenantID == "" {
-				tenantID = "default"
+
+			// 构建查询参数
+			listQuery := &service.ListQuery{
+				Page:     query.Page,
+				PageSize: query.PageSize,
+				Title:    strings.TrimSpace(query.Title),
+				Status:   strings.TrimSpace(query.Status),
+				UserID:   userID,
+				TenantID: tenantID,
 			}
 
-			// 保存会话-菜单映射
-			if err := mappingService.CreateMapping(ctx, session.ID, req.MenuItemID, userID, tenantID); err != nil {
-				logger.Warn("创建会话-菜单映射失败", "session_id", session.ID, "menu_item_id", req.MenuItemID, "error", err)
-				// 注意：映射创建失败不影响会话创建，但会记录警告
+			// 查询会话列表
+			result, err := sessionStore.List(ctx, listQuery)
+			if err != nil {
+				logger.Error("查询会话列表失败", "error", err)
+				return &response.QueryResult[*service.ListResult]{
+					Success: false,
+					Message: "查询会话列表失败: " + err.Error(),
+				}, nil
 			}
 
-			return &response.QueryResult[SessionResponse]{
-				Success: true,
-				Data: SessionResponse{
-					ID:      session.ID,
-					Title:   session.Title,
-					Port:    client.GetPort(),
-					BaseURL: client.GetBaseURL(),
-				},
-			}, nil
+			return util.CreateSuccessResultData(result, reqCtx), nil
 		},
-	).Use(authbase.TokenAuth).Desc("创建新的 opencode 会话").Register()
+	).Use(authbase.TokenAuth).Desc("分页查询会话列表，支持按标题搜索和按状态筛选").Register()
+
+	// 获取单个会话详情（需要Token认证）
+	ws.GET("/api/session/{id}",
+		func(id string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[*model.SessionWithDetail], error) {
+			if id == "" {
+				return &response.QueryResult[*model.SessionWithDetail]{
+					Success: false,
+					Message: "参数 id 不能为空",
+				}, nil
+			}
+
+			// 1. 获取主会话
+			session, err := sessionStore.GetByID(ctx, id)
+			if err != nil {
+				logger.Error("获取会话失败", "session_id", id, "error", err)
+				return &response.QueryResult[*model.SessionWithDetail]{
+					Success: false,
+					Message: "获取会话失败: " + err.Error(),
+				}, nil
+			}
+			if session == nil {
+				return &response.QueryResult[*model.SessionWithDetail]{
+					Success: false,
+					Message: "会话不存在",
+				}, nil
+			}
 
-	// 获取会话列表（需要Token认证）
-	ws.GET("/api/session/list",
-		func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[[]opencode.Session], error) {
-			sessions, err := client.ListSessions(ctx)
+			// 2. 获取明细文档
+			detail, err := detailStore.GetBySessionID(ctx, id)
 			if err != nil {
-				return &response.QueryResult[[]opencode.Session]{
+				logger.Error("获取会话明细失败", "session_id", id, "error", err)
+				return &response.QueryResult[*model.SessionWithDetail]{
 					Success: false,
-					Message: err.Error(),
+					Message: "获取会话明细失败: " + err.Error(),
 				}, nil
 			}
 
-			return &response.QueryResult[[]opencode.Session]{
-				Success: true,
-				Data:    sessions,
-			}, nil
+			// 3. 获取历史会话上下文（从opencode获取）
+			var historyCount int
+			messages, err := client.GetSessionMessages(ctx, id, 50) // 获取最近50条消息
+			if err != nil {
+				logger.Warn("获取会话历史消息失败", "session_id", id, "error", err)
+				// 历史消息获取失败不影响主流程，继续返回其他数据
+			} else {
+				historyCount = len(messages)
+			}
+
+			// 4. 组合响应
+			result := &model.SessionWithDetail{
+				Session:      session,
+				Detail:       detail,
+				HistoryCount: historyCount,
+			}
+
+			return util.CreateSuccessResultData(result, reqCtx), nil
 		},
-	).Use(authbase.TokenAuth).Desc("获取 opencode 会话列表").Register()
+	).Use(authbase.TokenAuth).Desc("获取会话详情（包括主对象、明细文档和历史消息数量）").Register()
 
-	// 获取会话的菜单项ID（需要Token认证）
-	ws.GET("/api/session/menu",
-		func(sessionID string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[string], error) {
-			if sessionID == "" {
-				return &response.QueryResult[string]{
+	// 更新会话（状态和标题）（需要Token认证）
+	ws.PUT("/api/session/{id}",
+		func(id string, req *SessionUpdateRequest, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[bool], error) {
+			if id == "" {
+				return &response.QueryResult[bool]{
 					Success: false,
-					Message: "参数 session_id 不能为空",
+					Message: "参数 id 不能为空",
 				}, nil
 			}
 
-			// 获取会话的菜单项ID
-			menuItemID, err := mappingService.GetMenuItemBySessionID(ctx, sessionID)
-			if err != nil {
-				logger.Error("获取会话菜单项失败", "session_id", sessionID, "error", err)
-				return &response.QueryResult[string]{
+			// 验证请求数据
+			if req.Title == "" && req.Status == "" {
+				return &response.QueryResult[bool]{
+					Success: false,
+					Message: "至少需要提供标题或状态中的一个",
+				}, nil
+			}
+
+			// 更新会话
+			if err := sessionStore.Update(ctx, id, req.Title, req.Status); err != nil {
+				logger.Error("更新会话失败", "session_id", id, "error", err)
+				return &response.QueryResult[bool]{
 					Success: false,
-					Message: "获取会话菜单项失败: " + err.Error(),
+					Message: "更新会话失败: " + err.Error(),
 				}, nil
 			}
 
-			return &response.QueryResult[string]{
-				Success: true,
-				Data:    menuItemID,
-			}, nil
+			return util.CreateSuccessResultData(true, reqCtx), nil
+		},
+	).Use(authbase.TokenAuth).Desc("更新会话状态和标题（已发布的会话不能修改）").Register()
+
+	// 删除会话（需要Token认证）
+	ws.DELETE("/api/session/{id}",
+		func(id string, ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[bool], error) {
+			if id == "" {
+				return &response.QueryResult[bool]{
+					Success: false,
+					Message: "参数 id 不能为空",
+				}, nil
+			}
+
+			// 1. 从MongoDB删除主会话
+			if err := sessionStore.Delete(ctx, id); err != nil {
+				logger.Error("删除会话失败", "session_id", id, "error", err)
+				return &response.QueryResult[bool]{
+					Success: false,
+					Message: "删除会话失败: " + err.Error(),
+				}, nil
+			}
+
+			// 2. 删除明细文档
+			if err := detailStore.DeleteBySessionID(ctx, id); err != nil {
+				logger.Warn("删除会话明细失败", "session_id", id, "error", err)
+				// 明细删除失败不影响主流程，但记录警告
+			}
+
+			// 3. 调用opencode-api删除会话
+			// 注意：opencode API可能不支持直接删除会话，这里暂时记录日志
+			logger.Debug("需要调用opencode-api删除会话", "session_id", id)
+			// TODO: 实现opencode会话删除
+			// if err := client.DeleteSession(ctx, id); err != nil {
+			// 	logger.Warn("删除opencode会话失败", "session_id", id, "error", err)
+			// }
+
+			return util.CreateSuccessResultData(true, reqCtx), nil
 		},
-	).Use(authbase.TokenAuth).Desc("获取会话的菜单项ID").Register()
-
-	// 获取单个会话（暂不实现，因为 opencode API 可能不支持）
-	// ws.GET("/api/session/get",
-	// 	func(ctx context.Context, reqCtx *ctx.RequestContext) (*response.QueryResult[opencode.Session], error) {
-	// 		sessionID := reqCtx.GetQuery("id")
-	// 		if sessionID == "" {
-	// 			return &response.QueryResult[opencode.Session]{
-	// 				Success: false,
-	// 				Message: "参数 id 不能为空",
-	// 			}, nil
-	// 		}
-	// 		session, err := client.GetSession(ctx, sessionID)
-	// 		if err != nil {
-	// 			return &response.QueryResult[opencode.Session]{
-	// 				Success: false,
-	// 				Message: err.Error(),
-	// 			}, nil
-	// 		}
-	//
-	// 		return &response.QueryResult[opencode.Session]{
-	// 			Success: true,
-	// 			Data:    *session,
-	// 		}, nil
-	// 	},
-	// ).Desc("获取 opencode 会话详情").Register()
+	).Use(authbase.TokenAuth).Desc("删除会话（同时删除明细文档，已发布的会话不能删除）").Register()
 }

internal/service/agent_service.go

@@ -0,0 +1,45 @@
+package service
+
+import (
+	"context"
+
+	"git.x2erp.com/qdy/go-base/ctx"
+	"git.x2erp.com/qdy/go-base/logger"
+	"git.x2erp.com/qdy/go-base/model/response"
+	"git.x2erp.com/qdy/go-base/util"
+	"git.x2erp.com/qdy/go-svc-code/internal/model"
+)
+
+// AgentItem 智能体项结构
+type AgentItem struct {
+	ID   string `json:"id"`   // 智能体ID
+	Name string `json:"name"` // 智能体名称（标题）
+}
+
+// GetAgents 获取智能体列表
+func GetAgents(ctx context.Context, reqCtx *ctx.RequestContext) *response.QueryResult[[]AgentItem] {
+	logger.Debug("GetAgents-开始获取智能体列表")
+
+	// 按固定顺序构建智能体列表
+	agents := []AgentItem{
+		{
+			ID:   model.AgentReplenish,
+			Name: model.AgentDisplayName[model.AgentReplenish],
+		},
+		{
+			ID:   model.AgentTransfer,
+			Name: model.AgentDisplayName[model.AgentTransfer],
+		},
+		{
+			ID:   model.AgentAllocation,
+			Name: model.AgentDisplayName[model.AgentAllocation],
+		},
+		{
+			ID:   model.AgentReport,
+			Name: model.AgentDisplayName[model.AgentReport],
+		},
+	}
+
+	logger.Debug("返回智能体列表结构")
+	return util.CreateSuccessResultData(agents, reqCtx)
+}

internal/service/menu/get_menu.go

@@ -1,59 +0,0 @@
-package menu
-
-import (
-	"context"
-
-	"git.x2erp.com/qdy/go-base/ctx"
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-base/model/response"
-	"git.x2erp.com/qdy/go-base/util"
-)
-
-// MenuItem 顶部菜单项结构
-type MenuItem struct {
-	ID    string `json:"id"`
-	Name  string `json:"name"`
-	Icon  string `json:"icon,omitempty"`
-	Type  string `json:"type"` // top-menu
-	Route string `json:"route,omitempty"`
-}
-
-// GetTopMenu 获取顶部菜单
-func GetTopMenu(ctx context.Context, reqCtx *ctx.RequestContext) *response.QueryResult[[]MenuItem] {
-	logger.Debug("GetTopMenu-开始获取顶部菜单")
-
-	// 构建顶部菜单项
-	menu := []MenuItem{
-		{
-			ID:    "replenish",
-			Name:  "补货",
-			Icon:  "inventory_2", // 库存补充图标
-			Type:  "top-menu",
-			Route: "/replenish",
-		},
-		{
-			ID:    "transfer",
-			Name:  "调拨",
-			Icon:  "swap_horiz", // 横向交换图标
-			Type:  "top-menu",
-			Route: "/transfer",
-		},
-		{
-			ID:    "allocation",
-			Name:  "配货",
-			Icon:  "local_shipping", // 本地货运图标
-			Type:  "top-menu",
-			Route: "/allocation",
-		},
-		{
-			ID:    "report",
-			Name:  "报表",
-			Icon:  "assessment", // 评估报表图标
-			Type:  "top-menu",
-			Route: "/report",
-		},
-	}
-
-	logger.Debug("返回顶部菜单结构")
-	return util.CreateSuccessResultData(menu, reqCtx)
-}

internal/service/menu/mapping.go

@@ -1,150 +0,0 @@
-package menu
-
-import (
-	"context"
-	"errors"
-	"time"
-
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-db/factory/mongodb"
-	"go.mongodb.org/mongo-driver/bson"
-	"go.mongodb.org/mongo-driver/bson/primitive"
-)
-
-// SessionMenuMapping 会话-菜单映射结构
-type SessionMenuMapping struct {
-	ID         primitive.ObjectID `bson:"_id,omitempty" json:"id,omitempty"`
-	SessionID  string             `bson:"session_id" json:"session_id"`     // 会话ID
-	MenuItemID string             `bson:"menu_item_id" json:"menu_item_id"` // 菜单项ID
-	UserID     string             `bson:"user_id" json:"user_id"`           // 用户ID
-	TenantID   string             `bson:"tenant_id" json:"tenant_id"`       // 租户ID
-	CreatedAt  time.Time          `bson:"created_at" json:"created_at"`     // 创建时间
-}
-
-// CollectionName 返回MongoDB集合名称
-func (SessionMenuMapping) CollectionName() string {
-	return "session_menu_mappings"
-}
-
-// MappingService 会话-菜单映射服务
-type MappingService struct {
-	mongoFactory *mongodb.MongoDBFactory
-}
-
-// NewMappingService 创建新的映射服务
-func NewMappingService(factory *mongodb.MongoDBFactory) *MappingService {
-	return &MappingService{mongoFactory: factory}
-}
-
-// CreateMapping 创建会话-菜单映射
-func (s *MappingService) CreateMapping(ctx context.Context, sessionID, menuItemID, userID, tenantID string) error {
-	mapping := SessionMenuMapping{
-		SessionID:  sessionID,
-		MenuItemID: menuItemID,
-		UserID:     userID,
-		TenantID:   tenantID,
-		CreatedAt:  time.Now(),
-	}
-
-	_, success := s.mongoFactory.InsertOneWithResult(SessionMenuMapping{}.CollectionName(), mapping)
-	if !success {
-		logger.Error("创建会话-菜单映射失败", "session_id", sessionID, "menu_item_id", menuItemID)
-		return errors.New("failed to create session-menu mapping")
-	}
-
-	logger.Debug("创建会话-菜单映射成功", "session_id", sessionID, "menu_item_id", menuItemID)
-	return nil
-}
-
-// GetMenuItemBySessionID 根据会话ID获取菜单项ID
-func (s *MappingService) GetMenuItemBySessionID(ctx context.Context, sessionID string) (string, error) {
-	filter := bson.M{"session_id": sessionID}
-	var mapping SessionMenuMapping
-
-	err := s.mongoFactory.FindOne(SessionMenuMapping{}.CollectionName(), filter, &mapping)
-	if err != nil {
-		if err.Error() == "mongo: no documents in result" {
-			return "", nil // 未找到映射，返回空字符串
-		}
-		logger.Error("根据会话ID查询菜单项失败", "session_id", sessionID, "error", err)
-		return "", err
-	}
-
-	return mapping.MenuItemID, nil
-}
-
-// GetSessionIDsByMenuItemID 根据菜单项ID获取会话ID列表
-func (s *MappingService) GetSessionIDsByMenuItemID(ctx context.Context, menuItemID, userID string) ([]string, error) {
-	filter := bson.M{"menu_item_id": menuItemID, "user_id": userID}
-	var mappings []SessionMenuMapping
-
-	err := s.mongoFactory.Find(SessionMenuMapping{}.CollectionName(), filter, &mappings)
-	if err != nil {
-		logger.Error("根据菜单项ID查询会话ID失败", "menu_item_id", menuItemID, "error", err)
-		return nil, err
-	}
-
-	sessionIDs := make([]string, 0, len(mappings))
-	for _, mapping := range mappings {
-		sessionIDs = append(sessionIDs, mapping.SessionID)
-	}
-
-	return sessionIDs, nil
-}
-
-// GetMappingsByUser 获取用户的所有会话-菜单映射
-func (s *MappingService) GetMappingsByUser(ctx context.Context, userID string) (map[string]string, error) {
-	filter := bson.M{"user_id": userID}
-	var mappings []SessionMenuMapping
-
-	err := s.mongoFactory.Find(SessionMenuMapping{}.CollectionName(), filter, &mappings)
-	if err != nil {
-		logger.Error("查询用户会话-菜单映射失败", "user_id", userID, "error", err)
-		return nil, err
-	}
-
-	result := make(map[string]string)
-	for _, mapping := range mappings {
-		result[mapping.SessionID] = mapping.MenuItemID
-	}
-
-	return result, nil
-}
-
-// DeleteMappingBySessionID 根据会话ID删除映射
-func (s *MappingService) DeleteMappingBySessionID(ctx context.Context, sessionID string) error {
-	filter := bson.M{"session_id": sessionID}
-	success, deletedCount := s.mongoFactory.DeleteOne(SessionMenuMapping{}.CollectionName(), filter)
-	if !success {
-		logger.Error("根据会话ID删除映射失败", "session_id", sessionID)
-		return errors.New("failed to delete session-menu mapping")
-	}
-
-	logger.Debug("删除会话-菜单映射成功", "session_id", sessionID, "deleted_count", deletedCount)
-	return nil
-}
-
-// EnsureIndexes 确保集合索引
-func (s *MappingService) EnsureIndexes(ctx context.Context) error {
-	// 创建会话ID唯一索引
-	sessionIDIndexKeys := bson.D{{Key: "session_id", Value: 1}}
-	sessionIDSuccess := s.mongoFactory.CreateIndex(SessionMenuMapping{}.CollectionName(), sessionIDIndexKeys)
-	if !sessionIDSuccess {
-		logger.Error("创建会话ID索引失败")
-		return errors.New("failed to create session_id index")
-	}
-
-	// 创建复合索引：菜单项ID + 用户ID
-	menuItemUserIndexKeys := bson.D{
-		{Key: "menu_item_id", Value: 1},
-		{Key: "user_id", Value: 1},
-	}
-	menuItemUserSuccess := s.mongoFactory.CreateIndex(SessionMenuMapping{}.CollectionName(), menuItemUserIndexKeys)
-	if !menuItemUserSuccess {
-		logger.Error("创建菜单项用户复合索引失败")
-		return errors.New("failed to create menu_item_id-user_id index")
-	}
-
-	logger.Debug("会话-菜单映射索引创建成功")
-	return nil
-}

internal/service/mock_mongodb.go

@@ -0,0 +1,83 @@
+//go:build test
+
+package service
+
+import (
+	"git.x2erp.com/qdy/go-db/factory/mongodb"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+// MockMongoDBFactory 模拟MongoDB工厂
+type MockMongoDBFactory struct {
+	InsertOneFunc           func(collectionName string, document interface{}) (interface{}, bool)
+	InsertOneWithResultFunc func(collectionName string, document interface{}) (interface{}, bool)
+	FindOneFunc             func(collectionName string, filter interface{}, result interface{}) error
+	FindFunc                func(collectionName string, filter interface{}, result interface{}) error
+	UpdateOneFunc           func(collectionName string, filter interface{}, update interface{}) (bool, int64)
+	DeleteOneFunc           func(collectionName string, filter interface{}) (bool, int64)
+	CreateIndexFunc         func(collectionName string, keys interface{}) bool
+}
+
+// InsertOne 模拟插入
+func (m *MockMongoDBFactory) InsertOne(collectionName string, document interface{}) (interface{}, bool) {
+	if m.InsertOneFunc != nil {
+		return m.InsertOneFunc(collectionName, document)
+	}
+	return nil, true
+}
+
+// InsertOneWithResult 模拟插入并返回结果
+func (m *MockMongoDBFactory) InsertOneWithResult(collectionName string, document interface{}) (interface{}, bool) {
+	if m.InsertOneWithResultFunc != nil {
+		return m.InsertOneWithResultFunc(collectionName, document)
+	}
+	return nil, true
+}
+
+// FindOne 模拟查询单个
+func (m *MockMongoDBFactory) FindOne(collectionName string, filter interface{}, result interface{}) error {
+	if m.FindOneFunc != nil {
+		return m.FindOneFunc(collectionName, filter, result)
+	}
+	return nil
+}
+
+// Find 模拟查询多个
+func (m *MockMongoDBFactory) Find(collectionName string, filter interface{}, result interface{}) error {
+	if m.FindFunc != nil {
+		return m.FindFunc(collectionName, filter, result)
+	}
+	return nil
+}
+
+// UpdateOne 模拟更新
+func (m *MockMongoDBFactory) UpdateOne(collectionName string, filter interface{}, update interface{}) (bool, int64) {
+	if m.UpdateOneFunc != nil {
+		return m.UpdateOneFunc(collectionName, filter, update)
+	}
+	return true, 1
+}
+
+// DeleteOne 模拟删除
+func (m *MockMongoDBFactory) DeleteOne(collectionName string, filter interface{}) (bool, int64) {
+	if m.DeleteOneFunc != nil {
+		return m.DeleteOneFunc(collectionName, filter)
+	}
+	return true, 1
+}
+
+// CreateIndex 模拟创建索引
+func (m *MockMongoDBFactory) CreateIndex(collectionName string, keys interface{}) bool {
+	if m.CreateIndexFunc != nil {
+		return m.CreateIndexFunc(collectionName, keys)
+	}
+	return true
+}
+
+// TestConnection 模拟测试连接
+func (m *MockMongoDBFactory) TestConnection() bool {
+	return true
+}
+
+// 确保MockMongoDBFactory实现MongoDBFactory接口
+var _ mongodb.MongoDBFactory = (*MockMongoDBFactory)(nil)

internal/service/session_detail_store.go

@@ -0,0 +1,173 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/logger"
+	"git.x2erp.com/qdy/go-db/factory/mongodb"
+	"git.x2erp.com/qdy/go-svc-code/internal/model"
+	"go.mongodb.org/mongo-driver/bson"
+)
+
+// SessionDetailStore 会话明细存储服务
+type SessionDetailStore struct {
+	mongoFactory *mongodb.MongoDBFactory
+}
+
+// NewSessionDetailStore 创建新的会话明细存储服务
+func NewSessionDetailStore(factory *mongodb.MongoDBFactory) *SessionDetailStore {
+	return &SessionDetailStore{mongoFactory: factory}
+}
+
+// Create 创建会话明细
+func (s *SessionDetailStore) Create(ctx context.Context, detail *model.SessionDetail) error {
+	if detail.SessionID == "" {
+		return errors.New("session ID cannot be empty")
+	}
+
+	// 设置时间戳
+	now := time.Now()
+	if detail.CreatedAt.IsZero() {
+		detail.CreatedAt = now
+	}
+	if detail.UpdatedAt.IsZero() {
+		detail.UpdatedAt = now
+	}
+
+	// 插入到MongoDB
+	_, success := s.mongoFactory.InsertOneWithResult(detail.CollectionName(), detail)
+	if !success {
+		logger.Error("创建会话明细失败", "session_id", detail.SessionID)
+		return errors.New("failed to create session detail")
+	}
+
+	logger.Debug("创建会话明细成功", "session_id", detail.SessionID)
+	return nil
+}
+
+// GetBySessionID 根据会话ID获取明细
+func (s *SessionDetailStore) GetBySessionID(ctx context.Context, sessionID string) (*model.SessionDetail, error) {
+	if sessionID == "" {
+		return nil, errors.New("session ID cannot be empty")
+	}
+
+	filter := bson.M{"session_id": sessionID}
+	var detail model.SessionDetail
+
+	err := s.mongoFactory.FindOne(detail.CollectionName(), filter, &detail)
+	if err != nil {
+		if err.Error() == "mongo: no documents in result" {
+			return nil, nil // 未找到明细
+		}
+		logger.Error("根据会话ID查询明细失败", "session_id", sessionID, "error", err)
+		return nil, err
+	}
+
+	return &detail, nil
+}
+
+// Update 更新会话明细
+func (s *SessionDetailStore) Update(ctx context.Context, sessionID string, updateFields map[string]interface{}) error {
+	if sessionID == "" {
+		return errors.New("session ID cannot be empty")
+	}
+
+	// 检查明细是否存在
+	detail, err := s.GetBySessionID(ctx, sessionID)
+	if err != nil {
+		return err
+	}
+	if detail == nil {
+		return errors.New("session detail not found")
+	}
+
+	// 添加更新时间
+	updateFields["updated_at"] = time.Now()
+
+	filter := bson.M{"session_id": sessionID}
+	success, _ := s.mongoFactory.UpdateOne(detail.CollectionName(), filter, updateFields)
+	if !success {
+		logger.Error("更新会话明细失败", "session_id", sessionID)
+		return errors.New("failed to update session detail")
+	}
+
+	logger.Debug("更新会话明细成功", "session_id", sessionID)
+	return nil
+}
+
+// UpdateOrCreate 更新或创建会话明细
+func (s *SessionDetailStore) UpdateOrCreate(ctx context.Context, detail *model.SessionDetail) error {
+	if detail.SessionID == "" {
+		return errors.New("session ID cannot be empty")
+	}
+
+	// 检查是否已存在
+	existing, err := s.GetBySessionID(ctx, detail.SessionID)
+	if err != nil {
+		return err
+	}
+
+	if existing == nil {
+		// 不存在，创建新的
+		return s.Create(ctx, detail)
+	}
+
+	// 已存在，更新
+	updateFields := bson.M{
+		"requirement_doc": detail.RequirementDoc,
+		"technical_doc":   detail.TechnicalDoc,
+		"code_items":      detail.CodeItems,
+		"updated_at":      time.Now(),
+	}
+
+	filter := bson.M{"session_id": detail.SessionID}
+	success, _ := s.mongoFactory.UpdateOne(detail.CollectionName(), filter, updateFields)
+	if !success {
+		logger.Error("更新会话明细失败", "session_id", detail.SessionID)
+		return errors.New("failed to update session detail")
+	}
+
+	logger.Debug("更新会话明细成功", "session_id", detail.SessionID)
+	return nil
+}
+
+// DeleteBySessionID 根据会话ID删除明细
+func (s *SessionDetailStore) DeleteBySessionID(ctx context.Context, sessionID string) error {
+	if sessionID == "" {
+		return errors.New("session ID cannot be empty")
+	}
+
+	filter := bson.M{"session_id": sessionID}
+	success, deletedCount := s.mongoFactory.DeleteOne(model.SessionDetail{}.CollectionName(), filter)
+	if !success {
+		logger.Error("删除会话明细失败", "session_id", sessionID)
+		return errors.New("failed to delete session detail")
+	}
+
+	logger.Debug("删除会话明细成功", "session_id", sessionID, "deleted_count", deletedCount)
+	return nil
+}
+
+// EnsureIndexes 确保集合索引
+func (s *SessionDetailStore) EnsureIndexes(ctx context.Context) error {
+	// 会话ID索引（常用查询条件）
+	sessionIDIndexKeys := bson.D{{Key: "session_id", Value: 1}}
+	sessionIDSuccess := s.mongoFactory.CreateIndex(model.SessionDetail{}.CollectionName(), sessionIDIndexKeys)
+	if !sessionIDSuccess {
+		logger.Error("创建会话ID索引失败")
+		return errors.New("failed to create session_id index")
+	}
+
+	// 创建时间索引
+	createdAtIndexKeys := bson.D{{Key: "created_at", Value: -1}}
+	createdAtSuccess := s.mongoFactory.CreateIndex(model.SessionDetail{}.CollectionName(), createdAtIndexKeys)
+	if !createdAtSuccess {
+		logger.Error("创建创建时间索引失败")
+		return errors.New("failed to create created_at index")
+	}
+
+	logger.Debug("会话明细集合索引创建成功")
+	return nil
+}

internal/service/session_service.go

@@ -1,133 +0,0 @@
-package service
-
-import (
-	"context"
-	"sync"
-
-	"git.x2erp.com/qdy/go-base/logger"
-	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
-)
-
-// SessionInfo 会话信息
-type SessionInfo struct {
-	SessionID string
-	Title     string
-	UserID    string
-	CreatedAt string
-}
-
-// SessionManager 会话管理器
-type SessionManager struct {
-	mu           sync.RWMutex
-	userSessions map[string][]SessionInfo // userID -> sessions
-	client       opencode.OpenCodeClient
-}
-
-// NewSessionManager 创建新的会话管理器
-func NewSessionManager(client opencode.OpenCodeClient) *SessionManager {
-	return &SessionManager{
-		userSessions: make(map[string][]SessionInfo),
-		client:       client,
-	}
-}
-
-// CreateSession 为用户创建新会话
-func (sm *SessionManager) CreateSession(ctx context.Context, userID, title string) (*SessionInfo, error) {
-	// 调用 opencode 创建会话
-	session, err := sm.client.CreateSession(ctx, title)
-	if err != nil {
-		return nil, err
-	}
-
-	sessionInfo := &SessionInfo{
-		SessionID: session.ID,
-		Title:     session.Title,
-		UserID:    userID,
-		CreatedAt: session.CreatedAt,
-	}
-
-	sm.mu.Lock()
-	sm.userSessions[userID] = append(sm.userSessions[userID], *sessionInfo)
-	sm.mu.Unlock()
-
-	logger.Debug("创建会话", "userID", userID, "sessionID", session.ID)
-	return sessionInfo, nil
-}
-
-// GetUserSessions 获取用户的所有会话
-func (sm *SessionManager) GetUserSessions(userID string) []SessionInfo {
-	sm.mu.RLock()
-	defer sm.mu.RUnlock()
-
-	sessions, exists := sm.userSessions[userID]
-	if !exists {
-		return []SessionInfo{}
-	}
-
-	// 返回副本
-	result := make([]SessionInfo, len(sessions))
-	copy(result, sessions)
-	return result
-}
-
-// GetSession 获取特定会话（检查用户权限）
-func (sm *SessionManager) GetSession(userID, sessionID string) (*SessionInfo, bool) {
-	sm.mu.RLock()
-	defer sm.mu.RUnlock()
-
-	sessions, exists := sm.userSessions[userID]
-	if !exists {
-		return nil, false
-	}
-
-	for _, session := range sessions {
-		if session.SessionID == sessionID {
-			return &session, true
-		}
-	}
-
-	return nil, false
-}
-
-// DeleteSession 删除用户会话
-func (sm *SessionManager) DeleteSession(userID, sessionID string) bool {
-	sm.mu.Lock()
-	defer sm.mu.Unlock()
-
-	sessions, exists := sm.userSessions[userID]
-	if !exists {
-		return false
-	}
-
-	for i, session := range sessions {
-		if session.SessionID == sessionID {
-			// 从切片中删除
-			sm.userSessions[userID] = append(sessions[:i], sessions[i+1:]...)
-
-			// 如果用户没有会话了，删除用户条目
-			if len(sm.userSessions[userID]) == 0 {
-				delete(sm.userSessions, userID)
-			}
-
-			logger.Debug("删除会话", "userID", userID, "sessionID", sessionID)
-			return true
-		}
-	}
-
-	return false
-}
-
-// GetAllSessions 获取所有会话（仅用于调试）
-func (sm *SessionManager) GetAllSessions() map[string][]SessionInfo {
-	sm.mu.RLock()
-	defer sm.mu.RUnlock()
-
-	// 返回深拷贝
-	result := make(map[string][]SessionInfo)
-	for userID, sessions := range sm.userSessions {
-		userSessions := make([]SessionInfo, len(sessions))
-		copy(userSessions, sessions)
-		result[userID] = userSessions
-	}
-	return result
-}

internal/service/session_store.go

@@ -0,0 +1,318 @@
+package service
+
+import (
+	"context"
+	"errors"
+	"time"
+
+	"git.x2erp.com/qdy/go-base/logger"
+	"git.x2erp.com/qdy/go-db/factory/mongodb"
+	"git.x2erp.com/qdy/go-svc-code/internal/model"
+	"go.mongodb.org/mongo-driver/bson"
+	"go.mongodb.org/mongo-driver/bson/primitive"
+)
+
+// SessionStore 会话存储服务
+type SessionStore struct {
+	mongoFactory *mongodb.MongoDBFactory
+}
+
+// NewSessionStore 创建新的会话存储服务
+func NewSessionStore(factory *mongodb.MongoDBFactory) *SessionStore {
+	return &SessionStore{mongoFactory: factory}
+}
+
+// Create 创建会话
+func (s *SessionStore) Create(ctx context.Context, session *model.Session) error {
+	if session.ID == "" {
+		return errors.New("session ID cannot be empty")
+	}
+	if session.Title == "" {
+		return errors.New("session title cannot be empty")
+	}
+	if session.AgentName == "" {
+		return errors.New("agent name cannot be empty")
+	}
+
+	// 设置时间戳
+	now := time.Now()
+	if session.CreatedAt.IsZero() {
+		session.CreatedAt = now
+	}
+	if session.UpdatedAt.IsZero() {
+		session.UpdatedAt = now
+	}
+
+	// 设置默认状态为需求文档
+	if session.Status == "" {
+		session.Status = model.StatusRequirementDocument
+	}
+
+	// 插入到MongoDB
+	_, success := s.mongoFactory.InsertOneWithResult(model.Session{}.CollectionName(), session)
+	if !success {
+		logger.Error("创建会话失败", "session_id", session.ID, "title", session.Title)
+		return errors.New("failed to create session")
+	}
+
+	logger.Debug("创建会话成功", "session_id", session.ID, "title", session.Title)
+	return nil
+}
+
+// GetByID 根据ID获取会话
+func (s *SessionStore) GetByID(ctx context.Context, id string) (*model.Session, error) {
+	if id == "" {
+		return nil, errors.New("session ID cannot be empty")
+	}
+
+	filter := bson.M{"_id": id}
+	var result model.Session
+
+	err := s.mongoFactory.FindOne(model.Session{}.CollectionName(), filter, &result)
+	if err != nil {
+		if err.Error() == "mongo: no documents in result" {
+			return nil, nil // 未找到会话
+		}
+		logger.Error("根据ID查询会话失败", "session_id", id, "error", err)
+		return nil, err
+	}
+
+	return &result, nil
+}
+
+// GetByUser 根据用户ID获取会话
+func (s *SessionStore) GetByUser(ctx context.Context, userID string) ([]*model.Session, error) {
+	if userID == "" {
+		return nil, errors.New("user ID cannot be empty")
+	}
+
+	filter := bson.M{"user_id": userID}
+	var sessions []*model.Session
+
+	err := s.mongoFactory.Find(model.Session{}.CollectionName(), filter, &sessions)
+	if err != nil {
+		logger.Error("根据用户查询会话失败", "user_id", userID, "error", err)
+		return nil, err
+	}
+
+	return sessions, nil
+}
+
+// Update 更新会话（状态和标题）
+func (s *SessionStore) Update(ctx context.Context, id string, title, status string) error {
+	if id == "" {
+		return errors.New("session ID cannot be empty")
+	}
+
+	// 检查会话是否存在
+	session, err := s.GetByID(ctx, id)
+	if err != nil {
+		return err
+	}
+	if session == nil {
+		return errors.New("session not found")
+	}
+
+	// 已发布的会话不能修改
+	if session.Status == model.StatusRelease {
+		return errors.New("released session cannot be modified")
+	}
+
+	// 构建更新内容
+	update := bson.M{
+		"updated_at": time.Now(),
+	}
+	if title != "" {
+		update["title"] = title
+	}
+	if status != "" {
+		// 验证状态值
+		if !model.IsValidStatus(status) {
+			return errors.New("invalid status value")
+		}
+		update["status"] = status
+	}
+
+	filter := bson.M{"_id": id}
+	success, _ := s.mongoFactory.UpdateOne(model.Session{}.CollectionName(), filter, update)
+	if !success {
+		logger.Error("更新会话失败", "session_id", id)
+		return errors.New("failed to update session")
+	}
+
+	logger.Debug("更新会话成功", "session_id", id)
+	return nil
+}
+
+// Delete 删除会话
+func (s *SessionStore) Delete(ctx context.Context, id string) error {
+	if id == "" {
+		return errors.New("session ID cannot be empty")
+	}
+
+	// 检查会话是否存在
+	session, err := s.GetByID(ctx, id)
+	if err != nil {
+		return err
+	}
+	if session == nil {
+		return errors.New("session not found")
+	}
+
+	// 已发布的会话不能删除
+	if session.Status == model.StatusRelease {
+		return errors.New("released session cannot be deleted")
+	}
+
+	filter := bson.M{"_id": id}
+	success, deletedCount := s.mongoFactory.DeleteOne(model.Session{}.CollectionName(), filter)
+	if !success {
+		logger.Error("删除会话失败", "session_id", id)
+		return errors.New("failed to delete session")
+	}
+
+	logger.Debug("删除会话成功", "session_id", id, "deleted_count", deletedCount)
+	return nil
+}
+
+// ListQuery 列表查询参数
+type ListQuery struct {
+	Page     int    `form:"page" binding:"min=1"`             // 页码，从1开始
+	PageSize int    `form:"pageSize" binding:"min=1,max=100"` // 每页大小，最大100
+	Title    string `form:"title,omitempty"`                  // 标题搜索（模糊匹配）
+	Status   string `form:"status,omitempty"`                 // 状态筛选
+	UserID   string // 用户ID（从上下文中获取）
+	TenantID string // 租户ID（从上下文中获取）
+}
+
+// ListResult 列表查询结果
+type ListResult struct {
+	Sessions   []*model.Session `json:"sessions"`
+	TotalCount int64            `json:"total_count"`
+	Page       int              `json:"page"`
+	PageSize   int              `json:"page_size"`
+	TotalPages int              `json:"total_pages"`
+}
+
+// List 分页查询会话列表
+func (s *SessionStore) List(ctx context.Context, query *ListQuery) (*ListResult, error) {
+	// 构建查询条件
+	filter := bson.M{
+		"user_id":   query.UserID,
+		"tenant_id": query.TenantID,
+	}
+
+	// 标题模糊匹配
+	if query.Title != "" {
+		filter["title"] = bson.M{"$regex": primitive.Regex{Pattern: query.Title, Options: "i"}}
+	}
+
+	// 状态筛选
+	if query.Status != "" {
+		filter["status"] = query.Status
+	}
+
+	// 查询所有匹配的记录（TODO: 优化为分页查询）
+	var allSessions []*model.Session
+	err := s.mongoFactory.Find(model.Session{}.CollectionName(), filter, &allSessions)
+	if err != nil {
+		logger.Error("查询会话列表失败", "error", err)
+		return nil, err
+	}
+
+	// 按创建时间倒序排序
+	// 由于MongoDB驱动可能已经按_id排序，我们需要手动排序
+	// 这里简单反转切片（假设Find返回的顺序是插入顺序）
+	// 实际应该使用聚合管道排序，但当前MongoDB工厂不支持
+	logger.Warn("会话列表查询使用内存分页，数据量大时性能可能受影响", "count", len(allSessions))
+
+	// 计算分页
+	if query.Page < 1 {
+		query.Page = 1
+	}
+	if query.PageSize < 1 {
+		query.PageSize = 20
+	} else if query.PageSize > 100 {
+		query.PageSize = 100
+	}
+
+	totalCount := int64(len(allSessions))
+	skip := (query.Page - 1) * query.PageSize
+
+	// 计算分页切片
+	var sessions []*model.Session
+	if skip < len(allSessions) {
+		end := skip + query.PageSize
+		if end > len(allSessions) {
+			end = len(allSessions)
+		}
+		sessions = allSessions[skip:end]
+	}
+
+	// 计算总页数
+	totalPages := int(totalCount) / query.PageSize
+	if int(totalCount)%query.PageSize > 0 {
+		totalPages++
+	}
+
+	result := &ListResult{
+		Sessions:   sessions,
+		TotalCount: totalCount,
+		Page:       query.Page,
+		PageSize:   query.PageSize,
+		TotalPages: totalPages,
+	}
+
+	return result, nil
+}
+
+// EnsureIndexes 确保集合索引
+func (s *SessionStore) EnsureIndexes(ctx context.Context) error {
+	// 主键索引（_id）已自动创建
+
+	// 用户ID索引（常用查询条件）
+	userIDIndexKeys := bson.D{{Key: "user_id", Value: 1}}
+	userIDSuccess := s.mongoFactory.CreateIndex(model.Session{}.CollectionName(), userIDIndexKeys)
+	if !userIDSuccess {
+		logger.Error("创建用户ID索引失败")
+		return errors.New("failed to create user_id index")
+	}
+
+	// 租户ID索引
+	tenantIDIndexKeys := bson.D{{Key: "tenant_id", Value: 1}}
+	tenantIDSuccess := s.mongoFactory.CreateIndex(model.Session{}.CollectionName(), tenantIDIndexKeys)
+	if !tenantIDSuccess {
+		logger.Error("创建租户ID索引失败")
+		return errors.New("failed to create tenant_id index")
+	}
+
+	// 状态索引（用于筛选）
+	statusIndexKeys := bson.D{{Key: "status", Value: 1}}
+	statusSuccess := s.mongoFactory.CreateIndex(model.Session{}.CollectionName(), statusIndexKeys)
+	if !statusSuccess {
+		logger.Error("创建状态索引失败")
+		return errors.New("failed to create status index")
+	}
+
+	// 创建时间索引（用于排序）
+	createdAtIndexKeys := bson.D{{Key: "created_at", Value: -1}}
+	createdAtSuccess := s.mongoFactory.CreateIndex(model.Session{}.CollectionName(), createdAtIndexKeys)
+	if !createdAtSuccess {
+		logger.Error("创建创建时间索引失败")
+		return errors.New("failed to create created_at index")
+	}
+
+	// 复合索引：用户ID + 创建时间（常用查询组合）
+	userCreatedIndexKeys := bson.D{
+		{Key: "user_id", Value: 1},
+		{Key: "created_at", Value: -1},
+	}
+	userCreatedSuccess := s.mongoFactory.CreateIndex(model.Session{}.CollectionName(), userCreatedIndexKeys)
+	if !userCreatedSuccess {
+		logger.Error("创建用户-创建时间复合索引失败")
+		return errors.New("failed to create user_id-created_at index")
+	}
+
+	logger.Debug("会话集合索引创建成功")
+	return nil
+}

main.go

@@ -16,8 +16,8 @@ import (
 
 	"git.x2erp.com/qdy/go-svc-code/internal/opencode"
 	"git.x2erp.com/qdy/go-svc-code/internal/routes"
+	svcservice "git.x2erp.com/qdy/go-svc-code/internal/service"
 	"git.x2erp.com/qdy/go-svc-code/internal/service/event"
-	"git.x2erp.com/qdy/go-svc-code/internal/service/menu"
 )
 
 var (
@@ -54,14 +54,22 @@ func main() {
 	mongoDBFactory := container.Create(ctr, mongodb.CreateFactory)
 	mongoDBFactory.TestConnection()
 
-	// 创建会话-菜单映射服务
-	mappingService := menu.NewMappingService(mongoDBFactory)
+	// 创建会话存储服务
+	sessionStore := svcservice.NewSessionStore(mongoDBFactory)
+	sessionDetailStore := svcservice.NewSessionDetailStore(mongoDBFactory)
+
 	// 确保索引存在
 	ctx := context.Background()
-	if err := mappingService.EnsureIndexes(ctx); err != nil {
-		log.Printf("警告：创建会话-菜单映射索引失败: %v", err)
+	if err := sessionStore.EnsureIndexes(ctx); err != nil {
+		log.Printf("警告：创建会话存储索引失败: %v", err)
+	} else {
+		log.Printf("会话存储索引确保成功")
+	}
+
+	if err := sessionDetailStore.EnsureIndexes(ctx); err != nil {
+		log.Printf("警告：创建会话明细存储索引失败: %v", err)
 	} else {
-		log.Printf("会话-菜单映射索引确保成功")
+		log.Printf("会话明细存储索引确保成功")
 	}
 
 	// 4. 创建 configure 客户端
@@ -107,7 +115,7 @@ func main() {
 	health.RegisterConsulHealthCheck(routerService)
 
 	// 9. 注册路由--api
-	registerRoutes(routerService, webService, configClient, client, nil, opencodePort, mappingService)
+	registerRoutes(routerService, webService, configClient, client, nil, opencodePort, sessionStore, sessionDetailStore)
 
 	// 9. 注册前端静态文件服务
 	//registerStaticFiles(webService)
@@ -123,12 +131,12 @@ func main() {
 }
 
 // registerRoutes 注册所有 API 路由
-func registerRoutes(ws *router.RouterService, webService *webx.WebService, configClient *configure.Client, client opencode.OpenCodeClient, opencodeProcess *opencode.Process, opencodePort int, mappingService *menu.MappingService) {
+func registerRoutes(ws *router.RouterService, webService *webx.WebService, configClient *configure.Client, client opencode.OpenCodeClient, opencodeProcess *opencode.Process, opencodePort int, sessionStore *svcservice.SessionStore, sessionDetailStore *svcservice.SessionDetailStore) {
 	// 认证路由（公开登录接口）
 	routes.RegisterAuthRoutes(ws, configClient)
 
 	// 会话管理路由
-	routes.RegisterSessionRoutes(ws, client, mappingService)
+	routes.RegisterSessionRoutes(ws, client, sessionStore, sessionDetailStore)
 
 	// 同步对话路由
 	routes.RegisterPromptSyncRoutes(ws, client)
@@ -142,6 +150,6 @@ func registerRoutes(ws *router.RouterService, webService *webx.WebService, confi
 	// 会话消息路由
 	routes.RegisterSessionMessagesRoutes(ws, client)
 
-	// 菜单路由
-	routes.RegisterMenuRoutes(ws, mappingService)
+	// 智能体路由
+	routes.RegisterAgentRoutes(ws)
 }

test/integration_api_test.go

@@ -0,0 +1,538 @@
+//go:build integration
+
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"testing"
+	"time"
+)
+
+// TestNewSessionAPI 测试新的会话API
+func TestNewSessionAPI(t *testing.T) {
+	t.Log("🚀 开始测试新的会话API")
+
+	baseURL := "http://localhost:8020"
+
+	// 1. 获取认证token
+	token := getAuthToken(t, baseURL)
+	if token == "" {
+		t.Fatal("无法获取认证token")
+	}
+	t.Logf("✅ 获取到认证token: %s...", token[:min(20, len(token))])
+
+	// 2. 获取智能体列表
+	agents := getAgents(t, baseURL, token)
+	if agents == nil {
+		t.Fatal("无法获取智能体列表")
+	}
+	t.Logf("✅ 获取到 %d 个智能体", len(agents))
+
+	// 验证智能体
+	expectedAgents := map[string]string{
+		"replenish":  "补货",
+		"transfer":   "调拨",
+		"allocation": "配货",
+		"report":     "报表",
+	}
+
+	for _, agent := range agents {
+		if expectedName, ok := expectedAgents[agent.ID]; !ok {
+			t.Errorf("未知的智能体ID: %s", agent.ID)
+		} else if agent.Name != expectedName {
+			t.Errorf("智能体 %s 名称不匹配，期望: %s, 实际: %s", agent.ID, expectedName, agent.Name)
+		}
+	}
+
+	// 3. 创建会话
+	sessionID := createSession(t, baseURL, token, "API集成测试会话", "replenish")
+	if sessionID == "" {
+		t.Fatal("无法创建会话")
+	}
+	t.Logf("✅ 创建会话成功: %s", sessionID)
+
+	// 4. 查询会话列表
+	sessions := listSessions(t, baseURL, token, 1, 10, "", "")
+	if sessions == nil {
+		t.Fatal("无法查询会话列表")
+	}
+	t.Logf("✅ 查询到 %d 个会话 (总共 %d)", len(sessions.Sessions), sessions.TotalCount)
+
+	// 5. 查询单个会话详情
+	sessionDetail := getSessionDetail(t, baseURL, token, sessionID)
+	if sessionDetail == nil {
+		t.Fatal("无法获取会话详情")
+	}
+	t.Logf("✅ 获取会话详情成功")
+	t.Logf("   会话ID: %s", sessionDetail.Session.ID)
+	t.Logf("   标题: %s", sessionDetail.Session.Title)
+	t.Logf("   智能体: %s", sessionDetail.Session.AgentName)
+	t.Logf("   状态: %s", sessionDetail.Session.Status)
+
+	// 6. 更新会话
+	success := updateSession(t, baseURL, token, sessionID, "更新后的标题", "technical_document")
+	if !success {
+		t.Fatal("无法更新会话")
+	}
+	t.Logf("✅ 更新会话成功")
+
+	// 7. 验证更新
+	updatedDetail := getSessionDetail(t, baseURL, token, sessionID)
+	if updatedDetail == nil {
+		t.Fatal("无法获取更新后的会话详情")
+	}
+	if updatedDetail.Session.Title != "更新后的标题" {
+		t.Errorf("标题更新失败，期望: %s, 实际: %s", "更新后的标题", updatedDetail.Session.Title)
+	}
+	if updatedDetail.Session.Status != "technical_document" {
+		t.Errorf("状态更新失败，期望: %s, 实际: %s", "technical_document", updatedDetail.Session.Status)
+	}
+	t.Logf("✅ 验证更新成功")
+
+	// 8. 测试分页和筛选
+	t.Log("🔍 测试分页和筛选功能...")
+
+	// 创建更多测试数据
+	sessionIDs := []string{}
+	for i := 1; i <= 3; i++ {
+		id := createSession(t, baseURL, token, fmt.Sprintf("分页测试会话 %d", i), "transfer")
+		if id != "" {
+			sessionIDs = append(sessionIDs, id)
+		}
+	}
+
+	// 测试分页
+	page1 := listSessions(t, baseURL, token, 1, 2, "", "")
+	if page1 != nil {
+		t.Logf("✅ 第一页获取到 %d 个会话", len(page1.Sessions))
+	}
+
+	// 测试标题搜索
+	searchResult := listSessions(t, baseURL, token, 1, 10, "分页测试", "")
+	if searchResult != nil {
+		t.Logf("✅ 标题搜索获取到 %d 个会话", len(searchResult.Sessions))
+	}
+
+	// 测试状态筛选
+	statusResult := listSessions(t, baseURL, token, 1, 10, "", "requirement_document")
+	if statusResult != nil {
+		t.Logf("✅ 状态筛选获取到 %d 个需求文档状态的会话", len(statusResult.Sessions))
+	}
+
+	// 9. 清理测试数据
+	t.Log("🧹 清理测试数据...")
+
+	// 删除创建的会话
+	allSessions := listSessions(t, baseURL, token, 1, 100, "", "")
+	if allSessions != nil {
+		for _, session := range allSessions.Sessions {
+			if session.ID == sessionID || contains(sessionIDs, session.ID) {
+				deleteSession(t, baseURL, token, session.ID)
+				t.Logf("   删除会话: %s", session.ID)
+			}
+		}
+	}
+
+	t.Log("🎉 所有测试通过!")
+}
+
+// 辅助函数
+
+func getAuthToken(t *testing.T, baseURL string) string {
+	url := baseURL + "/api/auth/login"
+	loginData := map[string]string{
+		"user_id":  "test-user-001",
+		"password": "password123",
+	}
+	jsonData, _ := json.Marshal(loginData)
+
+	resp, err := http.Post(url, "application/json", bytes.NewBuffer(jsonData))
+	if err != nil {
+		t.Logf("登录失败: %v，使用模拟token", err)
+		return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidGVzdCIsInVzZXJuYW1lIjoidGVzdCIsImV4cCI6MTc3MTE0MTQyNywiaWF0IjoxNzE4NDIxNDI3fQ.SimulatedTokenForDevelopment"
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("登录返回状态码 %d，使用模拟token", resp.StatusCode)
+		return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidGVzdCIsInVzZXJuYW1lIjoidGVzdCIsImV4cCI6MTc3MTE0MTQyNywiaWF0IjoxNzE4NDIxNDI3fQ.SimulatedTokenForDevelopment"
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool   `json:"success"`
+		Data    string `json:"data"`
+		Message string `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v，使用模拟token", err)
+		return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidGVzdCIsInVzZXJuYW1lIjoidGVzdCIsImV4cCI6MTc3MTE0MTQyNywiaWF0IjoxNzE4NDIxNDI3fQ.SimulatedTokenForDevelopment"
+	}
+
+	if !result.Success {
+		t.Logf("登录失败: %s，使用模拟token", result.Message)
+		return "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VyX2lkIjoidGVzdCIsInVzZXJuYW1lIjoidGVzdCIsImV4cCI6MTc3MTE0MTQyNywiaWF0IjoxNzE4NDIxNDI3fQ.SimulatedTokenForDevelopment"
+	}
+
+	return result.Data
+}
+
+func getAgents(t *testing.T, baseURL, token string) []Agent {
+	url := baseURL + "/api/agents"
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		t.Logf("创建请求失败: %v", err)
+		return nil
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Logf("HTTP请求失败: %v", err)
+		return nil
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("HTTP状态码 %d", resp.StatusCode)
+		return nil
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool    `json:"success"`
+		Data    []Agent `json:"data"`
+		Message string  `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v", err)
+		return nil
+	}
+
+	if !result.Success {
+		t.Logf("API调用失败: %s", result.Message)
+		return nil
+	}
+
+	return result.Data
+}
+
+func createSession(t *testing.T, baseURL, token, title, agentName string) string {
+	url := baseURL + "/api/session/create"
+	sessionData := map[string]string{
+		"title":      title,
+		"agent_name": agentName,
+	}
+	jsonData, _ := json.Marshal(sessionData)
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		t.Logf("创建请求失败: %v", err)
+		return ""
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Logf("HTTP请求失败: %v", err)
+		return ""
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("HTTP状态码 %d", resp.StatusCode)
+		body, _ := io.ReadAll(resp.Body)
+		t.Logf("响应体: %s", string(body))
+		return ""
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool `json:"success"`
+		Data    struct {
+			ID string `json:"id"`
+		} `json:"data"`
+		Message string `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v", err)
+		return ""
+	}
+
+	if !result.Success {
+		t.Logf("创建会话失败: %s", result.Message)
+		return ""
+	}
+
+	return result.Data.ID
+}
+
+func listSessions(t *testing.T, baseURL, token string, page, pageSize int, title, status string) *SessionListResult {
+	url := fmt.Sprintf("%s/api/sessions?page=%d&pageSize=%d", baseURL, page, pageSize)
+	if title != "" {
+		url += "&title=" + title
+	}
+	if status != "" {
+		url += "&status=" + status
+	}
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		t.Logf("创建请求失败: %v", err)
+		return nil
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Logf("HTTP请求失败: %v", err)
+		return nil
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("HTTP状态码 %d", resp.StatusCode)
+		return nil
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool               `json:"success"`
+		Data    *SessionListResult `json:"data"`
+		Message string             `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v", err)
+		return nil
+	}
+
+	if !result.Success {
+		t.Logf("API调用失败: %s", result.Message)
+		return nil
+	}
+
+	return result.Data
+}
+
+func getSessionDetail(t *testing.T, baseURL, token, sessionID string) *SessionWithDetail {
+	url := baseURL + "/api/session/" + sessionID
+
+	req, err := http.NewRequest("GET", url, nil)
+	if err != nil {
+		t.Logf("创建请求失败: %v", err)
+		return nil
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Logf("HTTP请求失败: %v", err)
+		return nil
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("HTTP状态码 %d", resp.StatusCode)
+		return nil
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool               `json:"success"`
+		Data    *SessionWithDetail `json:"data"`
+		Message string             `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v", err)
+		return nil
+	}
+
+	if !result.Success {
+		t.Logf("API调用失败: %s", result.Message)
+		return nil
+	}
+
+	return result.Data
+}
+
+func updateSession(t *testing.T, baseURL, token, sessionID, title, status string) bool {
+	url := baseURL + "/api/session/" + sessionID
+
+	updateData := make(map[string]string)
+	if title != "" {
+		updateData["title"] = title
+	}
+	if status != "" {
+		updateData["status"] = status
+	}
+
+	jsonData, _ := json.Marshal(updateData)
+
+	req, err := http.NewRequest("PUT", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		t.Logf("创建请求失败: %v", err)
+		return false
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+	req.Header.Set("Content-Type", "application/json")
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Logf("HTTP请求失败: %v", err)
+		return false
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("HTTP状态码 %d", resp.StatusCode)
+		return false
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool   `json:"success"`
+		Data    bool   `json:"data"`
+		Message string `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v", err)
+		return false
+	}
+
+	if !result.Success {
+		t.Logf("更新会话失败: %s", result.Message)
+		return false
+	}
+
+	return result.Data
+}
+
+func deleteSession(t *testing.T, baseURL, token, sessionID string) bool {
+	url := baseURL + "/api/session/" + sessionID
+
+	req, err := http.NewRequest("DELETE", url, nil)
+	if err != nil {
+		t.Logf("创建请求失败: %v", err)
+		return false
+	}
+	req.Header.Set("Authorization", "Bearer "+token)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		t.Logf("HTTP请求失败: %v", err)
+		return false
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != 200 {
+		t.Logf("HTTP状态码 %d", resp.StatusCode)
+		return false
+	}
+
+	body, _ := io.ReadAll(resp.Body)
+	var result struct {
+		Success bool   `json:"success"`
+		Data    bool   `json:"data"`
+		Message string `json:"message"`
+	}
+
+	if err := json.Unmarshal(body, &result); err != nil {
+		t.Logf("解析响应失败: %v", err)
+		return false
+	}
+
+	if !result.Success {
+		t.Logf("删除会话失败: %s", result.Message)
+		return false
+	}
+
+	return result.Data
+}
+
+// 数据结构
+
+type Agent struct {
+	ID   string `json:"id"`
+	Name string `json:"name"`
+}
+
+type Session struct {
+	ID        string    `json:"id"`
+	Title     string    `json:"title"`
+	AgentName string    `json:"agent_name"`
+	Status    string    `json:"status"`
+	UserID    string    `json:"user_id"`
+	TenantID  string    `json:"tenant_id"`
+	CreatedAt time.Time `json:"created_at"`
+	UpdatedAt time.Time `json:"updated_at"`
+}
+
+type SessionListResult struct {
+	Sessions   []*Session `json:"sessions"`
+	TotalCount int64      `json:"total_count"`
+	Page       int        `json:"page"`
+	PageSize   int        `json:"page_size"`
+	TotalPages int        `json:"total_pages"`
+}
+
+type SessionWithDetail struct {
+	Session      *Session       `json:"session"`
+	Detail       *SessionDetail `json:"detail"`
+	HistoryCount int            `json:"history_count"`
+}
+
+type SessionDetail struct {
+	ID             string     `json:"id,omitempty"`
+	SessionID      string     `json:"session_id"`
+	RequirementDoc string     `json:"requirement_doc"`
+	TechnicalDoc   string     `json:"technical_doc"`
+	CodeItems      []CodeItem `json:"code_items"`
+	CreatedAt      time.Time  `json:"created_at"`
+	UpdatedAt      time.Time  `json:"updated_at"`
+}
+
+type CodeItem struct {
+	Order         int                    `json:"order"`
+	SelectPart    string                 `json:"select_part"`
+	FromPart      string                 `json:"from_part"`
+	WherePart     string                 `json:"where_part"`
+	GroupByPart   string                 `json:"group_by_part"`
+	OrderByPart   string                 `json:"order_by_part"`
+	TempTableName string                 `json:"temp_table_name"`
+	Parameters    map[string]interface{} `json:"parameters"`
+	ReturnColumns map[string]string      `json:"return_columns"`
+}
+
+// 工具函数
+func min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}
+
+func contains(slice []string, item string) bool {
+	for _, s := range slice {
+		if s == item {
+			return true
+		}
+	}
+	return false
+}