chore: ut

backend/application/conversation/openapi_agent_run.go

@@ -21,6 +21,7 @@ import (
 	"encoding/json"
 	"errors"
 	"io"
+	"slices"
 	"strconv"
 
 	"github.com/cloudwego/eino/schema"
@@ -102,7 +103,7 @@ func (a *OpenapiAgentRunApplication) checkConversation(ctx context.Context, ar *
 			return nil, err
 		}
 		if conData == nil {
-			return nil, errors.New("conversation data is nil")
+			return nil, errorx.New(errno.ErrConversationNotFound)
 		}
 		conversationData = conData
 
@@ -110,7 +111,7 @@ func (a *OpenapiAgentRunApplication) checkConversation(ctx context.Context, ar *
 	}
 
 	if conversationData.CreatorID != userID {
-		return nil, errors.New("conversation data not match")
+		return nil, errorx.New(errno.ErrConversationPermissionCode, errorx.KV("msg","user not match"))
 	}
 
 	return conversationData, nil
@@ -138,26 +139,31 @@ func (a *OpenapiAgentRunApplication) buildAgentRunRequest(ctx context.Context, a
 	if err != nil {
 		return nil, err
 	}
-	multiContent, contentType, err := a.buildMultiContent(ctx, ar)
+	multiAdditionalMessages, err := a.parseAdditionalMessages(ctx, ar)
+	if err != nil {
+		return nil, err
+	}
+	filterMultiAdditionalMessages, multiContent, contentType, err := a.parseQueryContent(ctx, multiAdditionalMessages)
 	if err != nil {
 		return nil, err
 	}
 	displayContent := a.buildDisplayContent(ctx, ar)
 	arm := &entity.AgentRunMeta{
-		ConversationID:   ptr.From(ar.ConversationID),
+		ConversationID:     ptr.From(ar.ConversationID),
-		AgentID:          ar.BotID,
+		AgentID:            ar.BotID,
-		Content:          multiContent,
+		Content:            multiContent,
-		DisplayContent:   displayContent,
+		DisplayContent:     displayContent,
-		SpaceID:          spaceID,
+		SpaceID:            spaceID,
-		UserID:           ar.User,
+		UserID:             ar.User,
-		SectionID:        conversationData.SectionID,
+		SectionID:          conversationData.SectionID,
-		PreRetrieveTools: shortcutCMDData,
+		PreRetrieveTools:   shortcutCMDData,
-		IsDraft:          false,
+		IsDraft:            false,
-		ConnectorID:      connectorID,
+		ConnectorID:        connectorID,
-		ContentType:      contentType,
+		ContentType:        contentType,
-		Ext:              ar.ExtraParams,
+		Ext:                ar.ExtraParams,
-		CustomVariables:  ar.CustomVariables,
+		CustomVariables:    ar.CustomVariables,
-		CozeUID:          conversationData.CreatorID,
+		CozeUID:            conversationData.CreatorID,
+		AdditionalMessages: filterMultiAdditionalMessages,
 	}
 	return arm, nil
 }
@@ -200,29 +206,68 @@ func (a *OpenapiAgentRunApplication) buildDisplayContent(_ context.Context, ar *
 	return ""
 }
 
-func (a *OpenapiAgentRunApplication) buildMultiContent(ctx context.Context, ar *run.ChatV3Request) ([]*message.InputMetaData, message.ContentType, error) {
+func (a *OpenapiAgentRunApplication) parseQueryContent(ctx context.Context, multiAdditionalMessages []*entity.AdditionalMessage) ([]*entity.AdditionalMessage, []*message.InputMetaData, message.ContentType, error) {
-	var multiContents []*message.InputMetaData
+
-	contentType := message.ContentTypeText
+	var multiContent []*message.InputMetaData
+	var contentType message.ContentType
+	var filterMultiAdditionalMessages []*entity.AdditionalMessage
+	filterMultiAdditionalMessages = multiAdditionalMessages
+
+	if len(multiAdditionalMessages) > 0 {
+		lastMessage := multiAdditionalMessages[len(multiAdditionalMessages)-1]
+		if lastMessage != nil && lastMessage.Role == schema.User {
+			multiContent = lastMessage.Content
+			contentType = lastMessage.ContentType
+			filterMultiAdditionalMessages = multiAdditionalMessages[:len(multiAdditionalMessages)-1]
+		}
+	}
+
+	return filterMultiAdditionalMessages, multiContent, contentType, nil
+}
+
+func (a *OpenapiAgentRunApplication) parseAdditionalMessages(ctx context.Context, ar *run.ChatV3Request) ([]*entity.AdditionalMessage, error) {
+
+	additionalMessages := make([]*entity.AdditionalMessage, 0, len(ar.AdditionalMessages))
 
 	for _, item := range ar.AdditionalMessages {
 		if item == nil {
 			continue
 		}
-		if item.Role != string(schema.User) {
+		if item.Role != string(schema.User) && item.Role != string(schema.Assistant) {
-			return nil, contentType, errors.New("role not match")
+			return nil, errors.New("additional message role only support user and assistant")
 		}
+		if item.Type != nil && !slices.Contains([]message.MessageType{message.MessageTypeQuestion, message.MessageTypeAnswer}, message.MessageType(*item.Type)) {
+			return nil, errors.New("additional message type only support question and answer now")
+		}
+
+		addOne := entity.AdditionalMessage{
+			Role: schema.RoleType(item.Role),
+		}
+		if item.Type != nil {
+			addOne.Type = message.MessageType(*item.Type)
+		} else {
+			addOne.Type = message.MessageTypeQuestion
+		}
+
 		if item.ContentType == run.ContentTypeText {
 			if item.Content == "" {
 				continue
 			}
-			multiContents = append(multiContents, &message.InputMetaData{
+
+			addOne.ContentType = message.ContentTypeText
+			addOne.Content = []*message.InputMetaData{{
 				Type: message.InputTypeText,
 				Text: item.Content,
-			})
+			}}
 		}
 
 		if item.ContentType == run.ContentTypeMixApi {
-			contentType = message.ContentTypeMix
+
+			if ptr.From(item.Type) == string(message.MessageTypeAnswer) {
+				return nil, errors.New(" answer messages only support text content")
+			}
+
+			addOne.ContentType = message.ContentTypeMix
 			var inputs []*run.AdditionalContent
 			err := json.Unmarshal([]byte(item.Content), &inputs)
 
@@ -236,7 +281,8 @@ func (a *OpenapiAgentRunApplication) buildMultiContent(ctx context.Context, ar *
 				}
 				switch message.InputType(one.Type) {
 				case message.InputTypeText:
-					multiContents = append(multiContents, &message.InputMetaData{
+
+					addOne.Content = append(addOne.Content, &message.InputMetaData{
 						Type: message.InputTypeText,
 						Text: ptr.From(one.Text),
 					})
@@ -250,12 +296,12 @@ func (a *OpenapiAgentRunApplication) buildMultiContent(ctx context.Context, ar *
 							ID: one.GetFileID(),
 						})
 						if err != nil {
-							return nil, contentType, err
+							return nil, err
 						}
 						fileUrl = fileInfo.File.Url
 						fileURI = fileInfo.File.TosURI
 					}
-					multiContents = append(multiContents, &message.InputMetaData{
+					addOne.Content = append(addOne.Content, &message.InputMetaData{
 						Type: message.InputType(one.Type),
 						FileData: []*message.FileData{
 							{
@@ -269,10 +315,10 @@ func (a *OpenapiAgentRunApplication) buildMultiContent(ctx context.Context, ar *
 				}
 			}
 		}
-
+		additionalMessages = append(additionalMessages, &addOne)
 	}
 
-	return multiContents, contentType, nil
+	return additionalMessages, nil
 }
 
 func (a *OpenapiAgentRunApplication) pullStream(ctx context.Context, sseSender *sseImpl.SSenderImpl, streamer *schema.StreamReader[*entity.AgentRunResponse]) {

backend/application/conversation/openapi_agent_run_test.go

@@ -0,0 +1,903 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package conversation
+
+import (
+	"context"
+	"errors"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"go.uber.org/mock/gomock"
+
+	"github.com/coze-dev/coze-studio/backend/api/model/conversation/common"
+	"github.com/coze-dev/coze-studio/backend/api/model/conversation/run"
+	"github.com/coze-dev/coze-studio/backend/api/model/crossdomain/singleagent"
+	saEntity "github.com/coze-dev/coze-studio/backend/domain/agent/singleagent/entity"
+	convEntity "github.com/coze-dev/coze-studio/backend/domain/conversation/conversation/entity"
+	openapiEntity "github.com/coze-dev/coze-studio/backend/domain/openauth/openapiauth/entity"
+	cmdEntity "github.com/coze-dev/coze-studio/backend/domain/shortcutcmd/entity"
+	uploadEntity "github.com/coze-dev/coze-studio/backend/domain/upload/entity"
+	uploadService "github.com/coze-dev/coze-studio/backend/domain/upload/service"
+	sseImpl "github.com/coze-dev/coze-studio/backend/infra/impl/sse"
+	mockSingleAgent "github.com/coze-dev/coze-studio/backend/internal/mock/domain/agent/singleagent"
+	mockAgentRun "github.com/coze-dev/coze-studio/backend/internal/mock/domain/conversation/agentrun"
+	mockConversation "github.com/coze-dev/coze-studio/backend/internal/mock/domain/conversation/conversation"
+	mockShortcut "github.com/coze-dev/coze-studio/backend/internal/mock/domain/shortcutcmd"
+	mockUpload "github.com/coze-dev/coze-studio/backend/internal/mock/domain/upload"
+	"github.com/coze-dev/coze-studio/backend/pkg/ctxcache"
+	"github.com/coze-dev/coze-studio/backend/pkg/lang/ptr"
+	"github.com/coze-dev/coze-studio/backend/types/consts"
+)
+
+func setupMocks(t *testing.T) (*OpenapiAgentRunApplication, *mockShortcut.MockShortcutCmd, *mockUpload.MockUploadService, *mockAgentRun.MockRun, *mockConversation.MockConversation, *mockSingleAgent.MockSingleAgent, *gomock.Controller) {
+	ctrl := gomock.NewController(t)
+
+	mockShortcutSvc := mockShortcut.NewMockShortcutCmd(ctrl)
+	mockUploadSvc := mockUpload.NewMockUploadService(ctrl)
+	mockAgentRunSvc := mockAgentRun.NewMockRun(ctrl)
+	mockConversationSvc := mockConversation.NewMockConversation(ctrl)
+	mockSingleAgentSvc := mockSingleAgent.NewMockSingleAgent(ctrl)
+
+	app := &OpenapiAgentRunApplication{
+		ShortcutDomainSVC: mockShortcutSvc,
+		UploaodDomainSVC:  mockUploadSvc,
+	}
+
+	// Setup ConversationSVC mocks
+	originalConversationSVC := ConversationSVC
+	ConversationSVC = &ConversationApplicationService{
+		AgentRunDomainSVC:     mockAgentRunSvc,
+		ConversationDomainSVC: mockConversationSvc,
+		appContext: &ServiceComponents{
+			SingleAgentDomainSVC: mockSingleAgentSvc,
+		},
+	}
+
+	t.Cleanup(func() {
+		ConversationSVC = originalConversationSVC
+		ctrl.Finish()
+	})
+
+	return app, mockShortcutSvc, mockUploadSvc, mockAgentRunSvc, mockConversationSvc, mockSingleAgentSvc, ctrl
+}
+
+func createTestContext() context.Context {
+	ctx := context.Background()
+	ctx = ctxcache.Init(ctx)
+	apiKey := &openapiEntity.ApiKey{
+		UserID:      12345,
+		ConnectorID: consts.CozeConnectorID,
+	}
+	ctxcache.Store(ctx, consts.OpenapiAuthKeyInCtx, apiKey)
+	return ctx
+}
+
+func createTestRequest() *run.ChatV3Request {
+	return &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     "Hello, world!",
+				ContentType: run.ContentTypeText,
+			},
+		},
+	}
+}
+
+func createTestRequestWithMultipleMessages() *run.ChatV3Request {
+	return &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     "Hello, I need help with something.",
+				ContentType: run.ContentTypeText,
+			},
+			{
+				Role:        "assistant",
+				Content:     "Sure, I'd be happy to help! What do you need assistance with?",
+				ContentType: run.ContentTypeText,
+			},
+			{
+				Role:        "user",
+				Content:     `{"type": "image", "url": "https://example.com/image.jpg"}`,
+				ContentType: run.ContentTypeImage,
+			},
+			{
+				Role:        "user",
+				Content:     `{"type": "file", "name": "document.pdf", "url": "https://example.com/doc.pdf"}`,
+				ContentType: run.ContentTypeFile,
+			},
+		},
+	}
+}
+
+func createTestRequestWithAssistantOnly() *run.ChatV3Request {
+	return &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "assistant",
+				Content:     "I'm here to help you with any questions you might have.",
+				ContentType: run.ContentTypeText, // assistant role only supports text content type
+			},
+		},
+	}
+}
+
+func TestOpenapiAgentRun_Success(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+
+	// Mock agent check
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+}
+
+func TestOpenapiAgentRun_CheckAgentError(t *testing.T) {
+	app, _, _, _, _, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+
+	// Mock agent check failure
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(nil, errors.New("agent not found"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "agent not found")
+}
+
+func TestOpenapiAgentRun_AgentNotExists(t *testing.T) {
+	app, _, _, _, _, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+
+	// Mock agent check returns nil (agent not exists)
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(nil, nil)
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+}
+
+func TestOpenapiAgentRun_CheckConversationError(t *testing.T) {
+	app, _, _, _, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check failure
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(nil, errors.New("conversation not found"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "conversation not found")
+}
+
+func TestOpenapiAgentRun_ConversationPermissionError(t *testing.T) {
+	app, _, _, _, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation with different creator
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 99999, // Different from user ID (12345)
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+}
+
+func TestOpenapiAgentRun_CreateNewConversation(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+	req.ConversationID = ptr.Of(int64(0)) // No conversation ID
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock create new conversation
+	mockConv := &convEntity.Conversation{
+		ID:        22222,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().Create(ctx, gomock.Any()).DoAndReturn(func(ctx context.Context, meta *convEntity.CreateMeta) (*convEntity.Conversation, error) {
+		assert.Equal(t, int64(67890), meta.AgentID)
+		assert.Equal(t, int64(12345), meta.UserID)
+		assert.Equal(t, common.Scene_SceneOpenApi, meta.Scene)
+		return mockConv, nil
+	})
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Equal(t, int64(22222), *req.ConversationID) // Should be updated
+}
+
+func TestOpenapiAgentRun_AgentRunError(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("agent run failed"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "agent run failed")
+}
+
+func TestOpenapiAgentRun_WithShortcutCommand(t *testing.T) {
+	app, mockShortcut, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequest()
+	req.ShortcutCommand = &run.ShortcutCommandDetail{
+		CommandID:  123,
+		Parameters: map[string]string{"param1": "value1"},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock shortcut command
+	mockCmd := &cmdEntity.ShortcutCmd{
+		ID:             123,
+		PluginID:       456,
+		PluginToolName: "test-tool",
+		PluginToolID:   789,
+		ToolType:       1,
+	}
+	mockShortcut.EXPECT().GetByCmdID(ctx, int64(123), int32(0)).Return(mockCmd, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+}
+
+func TestOpenapiAgentRun_WithMultipleMessages(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequestWithMultipleMessages()
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+
+	// Verify that the request contains multiple messages with different roles and content types
+	assert.Len(t, req.AdditionalMessages, 4)
+	assert.Equal(t, "user", req.AdditionalMessages[0].Role)
+	assert.Equal(t, run.ContentTypeText, req.AdditionalMessages[0].ContentType)
+	assert.Equal(t, "assistant", req.AdditionalMessages[1].Role)
+	assert.Equal(t, run.ContentTypeText, req.AdditionalMessages[1].ContentType)
+	assert.Equal(t, "user", req.AdditionalMessages[2].Role)
+	assert.Equal(t, run.ContentTypeImage, req.AdditionalMessages[2].ContentType)
+	assert.Equal(t, "user", req.AdditionalMessages[3].Role)
+	assert.Equal(t, run.ContentTypeFile, req.AdditionalMessages[3].ContentType)
+}
+
+func TestOpenapiAgentRun_WithAssistantMessage(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+	req := createTestRequestWithAssistantOnly()
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+
+	// Verify that the assistant message only supports text content type
+	assert.Len(t, req.AdditionalMessages, 1)
+	assert.Equal(t, "assistant", req.AdditionalMessages[0].Role)
+	assert.Equal(t, run.ContentTypeText, req.AdditionalMessages[0].ContentType)
+}
+
+func TestOpenapiAgentRun_WithMixedContentTypes(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with various content types for user role
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     "Here's a text message",
+				ContentType: run.ContentTypeText,
+			},
+			{
+				Role:        "user",
+				Content:     `{"type": "audio", "url": "https://example.com/audio.mp3"}`,
+				ContentType: run.ContentTypeAudio,
+			},
+			{
+				Role:        "user",
+				Content:     `{"type": "video", "url": "https://example.com/video.mp4"}`,
+				ContentType: run.ContentTypeVideo,
+			},
+			{
+				Role:        "assistant",
+				Content:     "I can only respond with text content.",
+				ContentType: run.ContentTypeText, // assistant must use text
+			},
+			{
+				Role:        "user",
+				Content:     `{"type": "link", "url": "https://example.com"}`,
+				ContentType: run.ContentTypeLink,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+
+	// Verify various content types are preserved
+	assert.Len(t, req.AdditionalMessages, 5)
+
+	// Check user messages with different content types
+	assert.Equal(t, "user", req.AdditionalMessages[0].Role)
+	assert.Equal(t, run.ContentTypeText, req.AdditionalMessages[0].ContentType)
+
+	assert.Equal(t, "user", req.AdditionalMessages[1].Role)
+	assert.Equal(t, run.ContentTypeAudio, req.AdditionalMessages[1].ContentType)
+
+	assert.Equal(t, "user", req.AdditionalMessages[2].Role)
+	assert.Equal(t, run.ContentTypeVideo, req.AdditionalMessages[2].ContentType)
+
+	// Check assistant message (must be text)
+	assert.Equal(t, "assistant", req.AdditionalMessages[3].Role)
+	assert.Equal(t, run.ContentTypeText, req.AdditionalMessages[3].ContentType)
+
+	assert.Equal(t, "user", req.AdditionalMessages[4].Role)
+	assert.Equal(t, run.ContentTypeLink, req.AdditionalMessages[4].ContentType)
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_InvalidRole(t *testing.T) {
+	app, _, _, _, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with invalid role
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "system", // Invalid role
+				Content:     "System message",
+				ContentType: run.ContentTypeText,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success to reach parseAdditionalMessages
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "additional message role only support user and assistant")
+}
+
+
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_InvalidType(t *testing.T) {
+	app, _, _, _, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with invalid message type
+	invalidType := "invalid_type"
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     "Test message",
+				ContentType: run.ContentTypeText,
+				Type:        &invalidType, // Invalid type
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success to reach parseAdditionalMessages
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "additional message type only support question and answer now")
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_AnswerWithNonTextContent(t *testing.T) {
+	app, _, _, _, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with answer type but non-text content
+	answerType := "answer"
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "assistant",
+				Content:     `[{"type": "image", "file_url": "https://example.com/image.jpg"}]`,
+				ContentType: run.ContentTypeMixApi, // object_string
+				Type:        &answerType,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success to reach parseAdditionalMessages
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "answer messages only support text content")
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_MixApiWithFileURL(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with object_string content type and file URL
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     `[{"type": "text", "text": "Here's an image:"}, {"type": "image", "file_url": "https://example.com/image.jpg"}]`,
+				ContentType: run.ContentTypeMixApi,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_MixApiWithFileID(t *testing.T) {
+	app, _, mockUpload, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with object_string content type and file ID
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     `[{"type": "file", "file_id": "12345"}]`,
+				ContentType: run.ContentTypeMixApi,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock upload service to return file info
+	mockUpload.EXPECT().GetFile(ctx, gomock.Any()).DoAndReturn(func(ctx context.Context, req *uploadService.GetFileRequest) (*uploadService.GetFileResponse, error) {
+		assert.Equal(t, int64(12345), req.ID)
+		return &uploadService.GetFileResponse{
+			File: &uploadEntity.File{
+				Url:    "https://example.com/file.pdf",
+				TosURI: "tos://bucket/file.pdf",
+			},
+		}, nil
+	})
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_FileIDError(t *testing.T) {
+	app, _, mockUpload, _, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with object_string content type and file ID that will fail
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     `[{"type": "file", "file_id": "99999"}]`,
+				ContentType: run.ContentTypeMixApi,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock upload service to return error
+	mockUpload.EXPECT().GetFile(ctx, gomock.Any()).Return(nil, errors.New("file not found"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "file not found")
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_EmptyContent(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with empty text content (should be skipped)
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     "", // Empty content
+				ContentType: run.ContentTypeText,
+			},
+			{
+				Role:        "user",
+				Content:     "Valid content",
+				ContentType: run.ContentTypeText,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+
+	// Verify that only the non-empty message is included
+	assert.Len(t, req.AdditionalMessages, 2) // Original request still has 2 messages
+}
+
+func TestOpenapiAgentRun_ParseAdditionalMessages_NilMessage(t *testing.T) {
+	app, _, _, mockAgentRun, mockConversation, mockSingleAgent, _ := setupMocks(t)
+	ctx := createTestContext()
+
+	// Create request with empty content message (should be skipped)
+	req := &run.ChatV3Request{
+		BotID:          67890,
+		ConversationID: ptr.Of(int64(11111)),
+		User:           "test-user",
+		AdditionalMessages: []*run.EnterMessage{
+			{
+				Role:        "user",
+				Content:     "", // Empty content message
+				ContentType: run.ContentTypeText,
+			},
+			{
+				Role:        "user",
+				Content:     "Valid content",
+				ContentType: run.ContentTypeText,
+			},
+		},
+	}
+
+	// Mock agent check success
+	mockAgent := &saEntity.SingleAgent{
+		SingleAgent: &singleagent.SingleAgent{
+			AgentID: 67890,
+			SpaceID: 54321,
+		},
+	}
+	mockSingleAgent.EXPECT().ObtainAgentByIdentity(ctx, gomock.Any()).Return(mockAgent, nil)
+
+	// Mock conversation check success
+	mockConv := &convEntity.Conversation{
+		ID:        11111,
+		CreatorID: 12345,
+		SectionID: 98765,
+	}
+	mockConversation.EXPECT().GetByID(ctx, int64(11111)).Return(mockConv, nil)
+
+	// Mock agent run failure to avoid pullStream complexity
+	mockAgentRun.EXPECT().AgentRun(ctx, gomock.Any()).Return(nil, errors.New("mock stream error"))
+
+	err := app.OpenapiAgentRun(ctx, &sseImpl.SSenderImpl{}, req)
+
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "mock stream error")
+}

backend/crossdomain/contract/message/message.go

@@ -30,6 +30,7 @@ type Message interface {
 	GetByRunIDs(ctx context.Context, conversationID int64, runIDs []int64) ([]*message.Message, error)
 	PreCreate(ctx context.Context, msg *message.Message) (*message.Message, error)
 	Create(ctx context.Context, msg *message.Message) (*message.Message, error)
+	BatchCreate(ctx context.Context, msg []*message.Message) ([]*message.Message, error)
 	List(ctx context.Context, meta *entity.ListMeta) (*entity.ListResult, error)
 	ListWithoutPair(ctx context.Context, req *entity.ListMeta) (*entity.ListResult, error)
 	Edit(ctx context.Context, msg *message.Message) (*message.Message, error)

backend/crossdomain/contract/message/messagemock/message_mock.go

@@ -59,6 +59,21 @@ func (m *MockMessage) EXPECT() *MockMessageMockRecorder {
 	return m.recorder
 }
 
+// BatchCreate mocks base method.
+func (m *MockMessage) BatchCreate(ctx context.Context, msg []*message.Message) ([]*message.Message, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BatchCreate", ctx, msg)
+	ret0, _ := ret[0].([]*message.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// BatchCreate indicates an expected call of BatchCreate.
+func (mr *MockMessageMockRecorder) BatchCreate(ctx, msg any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchCreate", reflect.TypeOf((*MockMessage)(nil).BatchCreate), ctx, msg)
+}
+
 // Create mocks base method.
 func (m *MockMessage) Create(ctx context.Context, msg *message.Message) (*message.Message, error) {
 	m.ctrl.T.Helper()

backend/crossdomain/impl/message/message.go

@@ -170,6 +170,9 @@ func (c *impl) GetMessageByID(ctx context.Context, id int64) (*entity.Message, e
 func (c *impl) ListWithoutPair(ctx context.Context, req *entity.ListMeta) (*entity.ListResult, error) {
 	return c.DomainSVC.ListWithoutPair(ctx, req)
 }
+func (c *impl) BatchCreate(ctx context.Context, msgs []*entity.Message) ([]*entity.Message, error) {
+	return c.DomainSVC.BatchCreate(ctx, msgs)
+}
 
 func convertToConvAndSchemaMessage(ctx context.Context, msgs []*entity.Message) ([]*crossmessage.WfMessage, []*schema.Message, error) {
 	messages := make([]*schema.Message, 0)

backend/domain/agent/singleagent/service/single_agent.go

@@ -25,6 +25,7 @@ import (
 	"github.com/coze-dev/coze-studio/backend/domain/agent/singleagent/entity"
 )
 
+//go:generate mockgen -destination ../../../../internal/mock/domain/agent/singleagent/single_agent_mock.go --package singleagent -source single_agent.go
 type SingleAgent interface {
 	// draft agent
 	CreateSingleAgentDraft(ctx context.Context, creatorID int64, draft *entity.SingleAgent) (agentID int64, err error)

backend/domain/conversation/agentrun/entity/run_record.go

@@ -106,24 +106,34 @@ type MetaInfo struct {
 }
 
 type AgentRunMeta struct {
-	ConversationID   int64                    `json:"conversation_id"`
+	ConversationID     int64                    `json:"conversation_id"`
-	ConnectorID      int64                    `json:"connector_id"`
+	ConnectorID        int64                    `json:"connector_id"`
-	SpaceID          int64                    `json:"space_id"`
+	SpaceID            int64                    `json:"space_id"`
-	Scene            common.Scene             `json:"scene"`
+	Scene              common.Scene             `json:"scene"`
-	SectionID        int64                    `json:"section_id"`
+	SectionID          int64                    `json:"section_id"`
-	Name             string                   `json:"name"`
+	Name               string                   `json:"name"`
-	UserID           string                   `json:"user_id"`
+	UserID             string                   `json:"user_id"`
-	CozeUID          int64                    `json:"coze_uid"`
+	CozeUID            int64                    `json:"coze_uid"`
-	AgentID          int64                    `json:"agent_id"`
+	AgentID            int64                    `json:"agent_id"`
-	ContentType      message.ContentType      `json:"content_type"`
+	ContentType        message.ContentType      `json:"content_type"`
-	Content          []*message.InputMetaData `json:"content"`
+	Content            []*message.InputMetaData `json:"content"`
-	PreRetrieveTools []*Tool                  `json:"tools"`
+	PreRetrieveTools   []*Tool                  `json:"tools"`
-	IsDraft          bool                     `json:"is_draft"`
+	IsDraft            bool                     `json:"is_draft"`
-	CustomerConfig   *CustomerConfig          `json:"customer_config"`
+	CustomerConfig     *CustomerConfig          `json:"customer_config"`
-	DisplayContent   string                   `json:"display_content"`
+	DisplayContent     string                   `json:"display_content"`
-	CustomVariables  map[string]string        `json:"custom_variables"`
+	CustomVariables    map[string]string        `json:"custom_variables"`
-	Version          string                   `json:"version"`
+	Version            string                   `json:"version"`
-	Ext              map[string]string        `json:"ext"`
+	Ext                map[string]string        `json:"ext"`
+	AdditionalMessages []*AdditionalMessage     `json:"additional_messages"`
+}
+
+type AdditionalMessage struct {
+	Role        schema.RoleType          `json:"role"`
+	Type        message.MessageType      `json:"type"`
+	Content     []*message.InputMetaData `json:"content"`
+	ContentType message.ContentType      `json:"content_type"`
+	Name        *string                  `json:"name"`
+	Meta        map[string]string        `json:"meta"`
 }
 
 type UpdateMeta struct {

backend/domain/conversation/agentrun/internal/chatflow_run.go

@@ -41,7 +41,7 @@ import (
 
 func (art *AgentRuntime) ChatflowRun(ctx context.Context, imagex imagex.ImageX) (err error) {
 
-	mh := &MesssageEventHanlder{
+	mh := &MessageEventHandler{
 		sw:           art.SW,
 		messageEvent: art.MessageEvent,
 	}
@@ -110,7 +110,7 @@ func concatWfInput(rtDependence *AgentRuntime) string {
 	return strings.Trim(input, ",")
 }
 
-func (art *AgentRuntime) pullWfStream(ctx context.Context, events *schema.StreamReader[*crossworkflow.WorkflowMessage], mh *MesssageEventHanlder) {
+func (art *AgentRuntime) pullWfStream(ctx context.Context, events *schema.StreamReader[*crossworkflow.WorkflowMessage], mh *MessageEventHandler) {
 
 	fullAnswerContent := bytes.NewBuffer([]byte{})
 	var usage *msgEntity.UsageExt

backend/domain/conversation/agentrun/internal/message_builder.go

@@ -221,6 +221,51 @@ func preCreateAnswer(ctx context.Context, rtDependence *AgentRuntime) (*msgEntit
 	return crossmessage.DefaultSVC().PreCreate(ctx, msgMeta)
 }
 
+func buildAdditionalMessage2Create(ctx context.Context, runRecord *entity.RunRecordMeta, additionalMessage *entity.AdditionalMessage, userID string) *message.Message {
+
+	msg := &msgEntity.Message{
+		ConversationID: runRecord.ConversationID,
+		RunID:          runRecord.ID,
+		AgentID:        runRecord.AgentID,
+		SectionID:      runRecord.SectionID,
+		UserID:         userID,
+		MessageType:    additionalMessage.Type,
+	}
+
+	switch additionalMessage.Type {
+	case message.MessageTypeQuestion:
+		msg.Role = schema.User
+		msg.ContentType = additionalMessage.ContentType
+		for _, content := range additionalMessage.Content {
+			if content.Type == message.InputTypeText {
+				msg.Content = content.Text
+				break
+			}
+		}
+		msg.MultiContent = additionalMessage.Content
+
+	case message.MessageTypeAnswer:
+		msg.Role = schema.Assistant
+		msg.ContentType = message.ContentTypeText
+		for _, content := range additionalMessage.Content {
+			if content.Type == message.InputTypeText {
+				msg.Content = content.Text
+				break
+			}
+		}
+		modelContent := &schema.Message{
+			Role:    schema.Assistant,
+			Content: msg.Content,
+		}
+
+		jsonContent, err := json.Marshal(modelContent)
+		if err == nil {
+			msg.ModelContent = string(jsonContent)
+		}
+	}
+	return msg
+}
+
 func buildAgentMessage2Create(ctx context.Context, chunk *entity.AgentRespEvent, messageType message.MessageType, rtDependence *AgentRuntime) *message.Message {
 	arm := rtDependence.GetRunMeta()
 	msg := &msgEntity.Message{

backend/domain/conversation/agentrun/internal/message_event.go

@@ -98,12 +98,12 @@ func (e *Event) SendStreamDoneEvent(sw *schema.StreamWriter[*entity.AgentRunResp
 	sw.Send(resp, nil)
 }
 
-type MesssageEventHanlder struct {
+type MessageEventHandler struct {
 	messageEvent *Event
 	sw           *schema.StreamWriter[*entity.AgentRunResponse]
 }
 
-func (mh *MesssageEventHanlder) handlerErr(_ context.Context, err error) {
+func (mh *MessageEventHandler) handlerErr(_ context.Context, err error) {
 
 	var errMsg string
 	var statusErr errorx.StatusError
@@ -123,7 +123,7 @@ func (mh *MesssageEventHanlder) handlerErr(_ context.Context, err error) {
 	})
 }
 
-func (mh *MesssageEventHanlder) handlerAckMessage(_ context.Context, input *msgEntity.Message) error {
+func (mh *MessageEventHandler) handlerAckMessage(_ context.Context, input *msgEntity.Message) error {
 	sendMsg := &entity.ChunkMessageItem{
 		ID:             input.ID,
 		ConversationID: input.ConversationID,
@@ -142,7 +142,7 @@ func (mh *MesssageEventHanlder) handlerAckMessage(_ context.Context, input *msgE
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerFunctionCall(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
+func (mh *MessageEventHandler) handlerFunctionCall(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
 	cm := buildAgentMessage2Create(ctx, chunk, message.MessageTypeFunctionCall, rtDependence)
 
 	cmData, err := crossmessage.DefaultSVC().Create(ctx, cm)
@@ -156,7 +156,7 @@ func (mh *MesssageEventHanlder) handlerFunctionCall(ctx context.Context, chunk *
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerTooResponse(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime, preToolResponseMsg *msgEntity.Message, toolResponseMsgContent string) error {
+func (mh *MessageEventHandler) handlerTooResponse(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime, preToolResponseMsg *msgEntity.Message, toolResponseMsgContent string) error {
 
 	cm := buildAgentMessage2Create(ctx, chunk, message.MessageTypeToolResponse, rtDependence)
 
@@ -184,7 +184,7 @@ func (mh *MesssageEventHanlder) handlerTooResponse(ctx context.Context, chunk *e
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerSuggest(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
+func (mh *MessageEventHandler) handlerSuggest(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
 	cm := buildAgentMessage2Create(ctx, chunk, message.MessageTypeFlowUp, rtDependence)
 
 	cmData, err := crossmessage.DefaultSVC().Create(ctx, cm)
@@ -199,7 +199,7 @@ func (mh *MesssageEventHanlder) handlerSuggest(ctx context.Context, chunk *entit
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerKnowledge(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
+func (mh *MessageEventHandler) handlerKnowledge(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
 	cm := buildAgentMessage2Create(ctx, chunk, message.MessageTypeKnowledge, rtDependence)
 	cmData, err := crossmessage.DefaultSVC().Create(ctx, cm)
 	if err != nil {
@@ -212,7 +212,7 @@ func (mh *MesssageEventHanlder) handlerKnowledge(ctx context.Context, chunk *ent
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerAnswer(ctx context.Context, msg *entity.ChunkMessageItem, usage *msgEntity.UsageExt, rtDependence *AgentRuntime, preAnswerMsg *msgEntity.Message) error {
+func (mh *MessageEventHandler) handlerAnswer(ctx context.Context, msg *entity.ChunkMessageItem, usage *msgEntity.UsageExt, rtDependence *AgentRuntime, preAnswerMsg *msgEntity.Message) error {
 
 	if len(msg.Content) == 0 && len(ptr.From(msg.ReasoningContent)) == 0 {
 		return nil
@@ -265,7 +265,7 @@ func (mh *MesssageEventHanlder) handlerAnswer(ctx context.Context, msg *entity.C
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerFinalAnswerFinish(ctx context.Context, rtDependence *AgentRuntime) error {
+func (mh *MessageEventHandler) handlerFinalAnswerFinish(ctx context.Context, rtDependence *AgentRuntime) error {
 	cm := buildAgentMessage2Create(ctx, nil, message.MessageTypeVerbose, rtDependence)
 	cmData, err := crossmessage.DefaultSVC().Create(ctx, cm)
 	if err != nil {
@@ -278,7 +278,7 @@ func (mh *MesssageEventHanlder) handlerFinalAnswerFinish(ctx context.Context, rt
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerInterruptVerbose(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
+func (mh *MessageEventHandler) handlerInterruptVerbose(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime) error {
 	cm := buildAgentMessage2Create(ctx, chunk, message.MessageTypeInterrupt, rtDependence)
 	cmData, err := crossmessage.DefaultSVC().Create(ctx, cm)
 	if err != nil {
@@ -291,7 +291,7 @@ func (mh *MesssageEventHanlder) handlerInterruptVerbose(ctx context.Context, chu
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerWfUsage(ctx context.Context, msg *entity.ChunkMessageItem, usage *msgEntity.UsageExt) error {
+func (mh *MessageEventHandler) handlerWfUsage(ctx context.Context, msg *entity.ChunkMessageItem, usage *msgEntity.UsageExt) error {
 
 	if msg.Ext == nil {
 		msg.Ext = map[string]string{}
@@ -314,7 +314,7 @@ func (mh *MesssageEventHanlder) handlerWfUsage(ctx context.Context, msg *entity.
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerInterrupt(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime, firstAnswerMsg *msgEntity.Message, reasoningContent string) error {
+func (mh *MessageEventHandler) handlerInterrupt(ctx context.Context, chunk *entity.AgentRespEvent, rtDependence *AgentRuntime, firstAnswerMsg *msgEntity.Message, reasoningContent string) error {
 	interruptData, cType, err := parseInterruptData(ctx, chunk.Interrupt)
 	if err != nil {
 		return err
@@ -366,7 +366,7 @@ func (mh *MesssageEventHanlder) handlerInterrupt(ctx context.Context, chunk *ent
 	return nil
 }
 
-func (mh *MesssageEventHanlder) handlerWfInterruptMsg(ctx context.Context, stateMsg *crossworkflow.StateMessage, rtDependence *AgentRuntime) {
+func (mh *MessageEventHandler) handlerWfInterruptMsg(ctx context.Context, stateMsg *crossworkflow.StateMessage, rtDependence *AgentRuntime) {
 	interruptData, cType, err := handlerWfInterruptEvent(ctx, stateMsg.InterruptEvent)
 	if err != nil {
 		return
@@ -412,7 +412,7 @@ func (mh *MesssageEventHanlder) handlerWfInterruptMsg(ctx context.Context, state
 	}
 }
 
-func (mh *MesssageEventHanlder) HandlerInput(ctx context.Context, rtDependence *AgentRuntime) (*msgEntity.Message, error) {
+func (mh *MessageEventHandler) HandlerInput(ctx context.Context, rtDependence *AgentRuntime) (*msgEntity.Message, error) {
 	msgMeta := buildAgentMessage2Create(ctx, nil, message.MessageTypeQuestion, rtDependence)
 
 	cm, err := crossmessage.DefaultSVC().Create(ctx, msgMeta)
@@ -426,3 +426,21 @@ func (mh *MesssageEventHanlder) HandlerInput(ctx context.Context, rtDependence *
 	}
 	return cm, nil
 }
+
+func (mh *MessageEventHandler) ParseAdditionalMessages(ctx context.Context, rtDependence *AgentRuntime, runRecord *entity.RunRecordMeta) error {
+
+	if len(rtDependence.GetRunMeta().AdditionalMessages) == 0 {
+		return nil
+	}
+
+	additionalMessages := make([]*message.Message, 0, len(rtDependence.GetRunMeta().AdditionalMessages))
+
+	for _, msg := range rtDependence.GetRunMeta().AdditionalMessages {
+		cm := buildAdditionalMessage2Create(ctx, runRecord, msg, rtDependence.GetRunMeta().UserID)
+		additionalMessages = append(additionalMessages, cm)
+	}
+
+	_, err := crossmessage.DefaultSVC().BatchCreate(ctx, additionalMessages)
+
+	return err
+}

backend/domain/conversation/agentrun/internal/run.go

@@ -107,6 +107,11 @@ func (rd *AgentRuntime) GetHistory() []*msgEntity.Message {
 
 func (art *AgentRuntime) Run(ctx context.Context) (err error) {
 
+	mh := &MessageEventHandler{
+		messageEvent: art.MessageEvent,
+		sw:           art.SW,
+	}
+
 	agentInfo, err := getAgentInfo(ctx, art.GetRunMeta().AgentID, art.GetRunMeta().IsDraft, art.GetRunMeta().ConnectorID)
 	if err != nil {
 		return
@@ -114,6 +119,18 @@ func (art *AgentRuntime) Run(ctx context.Context) (err error) {
 
 	art.SetAgentInfo(agentInfo)
 
+	if len(art.GetRunMeta().AdditionalMessages) > 0 {
+		var additionalRunRecord *entity.RunRecordMeta
+		additionalRunRecord, err = art.RunRecordRepo.Create(ctx, art.GetRunMeta())
+		if err != nil {
+			return
+		}
+		err = mh.ParseAdditionalMessages(ctx, art, additionalRunRecord)
+		if err != nil {
+			return
+		}
+	}
+
 	history, err := art.getHistory(ctx)
 	if err != nil {
 		return
@@ -140,10 +157,7 @@ func (art *AgentRuntime) Run(ctx context.Context) (err error) {
 		}
 		art.RunProcess.StepToComplete(ctx, srRecord, art.SW, art.GetUsage())
 	}()
-	mh := &MesssageEventHanlder{
+
-		messageEvent: art.MessageEvent,
-		sw:           art.SW,
-	}
 	input, err := mh.HandlerInput(ctx, art)
 	if err != nil {
 		return

backend/domain/conversation/agentrun/internal/singleagent_run.go

@@ -80,7 +80,7 @@ func (art *AgentRuntime) AgentStreamExecute(ctx context.Context, imagex imagex.I
 
 func (art *AgentRuntime) push(ctx context.Context, mainChan chan *entity.AgentRespEvent) {
 
-	mh := &MesssageEventHanlder{
+	mh := &MessageEventHandler{
 		sw:           art.SW,
 		messageEvent: art.MessageEvent,
 	}

backend/domain/conversation/agentrun/service/agent_run.go

@@ -24,6 +24,7 @@ import (
 	"github.com/coze-dev/coze-studio/backend/domain/conversation/agentrun/entity"
 )
 
+//go:generate mockgen -destination ../../../../internal/mock/domain/conversation/agentrun/agent_run_mock.go --package agentrun -source agent_run.go
 type Run interface {
 	AgentRun(ctx context.Context, req *entity.AgentRunMeta) (*schema.StreamReader[*entity.AgentRunResponse], error)
 	Delete(ctx context.Context, runID []int64) error

backend/domain/conversation/conversation/service/conversation.go

@@ -22,6 +22,7 @@ import (
 	"github.com/coze-dev/coze-studio/backend/domain/conversation/conversation/entity"
 )
 
+//go:generate mockgen -destination ../../../../internal/mock/domain/conversation/conversation/conversation_mock.go --package conversation -source conversation.go
 type Conversation interface {
 	Create(ctx context.Context, req *entity.CreateMeta) (*entity.Conversation, error)
 	GetByID(ctx context.Context, id int64) (*entity.Conversation, error)

backend/domain/conversation/message/internal/dal/message.go

@@ -72,6 +72,25 @@ func (dao *MessageDAO) Create(ctx context.Context, msg *entity.Message) (*entity
 	return dao.messagePO2DO(poData), nil
 }
 
+func (dao *MessageDAO) BatchCreate(ctx context.Context, msg []*entity.Message) ([]*entity.Message, error) {
+	poList := make([]*model.Message, 0, len(msg))
+	for _, m := range msg {
+		po, err := dao.messageDO2PO(ctx, m)
+		if err != nil {
+			return nil, err
+		}
+		poList = append(poList, po)
+	}
+
+	do := dao.query.Message.WithContext(ctx).Debug()
+	cErr := do.CreateInBatches(poList, len(poList))
+	if cErr != nil {
+		return nil, cErr
+	}
+
+	return dao.batchMessagePO2DO(poList), nil
+}
+
 func (dao *MessageDAO) List(ctx context.Context, listMeta *entity.ListMeta) ([]*entity.Message, bool, error) {
 	m := dao.query.Message
 	do := m.WithContext(ctx).Debug().Where(m.ConversationID.Eq(listMeta.ConversationID)).Where(m.Status.Eq(int32(entity.MessageStatusAvailable)))

backend/domain/conversation/message/repository/repository.go

@@ -34,6 +34,7 @@ func NewMessageRepo(db *gorm.DB, idGen idgen.IDGenerator) MessageRepo {
 type MessageRepo interface {
 	PreCreate(ctx context.Context, msg *entity.Message) (*entity.Message, error)
 	Create(ctx context.Context, msg *entity.Message) (*entity.Message, error)
+	BatchCreate(ctx context.Context, msg []*entity.Message) ([]*entity.Message, error)
 	List(ctx context.Context, listMeta *entity.ListMeta) ([]*entity.Message, bool, error)
 	GetByRunIDs(ctx context.Context, runIDs []int64, orderBy string) ([]*entity.Message, error)
 	Edit(ctx context.Context, msgID int64, message *message.Message) (int64, error)

backend/domain/conversation/message/service/message.go

@@ -27,6 +27,7 @@ type Message interface {
 	ListWithoutPair(ctx context.Context, req *entity.ListMeta) (*entity.ListResult, error)
 	PreCreate(ctx context.Context, req *entity.Message) (*entity.Message, error)
 	Create(ctx context.Context, req *entity.Message) (*entity.Message, error)
+	BatchCreate(ctx context.Context, req []*entity.Message) ([]*entity.Message, error)
 	GetByRunIDs(ctx context.Context, conversationID int64, runIDs []int64) ([]*entity.Message, error)
 	GetByID(ctx context.Context, id int64) (*entity.Message, error)
 	Edit(ctx context.Context, req *entity.Message) (*entity.Message, error)

backend/domain/conversation/message/service/message_impl.go

@@ -124,6 +124,10 @@ func (m *messageImpl) GetByID(ctx context.Context, id int64) (*entity.Message, e
 	return m.MessageRepo.GetByID(ctx, id)
 }
 
+func (m *messageImpl) BatchCreate(ctx context.Context, req []*entity.Message) ([]*entity.Message, error) {
+	return m.MessageRepo.BatchCreate(ctx, req)
+}
+
 func (m *messageImpl) Broken(ctx context.Context, req *entity.BrokenMeta) error {
 
 	_, err := m.MessageRepo.Edit(ctx, req.ID, &message.Message{

backend/domain/conversation/message/service/message_test.go

@@ -494,3 +494,55 @@ func TestListWithoutPair(t *testing.T) {
 		assert.Equal(t, "Answer message", resp.Messages[0].Content)
 	})
 }
+
+func TestBatchCreate(t *testing.T) {
+	ctx := context.Background()
+	mockDBGen := orm.NewMockDB()
+	mockDBGen.AddTable(&model.Message{})
+	mockDB, err := mockDBGen.DB()
+	assert.NoError(t, err)
+
+	components := &Components{
+			MessageRepo: repository.NewMessageRepo(mockDB, nil),
+		}
+
+
+	t.Run("success_single_message", func(t *testing.T) {
+		ctrl := gomock.NewController(t)
+		defer ctrl.Finish()
+
+		// 准备测试数据
+		inputMsgs := []*entity.Message{
+			{
+				ID:             1,
+				ConversationID: 100,
+				RunID:          200,
+				AgentID:        300,
+				UserID:         "user123",
+				Content:        "Hello World",
+				Role:           schema.User,
+				ContentType:    message.ContentTypeText,
+				MessageType:    message.MessageTypeQuestion,
+				Status:         message.MessageStatusAvailable,
+			},
+			{
+				ID:             2,
+				ConversationID: 100,
+				RunID:          200,
+				AgentID:        300,
+				UserID:         "user123",
+				Content:        "Hello World",
+				Role:           schema.Assistant,
+				ContentType:    message.ContentTypeText,
+				MessageType:    message.MessageTypeQuestion,
+				Status:         message.MessageStatusAvailable,
+			},
+		}
+
+		result, err := NewService(components).BatchCreate(ctx, inputMsgs)
+
+		assert.NoError(t, err)
+		assert.Len(t, result, 2)
+		assert.Equal(t, inputMsgs[1].ID, result[1].ID)
+	})
+}

backend/domain/shortcutcmd/service/shortcut_cmd.go

@@ -22,6 +22,7 @@ import (
 	"github.com/coze-dev/coze-studio/backend/domain/shortcutcmd/entity"
 )
 
+//go:generate mockgen -destination ../../../internal/mock/domain/shortcutcmd/shortcut_cmd_mock.go --package shortcutcmd -source shortcut_cmd.go
 type ShortcutCmd interface {
 	ListCMD(ctx context.Context, lm *entity.ListMeta) ([]*entity.ShortcutCmd, error)
 	CreateCMD(ctx context.Context, shortcut *entity.ShortcutCmd) (*entity.ShortcutCmd, error)

backend/domain/upload/service/interface.go

@@ -22,6 +22,7 @@ import (
 	"github.com/coze-dev/coze-studio/backend/domain/upload/entity"
 )
 
+//go:generate mockgen -destination ../../../internal/mock/domain/upload/upload_service_mock.go --package upload -source interface.go
 type UploadService interface {
 	UploadFile(ctx context.Context, req *UploadFileRequest) (resp *UploadFileResponse, err error)
 	UploadFiles(ctx context.Context, req *UploadFilesRequest) (resp *UploadFilesResponse, err error)

backend/go.mod

@@ -289,5 +289,6 @@ require (
 	github.com/bahlo/generic-list-go v0.2.0 // indirect
 	github.com/buger/jsonparser v1.1.1 // indirect
 	github.com/eino-contrib/jsonschema v1.0.0 // indirect
+	github.com/stretchr/objx v0.5.2 // indirect
 	github.com/wk8/go-ordered-map/v2 v2.1.8 // indirect
 )

backend/internal/mock/domain/agent/singleagent/single_agent_mock.go

@@ -0,0 +1,355 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: domain/agent/singleagent/service/single_agent.go
+//
+// Generated by this command:
+//
+//	mockgen -destination internal/mock/domain/agent/singleagent/single_agent_mock.go --package mock -source domain/agent/singleagent/service/single_agent.go
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	schema "github.com/cloudwego/eino/schema"
+	playground "github.com/coze-dev/coze-studio/backend/api/model/playground"
+	entity "github.com/coze-dev/coze-studio/backend/domain/agent/singleagent/entity"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockSingleAgent is a mock of SingleAgent interface.
+type MockSingleAgent struct {
+	ctrl     *gomock.Controller
+	recorder *MockSingleAgentMockRecorder
+	isgomock struct{}
+}
+
+// MockSingleAgentMockRecorder is the mock recorder for MockSingleAgent.
+type MockSingleAgentMockRecorder struct {
+	mock *MockSingleAgent
+}
+
+// NewMockSingleAgent creates a new mock instance.
+func NewMockSingleAgent(ctrl *gomock.Controller) *MockSingleAgent {
+	mock := &MockSingleAgent{ctrl: ctrl}
+	mock.recorder = &MockSingleAgentMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockSingleAgent) EXPECT() *MockSingleAgentMockRecorder {
+	return m.recorder
+}
+
+// CreateSingleAgent mocks base method.
+func (m *MockSingleAgent) CreateSingleAgent(ctx context.Context, connectorID int64, version string, e *entity.SingleAgent) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSingleAgent", ctx, connectorID, version, e)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSingleAgent indicates an expected call of CreateSingleAgent.
+func (mr *MockSingleAgentMockRecorder) CreateSingleAgent(ctx, connectorID, version, e any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSingleAgent", reflect.TypeOf((*MockSingleAgent)(nil).CreateSingleAgent), ctx, connectorID, version, e)
+}
+
+// CreateSingleAgentDraft mocks base method.
+func (m *MockSingleAgent) CreateSingleAgentDraft(ctx context.Context, creatorID int64, draft *entity.SingleAgent) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSingleAgentDraft", ctx, creatorID, draft)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSingleAgentDraft indicates an expected call of CreateSingleAgentDraft.
+func (mr *MockSingleAgentMockRecorder) CreateSingleAgentDraft(ctx, creatorID, draft any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSingleAgentDraft", reflect.TypeOf((*MockSingleAgent)(nil).CreateSingleAgentDraft), ctx, creatorID, draft)
+}
+
+// CreateSingleAgentDraftWithID mocks base method.
+func (m *MockSingleAgent) CreateSingleAgentDraftWithID(ctx context.Context, creatorID, agentID int64, draft *entity.SingleAgent) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateSingleAgentDraftWithID", ctx, creatorID, agentID, draft)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateSingleAgentDraftWithID indicates an expected call of CreateSingleAgentDraftWithID.
+func (mr *MockSingleAgentMockRecorder) CreateSingleAgentDraftWithID(ctx, creatorID, agentID, draft any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateSingleAgentDraftWithID", reflect.TypeOf((*MockSingleAgent)(nil).CreateSingleAgentDraftWithID), ctx, creatorID, agentID, draft)
+}
+
+// DeleteAgentDraft mocks base method.
+func (m *MockSingleAgent) DeleteAgentDraft(ctx context.Context, spaceID, agentID int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteAgentDraft", ctx, spaceID, agentID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteAgentDraft indicates an expected call of DeleteAgentDraft.
+func (mr *MockSingleAgentMockRecorder) DeleteAgentDraft(ctx, spaceID, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAgentDraft", reflect.TypeOf((*MockSingleAgent)(nil).DeleteAgentDraft), ctx, spaceID, agentID)
+}
+
+// DuplicateInMemory mocks base method.
+func (m *MockSingleAgent) DuplicateInMemory(ctx context.Context, req *entity.DuplicateInfo) (*entity.SingleAgent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DuplicateInMemory", ctx, req)
+	ret0, _ := ret[0].(*entity.SingleAgent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DuplicateInMemory indicates an expected call of DuplicateInMemory.
+func (mr *MockSingleAgentMockRecorder) DuplicateInMemory(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateInMemory", reflect.TypeOf((*MockSingleAgent)(nil).DuplicateInMemory), ctx, req)
+}
+
+// GetAgentDraftDisplayInfo mocks base method.
+func (m *MockSingleAgent) GetAgentDraftDisplayInfo(ctx context.Context, userID, agentID int64) (*entity.AgentDraftDisplayInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAgentDraftDisplayInfo", ctx, userID, agentID)
+	ret0, _ := ret[0].(*entity.AgentDraftDisplayInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAgentDraftDisplayInfo indicates an expected call of GetAgentDraftDisplayInfo.
+func (mr *MockSingleAgentMockRecorder) GetAgentDraftDisplayInfo(ctx, userID, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentDraftDisplayInfo", reflect.TypeOf((*MockSingleAgent)(nil).GetAgentDraftDisplayInfo), ctx, userID, agentID)
+}
+
+// GetAgentPopupCount mocks base method.
+func (m *MockSingleAgent) GetAgentPopupCount(ctx context.Context, uid, agentID int64, agentPopupType playground.BotPopupType) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAgentPopupCount", ctx, uid, agentID, agentPopupType)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAgentPopupCount indicates an expected call of GetAgentPopupCount.
+func (mr *MockSingleAgentMockRecorder) GetAgentPopupCount(ctx, uid, agentID, agentPopupType any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentPopupCount", reflect.TypeOf((*MockSingleAgent)(nil).GetAgentPopupCount), ctx, uid, agentID, agentPopupType)
+}
+
+// GetPublishConnectorList mocks base method.
+func (m *MockSingleAgent) GetPublishConnectorList(ctx context.Context, agentID int64) (*entity.PublishConnectorData, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPublishConnectorList", ctx, agentID)
+	ret0, _ := ret[0].(*entity.PublishConnectorData)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPublishConnectorList indicates an expected call of GetPublishConnectorList.
+func (mr *MockSingleAgentMockRecorder) GetPublishConnectorList(ctx, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublishConnectorList", reflect.TypeOf((*MockSingleAgent)(nil).GetPublishConnectorList), ctx, agentID)
+}
+
+// GetPublishedInfo mocks base method.
+func (m *MockSingleAgent) GetPublishedInfo(ctx context.Context, agentID int64) (*entity.PublishInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPublishedInfo", ctx, agentID)
+	ret0, _ := ret[0].(*entity.PublishInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPublishedInfo indicates an expected call of GetPublishedInfo.
+func (mr *MockSingleAgentMockRecorder) GetPublishedInfo(ctx, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublishedInfo", reflect.TypeOf((*MockSingleAgent)(nil).GetPublishedInfo), ctx, agentID)
+}
+
+// GetPublishedTime mocks base method.
+func (m *MockSingleAgent) GetPublishedTime(ctx context.Context, agentID int64) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPublishedTime", ctx, agentID)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPublishedTime indicates an expected call of GetPublishedTime.
+func (mr *MockSingleAgentMockRecorder) GetPublishedTime(ctx, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPublishedTime", reflect.TypeOf((*MockSingleAgent)(nil).GetPublishedTime), ctx, agentID)
+}
+
+// GetSingleAgent mocks base method.
+func (m *MockSingleAgent) GetSingleAgent(ctx context.Context, agentID int64, version string) (*entity.SingleAgent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSingleAgent", ctx, agentID, version)
+	ret0, _ := ret[0].(*entity.SingleAgent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSingleAgent indicates an expected call of GetSingleAgent.
+func (mr *MockSingleAgentMockRecorder) GetSingleAgent(ctx, agentID, version any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSingleAgent", reflect.TypeOf((*MockSingleAgent)(nil).GetSingleAgent), ctx, agentID, version)
+}
+
+// GetSingleAgentDraft mocks base method.
+func (m *MockSingleAgent) GetSingleAgentDraft(ctx context.Context, agentID int64) (*entity.SingleAgent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetSingleAgentDraft", ctx, agentID)
+	ret0, _ := ret[0].(*entity.SingleAgent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetSingleAgentDraft indicates an expected call of GetSingleAgentDraft.
+func (mr *MockSingleAgentMockRecorder) GetSingleAgentDraft(ctx, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetSingleAgentDraft", reflect.TypeOf((*MockSingleAgent)(nil).GetSingleAgentDraft), ctx, agentID)
+}
+
+// IncrAgentPopupCount mocks base method.
+func (m *MockSingleAgent) IncrAgentPopupCount(ctx context.Context, uid, agentID int64, agentPopupType playground.BotPopupType) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "IncrAgentPopupCount", ctx, uid, agentID, agentPopupType)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// IncrAgentPopupCount indicates an expected call of IncrAgentPopupCount.
+func (mr *MockSingleAgentMockRecorder) IncrAgentPopupCount(ctx, uid, agentID, agentPopupType any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IncrAgentPopupCount", reflect.TypeOf((*MockSingleAgent)(nil).IncrAgentPopupCount), ctx, uid, agentID, agentPopupType)
+}
+
+// ListAgentPublishHistory mocks base method.
+func (m *MockSingleAgent) ListAgentPublishHistory(ctx context.Context, agentID int64, pageIndex, pageSize int32, connectorID *int64) ([]*entity.SingleAgentPublish, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListAgentPublishHistory", ctx, agentID, pageIndex, pageSize, connectorID)
+	ret0, _ := ret[0].([]*entity.SingleAgentPublish)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListAgentPublishHistory indicates an expected call of ListAgentPublishHistory.
+func (mr *MockSingleAgentMockRecorder) ListAgentPublishHistory(ctx, agentID, pageIndex, pageSize, connectorID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListAgentPublishHistory", reflect.TypeOf((*MockSingleAgent)(nil).ListAgentPublishHistory), ctx, agentID, pageIndex, pageSize, connectorID)
+}
+
+// MGetSingleAgentDraft mocks base method.
+func (m *MockSingleAgent) MGetSingleAgentDraft(ctx context.Context, agentIDs []int64) ([]*entity.SingleAgent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetSingleAgentDraft", ctx, agentIDs)
+	ret0, _ := ret[0].([]*entity.SingleAgent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetSingleAgentDraft indicates an expected call of MGetSingleAgentDraft.
+func (mr *MockSingleAgentMockRecorder) MGetSingleAgentDraft(ctx, agentIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetSingleAgentDraft", reflect.TypeOf((*MockSingleAgent)(nil).MGetSingleAgentDraft), ctx, agentIDs)
+}
+
+// ObtainAgentByIdentity mocks base method.
+func (m *MockSingleAgent) ObtainAgentByIdentity(ctx context.Context, identity *entity.AgentIdentity) (*entity.SingleAgent, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ObtainAgentByIdentity", ctx, identity)
+	ret0, _ := ret[0].(*entity.SingleAgent)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ObtainAgentByIdentity indicates an expected call of ObtainAgentByIdentity.
+func (mr *MockSingleAgentMockRecorder) ObtainAgentByIdentity(ctx, identity any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ObtainAgentByIdentity", reflect.TypeOf((*MockSingleAgent)(nil).ObtainAgentByIdentity), ctx, identity)
+}
+
+// SavePublishRecord mocks base method.
+func (m *MockSingleAgent) SavePublishRecord(ctx context.Context, p *entity.SingleAgentPublish, e *entity.SingleAgent) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SavePublishRecord", ctx, p, e)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SavePublishRecord indicates an expected call of SavePublishRecord.
+func (mr *MockSingleAgentMockRecorder) SavePublishRecord(ctx, p, e any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SavePublishRecord", reflect.TypeOf((*MockSingleAgent)(nil).SavePublishRecord), ctx, p, e)
+}
+
+// StreamExecute mocks base method.
+func (m *MockSingleAgent) StreamExecute(ctx context.Context, req *entity.ExecuteRequest) (*schema.StreamReader[*entity.AgentEvent], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "StreamExecute", ctx, req)
+	ret0, _ := ret[0].(*schema.StreamReader[*entity.AgentEvent])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// StreamExecute indicates an expected call of StreamExecute.
+func (mr *MockSingleAgentMockRecorder) StreamExecute(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StreamExecute", reflect.TypeOf((*MockSingleAgent)(nil).StreamExecute), ctx, req)
+}
+
+// UpdateAgentDraftDisplayInfo mocks base method.
+func (m *MockSingleAgent) UpdateAgentDraftDisplayInfo(ctx context.Context, userID int64, e *entity.AgentDraftDisplayInfo) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateAgentDraftDisplayInfo", ctx, userID, e)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateAgentDraftDisplayInfo indicates an expected call of UpdateAgentDraftDisplayInfo.
+func (mr *MockSingleAgentMockRecorder) UpdateAgentDraftDisplayInfo(ctx, userID, e any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateAgentDraftDisplayInfo", reflect.TypeOf((*MockSingleAgent)(nil).UpdateAgentDraftDisplayInfo), ctx, userID, e)
+}
+
+// UpdateSingleAgentDraft mocks base method.
+func (m *MockSingleAgent) UpdateSingleAgentDraft(ctx context.Context, agentInfo *entity.SingleAgent) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateSingleAgentDraft", ctx, agentInfo)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateSingleAgentDraft indicates an expected call of UpdateSingleAgentDraft.
+func (mr *MockSingleAgentMockRecorder) UpdateSingleAgentDraft(ctx, agentInfo any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateSingleAgentDraft", reflect.TypeOf((*MockSingleAgent)(nil).UpdateSingleAgentDraft), ctx, agentInfo)
+}

backend/internal/mock/domain/conversation/agentrun/agent_run_mock.go

@@ -0,0 +1,148 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: domain/conversation/agentrun/service/agent_run.go
+//
+// Generated by this command:
+//
+//	mockgen -destination internal/mock/domain/conversation/agentrun/agent_run_mock.go --package mock_agentrun -source domain/conversation/agentrun/service/agent_run.go
+//
+
+// Package mock_agentrun is a generated GoMock package.
+package mock_agentrun
+
+import (
+	context "context"
+	reflect "reflect"
+
+	schema "github.com/cloudwego/eino/schema"
+	entity "github.com/coze-dev/coze-studio/backend/domain/conversation/agentrun/entity"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockRun is a mock of Run interface.
+type MockRun struct {
+	ctrl     *gomock.Controller
+	recorder *MockRunMockRecorder
+	isgomock struct{}
+}
+
+// MockRunMockRecorder is the mock recorder for MockRun.
+type MockRunMockRecorder struct {
+	mock *MockRun
+}
+
+// NewMockRun creates a new mock instance.
+func NewMockRun(ctrl *gomock.Controller) *MockRun {
+	mock := &MockRun{ctrl: ctrl}
+	mock.recorder = &MockRunMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRun) EXPECT() *MockRunMockRecorder {
+	return m.recorder
+}
+
+// AgentRun mocks base method.
+func (m *MockRun) AgentRun(ctx context.Context, req *entity.AgentRunMeta) (*schema.StreamReader[*entity.AgentRunResponse], error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AgentRun", ctx, req)
+	ret0, _ := ret[0].(*schema.StreamReader[*entity.AgentRunResponse])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AgentRun indicates an expected call of AgentRun.
+func (mr *MockRunMockRecorder) AgentRun(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AgentRun", reflect.TypeOf((*MockRun)(nil).AgentRun), ctx, req)
+}
+
+// Cancel mocks base method.
+func (m *MockRun) Cancel(ctx context.Context, req *entity.CancelRunMeta) (*entity.RunRecordMeta, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Cancel", ctx, req)
+	ret0, _ := ret[0].(*entity.RunRecordMeta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Cancel indicates an expected call of Cancel.
+func (mr *MockRunMockRecorder) Cancel(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Cancel", reflect.TypeOf((*MockRun)(nil).Cancel), ctx, req)
+}
+
+// Create mocks base method.
+func (m *MockRun) Create(ctx context.Context, runRecord *entity.AgentRunMeta) (*entity.RunRecordMeta, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", ctx, runRecord)
+	ret0, _ := ret[0].(*entity.RunRecordMeta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create.
+func (mr *MockRunMockRecorder) Create(ctx, runRecord any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockRun)(nil).Create), ctx, runRecord)
+}
+
+// Delete mocks base method.
+func (m *MockRun) Delete(ctx context.Context, runID []int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", ctx, runID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete.
+func (mr *MockRunMockRecorder) Delete(ctx, runID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockRun)(nil).Delete), ctx, runID)
+}
+
+// GetByID mocks base method.
+func (m *MockRun) GetByID(ctx context.Context, runID int64) (*entity.RunRecordMeta, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetByID", ctx, runID)
+	ret0, _ := ret[0].(*entity.RunRecordMeta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetByID indicates an expected call of GetByID.
+func (mr *MockRunMockRecorder) GetByID(ctx, runID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockRun)(nil).GetByID), ctx, runID)
+}
+
+// List mocks base method.
+func (m *MockRun) List(ctx context.Context, ListMeta *entity.ListRunRecordMeta) ([]*entity.RunRecordMeta, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", ctx, ListMeta)
+	ret0, _ := ret[0].([]*entity.RunRecordMeta)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// List indicates an expected call of List.
+func (mr *MockRunMockRecorder) List(ctx, ListMeta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockRun)(nil).List), ctx, ListMeta)
+}

backend/internal/mock/domain/conversation/conversation/conversation_mock.go

@@ -0,0 +1,163 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: domain/conversation/conversation/service/conversation.go
+//
+// Generated by this command:
+//
+//	mockgen -destination internal/mock/domain/conversation/conversation/conversation_mock.go --package mock_conversation -source domain/conversation/conversation/service/conversation.go
+//
+
+// Package mock_conversation is a generated GoMock package.
+package mock_conversation
+
+import (
+	context "context"
+	reflect "reflect"
+
+	entity "github.com/coze-dev/coze-studio/backend/domain/conversation/conversation/entity"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockConversation is a mock of Conversation interface.
+type MockConversation struct {
+	ctrl     *gomock.Controller
+	recorder *MockConversationMockRecorder
+	isgomock struct{}
+}
+
+// MockConversationMockRecorder is the mock recorder for MockConversation.
+type MockConversationMockRecorder struct {
+	mock *MockConversation
+}
+
+// NewMockConversation creates a new mock instance.
+func NewMockConversation(ctrl *gomock.Controller) *MockConversation {
+	mock := &MockConversation{ctrl: ctrl}
+	mock.recorder = &MockConversationMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConversation) EXPECT() *MockConversationMockRecorder {
+	return m.recorder
+}
+
+// Create mocks base method.
+func (m *MockConversation) Create(ctx context.Context, req *entity.CreateMeta) (*entity.Conversation, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Create", ctx, req)
+	ret0, _ := ret[0].(*entity.Conversation)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Create indicates an expected call of Create.
+func (mr *MockConversationMockRecorder) Create(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Create", reflect.TypeOf((*MockConversation)(nil).Create), ctx, req)
+}
+
+// Delete mocks base method.
+func (m *MockConversation) Delete(ctx context.Context, id int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Delete", ctx, id)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Delete indicates an expected call of Delete.
+func (mr *MockConversationMockRecorder) Delete(ctx, id any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockConversation)(nil).Delete), ctx, id)
+}
+
+// GetByID mocks base method.
+func (m *MockConversation) GetByID(ctx context.Context, id int64) (*entity.Conversation, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetByID", ctx, id)
+	ret0, _ := ret[0].(*entity.Conversation)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetByID indicates an expected call of GetByID.
+func (mr *MockConversationMockRecorder) GetByID(ctx, id any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByID", reflect.TypeOf((*MockConversation)(nil).GetByID), ctx, id)
+}
+
+// GetCurrentConversation mocks base method.
+func (m *MockConversation) GetCurrentConversation(ctx context.Context, req *entity.GetCurrent) (*entity.Conversation, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetCurrentConversation", ctx, req)
+	ret0, _ := ret[0].(*entity.Conversation)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetCurrentConversation indicates an expected call of GetCurrentConversation.
+func (mr *MockConversationMockRecorder) GetCurrentConversation(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentConversation", reflect.TypeOf((*MockConversation)(nil).GetCurrentConversation), ctx, req)
+}
+
+// List mocks base method.
+func (m *MockConversation) List(ctx context.Context, req *entity.ListMeta) ([]*entity.Conversation, bool, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "List", ctx, req)
+	ret0, _ := ret[0].([]*entity.Conversation)
+	ret1, _ := ret[1].(bool)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// List indicates an expected call of List.
+func (mr *MockConversationMockRecorder) List(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "List", reflect.TypeOf((*MockConversation)(nil).List), ctx, req)
+}
+
+// NewConversationCtx mocks base method.
+func (m *MockConversation) NewConversationCtx(ctx context.Context, req *entity.NewConversationCtxRequest) (*entity.NewConversationCtxResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "NewConversationCtx", ctx, req)
+	ret0, _ := ret[0].(*entity.NewConversationCtxResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// NewConversationCtx indicates an expected call of NewConversationCtx.
+func (mr *MockConversationMockRecorder) NewConversationCtx(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewConversationCtx", reflect.TypeOf((*MockConversation)(nil).NewConversationCtx), ctx, req)
+}
+
+// Update mocks base method.
+func (m *MockConversation) Update(ctx context.Context, req *entity.UpdateMeta) (*entity.Conversation, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Update", ctx, req)
+	ret0, _ := ret[0].(*entity.Conversation)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Update indicates an expected call of Update.
+func (mr *MockConversationMockRecorder) Update(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Update", reflect.TypeOf((*MockConversation)(nil).Update), ctx, req)
+}

backend/internal/mock/domain/shortcutcmd/shortcut_cmd_mock.go

@@ -0,0 +1,132 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: domain/shortcutcmd/service/shortcut_cmd.go
+//
+// Generated by this command:
+//
+//	mockgen -destination internal/mock/domain/shortcutcmd/shortcut_cmd_mock.go --package mock_shortcutcmd -source domain/shortcutcmd/service/shortcut_cmd.go
+//
+
+// Package mock_shortcutcmd is a generated GoMock package.
+package mock_shortcutcmd
+
+import (
+	context "context"
+	reflect "reflect"
+
+	entity "github.com/coze-dev/coze-studio/backend/domain/shortcutcmd/entity"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockShortcutCmd is a mock of ShortcutCmd interface.
+type MockShortcutCmd struct {
+	ctrl     *gomock.Controller
+	recorder *MockShortcutCmdMockRecorder
+	isgomock struct{}
+}
+
+// MockShortcutCmdMockRecorder is the mock recorder for MockShortcutCmd.
+type MockShortcutCmdMockRecorder struct {
+	mock *MockShortcutCmd
+}
+
+// NewMockShortcutCmd creates a new mock instance.
+func NewMockShortcutCmd(ctrl *gomock.Controller) *MockShortcutCmd {
+	mock := &MockShortcutCmd{ctrl: ctrl}
+	mock.recorder = &MockShortcutCmdMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockShortcutCmd) EXPECT() *MockShortcutCmdMockRecorder {
+	return m.recorder
+}
+
+// CreateCMD mocks base method.
+func (m *MockShortcutCmd) CreateCMD(ctx context.Context, shortcut *entity.ShortcutCmd) (*entity.ShortcutCmd, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateCMD", ctx, shortcut)
+	ret0, _ := ret[0].(*entity.ShortcutCmd)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateCMD indicates an expected call of CreateCMD.
+func (mr *MockShortcutCmdMockRecorder) CreateCMD(ctx, shortcut any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateCMD", reflect.TypeOf((*MockShortcutCmd)(nil).CreateCMD), ctx, shortcut)
+}
+
+// GetByCmdID mocks base method.
+func (m *MockShortcutCmd) GetByCmdID(ctx context.Context, cmdID int64, isOnline int32) (*entity.ShortcutCmd, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetByCmdID", ctx, cmdID, isOnline)
+	ret0, _ := ret[0].(*entity.ShortcutCmd)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetByCmdID indicates an expected call of GetByCmdID.
+func (mr *MockShortcutCmdMockRecorder) GetByCmdID(ctx, cmdID, isOnline any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetByCmdID", reflect.TypeOf((*MockShortcutCmd)(nil).GetByCmdID), ctx, cmdID, isOnline)
+}
+
+// ListCMD mocks base method.
+func (m *MockShortcutCmd) ListCMD(ctx context.Context, lm *entity.ListMeta) ([]*entity.ShortcutCmd, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListCMD", ctx, lm)
+	ret0, _ := ret[0].([]*entity.ShortcutCmd)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListCMD indicates an expected call of ListCMD.
+func (mr *MockShortcutCmdMockRecorder) ListCMD(ctx, lm any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCMD", reflect.TypeOf((*MockShortcutCmd)(nil).ListCMD), ctx, lm)
+}
+
+// PublishCMDs mocks base method.
+func (m *MockShortcutCmd) PublishCMDs(ctx context.Context, objID int64, cmdIDs []int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishCMDs", ctx, objID, cmdIDs)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PublishCMDs indicates an expected call of PublishCMDs.
+func (mr *MockShortcutCmdMockRecorder) PublishCMDs(ctx, objID, cmdIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishCMDs", reflect.TypeOf((*MockShortcutCmd)(nil).PublishCMDs), ctx, objID, cmdIDs)
+}
+
+// UpdateCMD mocks base method.
+func (m *MockShortcutCmd) UpdateCMD(ctx context.Context, shortcut *entity.ShortcutCmd) (*entity.ShortcutCmd, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateCMD", ctx, shortcut)
+	ret0, _ := ret[0].(*entity.ShortcutCmd)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateCMD indicates an expected call of UpdateCMD.
+func (mr *MockShortcutCmdMockRecorder) UpdateCMD(ctx, shortcut any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateCMD", reflect.TypeOf((*MockShortcutCmd)(nil).UpdateCMD), ctx, shortcut)
+}

backend/internal/mock/domain/upload/upload_service_mock.go

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2025 coze-dev Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Code generated by MockGen. DO NOT EDIT.
+// Source: domain/upload/service/interface.go
+//
+// Generated by this command:
+//
+//	mockgen -destination internal/mock/domain/upload/upload_service_mock.go --package mock_upload -source domain/upload/service/interface.go UploadService
+//
+
+// Package mock_upload is a generated GoMock package.
+package mock_upload
+
+import (
+	context "context"
+	reflect "reflect"
+
+	service "github.com/coze-dev/coze-studio/backend/domain/upload/service"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockUploadService is a mock of UploadService interface.
+type MockUploadService struct {
+	ctrl     *gomock.Controller
+	recorder *MockUploadServiceMockRecorder
+	isgomock struct{}
+}
+
+// MockUploadServiceMockRecorder is the mock recorder for MockUploadService.
+type MockUploadServiceMockRecorder struct {
+	mock *MockUploadService
+}
+
+// NewMockUploadService creates a new mock instance.
+func NewMockUploadService(ctrl *gomock.Controller) *MockUploadService {
+	mock := &MockUploadService{ctrl: ctrl}
+	mock.recorder = &MockUploadServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockUploadService) EXPECT() *MockUploadServiceMockRecorder {
+	return m.recorder
+}
+
+// GetFile mocks base method.
+func (m *MockUploadService) GetFile(ctx context.Context, req *service.GetFileRequest) (*service.GetFileResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFile", ctx, req)
+	ret0, _ := ret[0].(*service.GetFileResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFile indicates an expected call of GetFile.
+func (mr *MockUploadServiceMockRecorder) GetFile(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFile", reflect.TypeOf((*MockUploadService)(nil).GetFile), ctx, req)
+}
+
+// GetFiles mocks base method.
+func (m *MockUploadService) GetFiles(ctx context.Context, req *service.GetFilesRequest) (*service.GetFilesResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetFiles", ctx, req)
+	ret0, _ := ret[0].(*service.GetFilesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetFiles indicates an expected call of GetFiles.
+func (mr *MockUploadServiceMockRecorder) GetFiles(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetFiles", reflect.TypeOf((*MockUploadService)(nil).GetFiles), ctx, req)
+}
+
+// UploadFile mocks base method.
+func (m *MockUploadService) UploadFile(ctx context.Context, req *service.UploadFileRequest) (*service.UploadFileResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UploadFile", ctx, req)
+	ret0, _ := ret[0].(*service.UploadFileResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UploadFile indicates an expected call of UploadFile.
+func (mr *MockUploadServiceMockRecorder) UploadFile(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadFile", reflect.TypeOf((*MockUploadService)(nil).UploadFile), ctx, req)
+}
+
+// UploadFiles mocks base method.
+func (m *MockUploadService) UploadFiles(ctx context.Context, req *service.UploadFilesRequest) (*service.UploadFilesResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UploadFiles", ctx, req)
+	ret0, _ := ret[0].(*service.UploadFilesResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UploadFiles indicates an expected call of UploadFiles.
+func (mr *MockUploadServiceMockRecorder) UploadFiles(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UploadFiles", reflect.TypeOf((*MockUploadService)(nil).UploadFiles), ctx, req)
+}