feat: manually mirror opencoze's code from bytedance

Change-Id: I09a73aadda978ad9511264a756b2ce51f5761adf

backend/internal/mock/crossdomain/crossuser/crossuser.go

@@ -0,0 +1,58 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: crossuser.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/crossdomain/crossuser/crossuser.go --package mockCrossUser -source crossuser.go
+//
+
+// Package mockCrossUser is a generated GoMock package.
+package mockCrossUser
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+
+	crossuser "github.com/coze-dev/coze-studio/backend/crossdomain/contract/crossuser"
+)
+
+// MockUser is a mock of User interface.
+type MockUser struct {
+	ctrl     *gomock.Controller
+	recorder *MockUserMockRecorder
+	isgomock struct{}
+}
+
+// MockUserMockRecorder is the mock recorder for MockUser.
+type MockUserMockRecorder struct {
+	mock *MockUser
+}
+
+// NewMockUser creates a new mock instance.
+func NewMockUser(ctrl *gomock.Controller) *MockUser {
+	mock := &MockUser{ctrl: ctrl}
+	mock.recorder = &MockUserMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockUser) EXPECT() *MockUserMockRecorder {
+	return m.recorder
+}
+
+// GetUserSpaceList mocks base method.
+func (m *MockUser) GetUserSpaceList(ctx context.Context, userID int64) ([]*crossuser.EntitySpace, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUserSpaceList", ctx, userID)
+	ret0, _ := ret[0].([]*crossuser.EntitySpace)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUserSpaceList indicates an expected call of GetUserSpaceList.
+func (mr *MockUserMockRecorder) GetUserSpaceList(ctx, userID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUserSpaceList", reflect.TypeOf((*MockUser)(nil).GetUserSpaceList), ctx, userID)
+}

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

@@ -0,0 +1,71 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: database.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../../internal/mock/domain/agent/singleagent/database_service_mock.go --package mock -source database.go
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	service "github.com/coze-dev/coze-studio/backend/domain/memory/database/service"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockDatabase is a mock of Database interface.
+type MockDatabase struct {
+	ctrl     *gomock.Controller
+	recorder *MockDatabaseMockRecorder
+}
+
+// MockDatabaseMockRecorder is the mock recorder for MockDatabase.
+type MockDatabaseMockRecorder struct {
+	mock *MockDatabase
+}
+
+// NewMockDatabase creates a new mock instance.
+func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase {
+	mock := &MockDatabase{ctrl: ctrl}
+	mock.recorder = &MockDatabaseMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDatabase) EXPECT() *MockDatabaseMockRecorder {
+	return m.recorder
+}
+
+// ExecuteSQL mocks base method.
+func (m *MockDatabase) ExecuteSQL(ctx context.Context, req *service.ExecuteSQLRequest) (*service.ExecuteSQLResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteSQL", ctx, req)
+	ret0, _ := ret[0].(*service.ExecuteSQLResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteSQL indicates an expected call of ExecuteSQL.
+func (mr *MockDatabaseMockRecorder) ExecuteSQL(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteSQL", reflect.TypeOf((*MockDatabase)(nil).ExecuteSQL), ctx, req)
+}
+
+// PublishDatabase mocks base method.
+func (m *MockDatabase) PublishDatabase(ctx context.Context, req *service.PublishDatabaseRequest) (*service.PublishDatabaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishDatabase", ctx, req)
+	ret0, _ := ret[0].(*service.PublishDatabaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishDatabase indicates an expected call of PublishDatabase.
+func (mr *MockDatabaseMockRecorder) PublishDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishDatabase", reflect.TypeOf((*MockDatabase)(nil).PublishDatabase), ctx, req)
+}

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

@@ -0,0 +1,73 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: knowledge.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../../internal/mock/domain/agent/singleagent/knowledge_mock.go --package mock -source knowledge.go
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	knowledge "github.com/coze-dev/coze-studio/backend/domain/knowledge/service"
+
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockKnowledge is a mock of Knowledge interface.
+type MockKnowledge struct {
+	ctrl     *gomock.Controller
+	recorder *MockKnowledgeMockRecorder
+	isgomock struct{}
+}
+
+// MockKnowledgeMockRecorder is the mock recorder for MockKnowledge.
+type MockKnowledgeMockRecorder struct {
+	mock *MockKnowledge
+}
+
+// NewMockKnowledge creates a new mock instance.
+func NewMockKnowledge(ctrl *gomock.Controller) *MockKnowledge {
+	mock := &MockKnowledge{ctrl: ctrl}
+	mock.recorder = &MockKnowledgeMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockKnowledge) EXPECT() *MockKnowledgeMockRecorder {
+	return m.recorder
+}
+
+// ListKnowledge mocks base method.
+func (m *MockKnowledge) ListKnowledge(ctx context.Context, request *knowledge.ListKnowledgeRequest) (*knowledge.ListKnowledgeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListKnowledge", ctx, request)
+	ret0, _ := ret[0].(*knowledge.ListKnowledgeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListKnowledge indicates an expected call of ListKnowledge.
+func (mr *MockKnowledgeMockRecorder) ListKnowledge(ctx, request any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListKnowledge", reflect.TypeOf((*MockKnowledge)(nil).ListKnowledge), ctx, request)
+}
+
+// Retrieve mocks base method.
+func (m *MockKnowledge) Retrieve(ctx context.Context, req *knowledge.RetrieveRequest) (*knowledge.RetrieveResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Retrieve", ctx, req)
+	ret0, _ := ret[0].(*knowledge.RetrieveResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Retrieve indicates an expected call of Retrieve.
+func (mr *MockKnowledgeMockRecorder) Retrieve(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Retrieve", reflect.TypeOf((*MockKnowledge)(nil).Retrieve), ctx, req)
+}

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

@@ -0,0 +1,59 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: model_manager.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../../internal/mock/domain/agent/singleagent/model_mgr_mock.go --package mock -source model_manager.go
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+
+	modelmgr "github.com/coze-dev/coze-studio/backend/domain/modelmgr"
+	entity "github.com/coze-dev/coze-studio/backend/domain/modelmgr/entity"
+)
+
+// MockModelMgr is a mock of ModelMgr interface.
+type MockModelMgr struct {
+	ctrl     *gomock.Controller
+	recorder *MockModelMgrMockRecorder
+	isgomock struct{}
+}
+
+// MockModelMgrMockRecorder is the mock recorder for MockModelMgr.
+type MockModelMgrMockRecorder struct {
+	mock *MockModelMgr
+}
+
+// NewMockModelMgr creates a new mock instance.
+func NewMockModelMgr(ctrl *gomock.Controller) *MockModelMgr {
+	mock := &MockModelMgr{ctrl: ctrl}
+	mock.recorder = &MockModelMgrMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockModelMgr) EXPECT() *MockModelMgrMockRecorder {
+	return m.recorder
+}
+
+// MGetModelByID mocks base method.
+func (m *MockModelMgr) MGetModelByID(ctx context.Context, req *modelmgr.MGetModelRequest) ([]*entity.Model, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetModelByID", ctx, req)
+	ret0, _ := ret[0].([]*entity.Model)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetModelByID indicates an expected call of MGetModelByID.
+func (mr *MockModelMgrMockRecorder) MGetModelByID(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetModelByID", reflect.TypeOf((*MockModelMgr)(nil).MGetModelByID), ctx, req)
+}

backend/internal/mock/domain/memory/database/crossdomain/search.go

@@ -0,0 +1,56 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: search.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../../internal/mock/domain/memory/database/crossdomain/search.go --package database -source search.go
+//
+
+// Package database is a generated GoMock package.
+package database
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+
+	entity "github.com/coze-dev/coze-studio/backend/domain/search/entity"
+)
+
+// MockResourceDomainNotifier is a mock of ResourceDomainNotifier interface.
+type MockResourceDomainNotifier struct {
+	ctrl     *gomock.Controller
+	recorder *MockResourceDomainNotifierMockRecorder
+}
+
+// MockResourceDomainNotifierMockRecorder is the mock recorder for MockResourceDomainNotifier.
+type MockResourceDomainNotifierMockRecorder struct {
+	mock *MockResourceDomainNotifier
+}
+
+// NewMockResourceDomainNotifier creates a new mock instance.
+func NewMockResourceDomainNotifier(ctrl *gomock.Controller) *MockResourceDomainNotifier {
+	mock := &MockResourceDomainNotifier{ctrl: ctrl}
+	mock.recorder = &MockResourceDomainNotifierMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockResourceDomainNotifier) EXPECT() *MockResourceDomainNotifierMockRecorder {
+	return m.recorder
+}
+
+// PublishResources mocks base method.
+func (m *MockResourceDomainNotifier) PublishResources(ctx context.Context, event *entity.ResourceDomainEvent) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishResources", ctx, event)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PublishResources indicates an expected call of PublishResources.
+func (mr *MockResourceDomainNotifierMockRecorder) PublishResources(ctx, event any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishResources", reflect.TypeOf((*MockResourceDomainNotifier)(nil).PublishResources), ctx, event)
+}

backend/internal/mock/domain/memory/database/database_mock.go

@@ -0,0 +1,379 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: database.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../../internal/mock/domain/memory/database/database_mock.go --package database -source database.go
+//
+
+// Package database is a generated GoMock package.
+package database
+
+import (
+	context "context"
+	reflect "reflect"
+
+	service "github.com/coze-dev/coze-studio/backend/domain/memory/database/service"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockDatabase is a mock of Database interface.
+type MockDatabase struct {
+	ctrl     *gomock.Controller
+	recorder *MockDatabaseMockRecorder
+}
+
+// MockDatabaseMockRecorder is the mock recorder for MockDatabase.
+type MockDatabaseMockRecorder struct {
+	mock *MockDatabase
+}
+
+// NewMockDatabase creates a new mock instance.
+func NewMockDatabase(ctrl *gomock.Controller) *MockDatabase {
+	mock := &MockDatabase{ctrl: ctrl}
+	mock.recorder = &MockDatabaseMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDatabase) EXPECT() *MockDatabaseMockRecorder {
+	return m.recorder
+}
+
+// AddDatabaseRecord mocks base method.
+func (m *MockDatabase) AddDatabaseRecord(ctx context.Context, req *service.AddDatabaseRecordRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AddDatabaseRecord", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// AddDatabaseRecord indicates an expected call of AddDatabaseRecord.
+func (mr *MockDatabaseMockRecorder) AddDatabaseRecord(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddDatabaseRecord", reflect.TypeOf((*MockDatabase)(nil).AddDatabaseRecord), ctx, req)
+}
+
+// BindDatabase mocks base method.
+func (m *MockDatabase) BindDatabase(ctx context.Context, req *service.BindDatabaseToAgentRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BindDatabase", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BindDatabase indicates an expected call of BindDatabase.
+func (mr *MockDatabaseMockRecorder) BindDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindDatabase", reflect.TypeOf((*MockDatabase)(nil).BindDatabase), ctx, req)
+}
+
+// CreateDatabase mocks base method.
+func (m *MockDatabase) CreateDatabase(ctx context.Context, req *service.CreateDatabaseRequest) (*service.CreateDatabaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDatabase", ctx, req)
+	ret0, _ := ret[0].(*service.CreateDatabaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDatabase indicates an expected call of CreateDatabase.
+func (mr *MockDatabaseMockRecorder) CreateDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDatabase", reflect.TypeOf((*MockDatabase)(nil).CreateDatabase), ctx, req)
+}
+
+// DeleteDatabase mocks base method.
+func (m *MockDatabase) DeleteDatabase(ctx context.Context, req *service.DeleteDatabaseRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDatabase", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteDatabase indicates an expected call of DeleteDatabase.
+func (mr *MockDatabaseMockRecorder) DeleteDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDatabase", reflect.TypeOf((*MockDatabase)(nil).DeleteDatabase), ctx, req)
+}
+
+// DeleteDatabaseByAppID mocks base method.
+func (m *MockDatabase) DeleteDatabaseByAppID(ctx context.Context, req *service.DeleteDatabaseByAppIDRequest) (*service.DeleteDatabaseByAppIDResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDatabaseByAppID", ctx, req)
+	ret0, _ := ret[0].(*service.DeleteDatabaseByAppIDResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteDatabaseByAppID indicates an expected call of DeleteDatabaseByAppID.
+func (mr *MockDatabaseMockRecorder) DeleteDatabaseByAppID(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDatabaseByAppID", reflect.TypeOf((*MockDatabase)(nil).DeleteDatabaseByAppID), ctx, req)
+}
+
+// DeleteDatabaseRecord mocks base method.
+func (m *MockDatabase) DeleteDatabaseRecord(ctx context.Context, req *service.DeleteDatabaseRecordRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDatabaseRecord", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteDatabaseRecord indicates an expected call of DeleteDatabaseRecord.
+func (mr *MockDatabaseMockRecorder) DeleteDatabaseRecord(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDatabaseRecord", reflect.TypeOf((*MockDatabase)(nil).DeleteDatabaseRecord), ctx, req)
+}
+
+// ExecuteSQL mocks base method.
+func (m *MockDatabase) ExecuteSQL(ctx context.Context, req *service.ExecuteSQLRequest) (*service.ExecuteSQLResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteSQL", ctx, req)
+	ret0, _ := ret[0].(*service.ExecuteSQLResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteSQL indicates an expected call of ExecuteSQL.
+func (mr *MockDatabaseMockRecorder) ExecuteSQL(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteSQL", reflect.TypeOf((*MockDatabase)(nil).ExecuteSQL), ctx, req)
+}
+
+// GetAllDatabaseByAppID mocks base method.
+func (m *MockDatabase) GetAllDatabaseByAppID(ctx context.Context, req *service.GetAllDatabaseByAppIDRequest) (*service.GetAllDatabaseByAppIDResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAllDatabaseByAppID", ctx, req)
+	ret0, _ := ret[0].(*service.GetAllDatabaseByAppIDResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAllDatabaseByAppID indicates an expected call of GetAllDatabaseByAppID.
+func (mr *MockDatabaseMockRecorder) GetAllDatabaseByAppID(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllDatabaseByAppID", reflect.TypeOf((*MockDatabase)(nil).GetAllDatabaseByAppID), ctx, req)
+}
+
+// GetDatabaseFileProgressData mocks base method.
+func (m *MockDatabase) GetDatabaseFileProgressData(ctx context.Context, req *service.GetDatabaseFileProgressDataRequest) (*service.GetDatabaseFileProgressDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDatabaseFileProgressData", ctx, req)
+	ret0, _ := ret[0].(*service.GetDatabaseFileProgressDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDatabaseFileProgressData indicates an expected call of GetDatabaseFileProgressData.
+func (mr *MockDatabaseMockRecorder) GetDatabaseFileProgressData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDatabaseFileProgressData", reflect.TypeOf((*MockDatabase)(nil).GetDatabaseFileProgressData), ctx, req)
+}
+
+// GetDatabaseTableSchema mocks base method.
+func (m *MockDatabase) GetDatabaseTableSchema(ctx context.Context, req *service.GetDatabaseTableSchemaRequest) (*service.GetDatabaseTableSchemaResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDatabaseTableSchema", ctx, req)
+	ret0, _ := ret[0].(*service.GetDatabaseTableSchemaResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDatabaseTableSchema indicates an expected call of GetDatabaseTableSchema.
+func (mr *MockDatabaseMockRecorder) GetDatabaseTableSchema(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDatabaseTableSchema", reflect.TypeOf((*MockDatabase)(nil).GetDatabaseTableSchema), ctx, req)
+}
+
+// GetDatabaseTemplate mocks base method.
+func (m *MockDatabase) GetDatabaseTemplate(ctx context.Context, req *service.GetDatabaseTemplateRequest) (*service.GetDatabaseTemplateResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDatabaseTemplate", ctx, req)
+	ret0, _ := ret[0].(*service.GetDatabaseTemplateResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDatabaseTemplate indicates an expected call of GetDatabaseTemplate.
+func (mr *MockDatabaseMockRecorder) GetDatabaseTemplate(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDatabaseTemplate", reflect.TypeOf((*MockDatabase)(nil).GetDatabaseTemplate), ctx, req)
+}
+
+// GetDraftDatabaseByOnlineID mocks base method.
+func (m *MockDatabase) GetDraftDatabaseByOnlineID(ctx context.Context, req *service.GetDraftDatabaseByOnlineIDRequest) (*service.GetDraftDatabaseByOnlineIDResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDraftDatabaseByOnlineID", ctx, req)
+	ret0, _ := ret[0].(*service.GetDraftDatabaseByOnlineIDResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDraftDatabaseByOnlineID indicates an expected call of GetDraftDatabaseByOnlineID.
+func (mr *MockDatabaseMockRecorder) GetDraftDatabaseByOnlineID(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDraftDatabaseByOnlineID", reflect.TypeOf((*MockDatabase)(nil).GetDraftDatabaseByOnlineID), ctx, req)
+}
+
+// ListDatabase mocks base method.
+func (m *MockDatabase) ListDatabase(ctx context.Context, req *service.ListDatabaseRequest) (*service.ListDatabaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListDatabase", ctx, req)
+	ret0, _ := ret[0].(*service.ListDatabaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListDatabase indicates an expected call of ListDatabase.
+func (mr *MockDatabaseMockRecorder) ListDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabase", reflect.TypeOf((*MockDatabase)(nil).ListDatabase), ctx, req)
+}
+
+// ListDatabaseRecord mocks base method.
+func (m *MockDatabase) ListDatabaseRecord(ctx context.Context, req *service.ListDatabaseRecordRequest) (*service.ListDatabaseRecordResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListDatabaseRecord", ctx, req)
+	ret0, _ := ret[0].(*service.ListDatabaseRecordResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListDatabaseRecord indicates an expected call of ListDatabaseRecord.
+func (mr *MockDatabaseMockRecorder) ListDatabaseRecord(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDatabaseRecord", reflect.TypeOf((*MockDatabase)(nil).ListDatabaseRecord), ctx, req)
+}
+
+// MGetDatabase mocks base method.
+func (m *MockDatabase) MGetDatabase(ctx context.Context, req *service.MGetDatabaseRequest) (*service.MGetDatabaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetDatabase", ctx, req)
+	ret0, _ := ret[0].(*service.MGetDatabaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetDatabase indicates an expected call of MGetDatabase.
+func (mr *MockDatabaseMockRecorder) MGetDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetDatabase", reflect.TypeOf((*MockDatabase)(nil).MGetDatabase), ctx, req)
+}
+
+// MGetDatabaseByAgentID mocks base method.
+func (m *MockDatabase) MGetDatabaseByAgentID(ctx context.Context, req *service.MGetDatabaseByAgentIDRequest) (*service.MGetDatabaseByAgentIDResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetDatabaseByAgentID", ctx, req)
+	ret0, _ := ret[0].(*service.MGetDatabaseByAgentIDResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetDatabaseByAgentID indicates an expected call of MGetDatabaseByAgentID.
+func (mr *MockDatabaseMockRecorder) MGetDatabaseByAgentID(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetDatabaseByAgentID", reflect.TypeOf((*MockDatabase)(nil).MGetDatabaseByAgentID), ctx, req)
+}
+
+// MGetRelationsByAgentID mocks base method.
+func (m *MockDatabase) MGetRelationsByAgentID(ctx context.Context, req *service.MGetRelationsByAgentIDRequest) (*service.MGetRelationsByAgentIDResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetRelationsByAgentID", ctx, req)
+	ret0, _ := ret[0].(*service.MGetRelationsByAgentIDResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetRelationsByAgentID indicates an expected call of MGetRelationsByAgentID.
+func (mr *MockDatabaseMockRecorder) MGetRelationsByAgentID(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetRelationsByAgentID", reflect.TypeOf((*MockDatabase)(nil).MGetRelationsByAgentID), ctx, req)
+}
+
+// PublishDatabase mocks base method.
+func (m *MockDatabase) PublishDatabase(ctx context.Context, req *service.PublishDatabaseRequest) (*service.PublishDatabaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishDatabase", ctx, req)
+	ret0, _ := ret[0].(*service.PublishDatabaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishDatabase indicates an expected call of PublishDatabase.
+func (mr *MockDatabaseMockRecorder) PublishDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishDatabase", reflect.TypeOf((*MockDatabase)(nil).PublishDatabase), ctx, req)
+}
+
+// SubmitDatabaseInsertTask mocks base method.
+func (m *MockDatabase) SubmitDatabaseInsertTask(ctx context.Context, req *service.SubmitDatabaseInsertTaskRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SubmitDatabaseInsertTask", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// SubmitDatabaseInsertTask indicates an expected call of SubmitDatabaseInsertTask.
+func (mr *MockDatabaseMockRecorder) SubmitDatabaseInsertTask(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SubmitDatabaseInsertTask", reflect.TypeOf((*MockDatabase)(nil).SubmitDatabaseInsertTask), ctx, req)
+}
+
+// UnBindDatabase mocks base method.
+func (m *MockDatabase) UnBindDatabase(ctx context.Context, req *service.UnBindDatabaseToAgentRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UnBindDatabase", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UnBindDatabase indicates an expected call of UnBindDatabase.
+func (mr *MockDatabaseMockRecorder) UnBindDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnBindDatabase", reflect.TypeOf((*MockDatabase)(nil).UnBindDatabase), ctx, req)
+}
+
+// UpdateDatabase mocks base method.
+func (m *MockDatabase) UpdateDatabase(ctx context.Context, req *service.UpdateDatabaseRequest) (*service.UpdateDatabaseResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDatabase", ctx, req)
+	ret0, _ := ret[0].(*service.UpdateDatabaseResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateDatabase indicates an expected call of UpdateDatabase.
+func (mr *MockDatabaseMockRecorder) UpdateDatabase(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDatabase", reflect.TypeOf((*MockDatabase)(nil).UpdateDatabase), ctx, req)
+}
+
+// UpdateDatabaseRecord mocks base method.
+func (m *MockDatabase) UpdateDatabaseRecord(ctx context.Context, req *service.UpdateDatabaseRecordRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDatabaseRecord", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateDatabaseRecord indicates an expected call of UpdateDatabaseRecord.
+func (mr *MockDatabaseMockRecorder) UpdateDatabaseRecord(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDatabaseRecord", reflect.TypeOf((*MockDatabase)(nil).UpdateDatabaseRecord), ctx, req)
+}
+
+// ValidateDatabaseTableSchema mocks base method.
+func (m *MockDatabase) ValidateDatabaseTableSchema(ctx context.Context, req *service.ValidateDatabaseTableSchemaRequest) (*service.ValidateDatabaseTableSchemaResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ValidateDatabaseTableSchema", ctx, req)
+	ret0, _ := ret[0].(*service.ValidateDatabaseTableSchemaResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ValidateDatabaseTableSchema indicates an expected call of ValidateDatabaseTableSchema.
+func (mr *MockDatabaseMockRecorder) ValidateDatabaseTableSchema(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ValidateDatabaseTableSchema", reflect.TypeOf((*MockDatabase)(nil).ValidateDatabaseTableSchema), ctx, req)
+}

backend/internal/mock/domain/plugin/interface.go

@@ -0,0 +1,665 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: service.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/domain/plugin/interface.go --package mockPlugin -source service.go
+//
+
+// Package mockPlugin is a generated GoMock package.
+package mockPlugin
+
+import (
+	context "context"
+	reflect "reflect"
+
+	entity "github.com/coze-dev/coze-studio/backend/domain/plugin/entity"
+	service "github.com/coze-dev/coze-studio/backend/domain/plugin/service"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockPluginService is a mock of PluginService interface.
+type MockPluginService struct {
+	ctrl     *gomock.Controller
+	recorder *MockPluginServiceMockRecorder
+}
+
+// MockPluginServiceMockRecorder is the mock recorder for MockPluginService.
+type MockPluginServiceMockRecorder struct {
+	mock *MockPluginService
+}
+
+// NewMockPluginService creates a new mock instance.
+func NewMockPluginService(ctrl *gomock.Controller) *MockPluginService {
+	mock := &MockPluginService{ctrl: ctrl}
+	mock.recorder = &MockPluginServiceMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockPluginService) EXPECT() *MockPluginServiceMockRecorder {
+	return m.recorder
+}
+
+// BindAgentTools mocks base method.
+func (m *MockPluginService) BindAgentTools(ctx context.Context, agentID int64, toolIDs []int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BindAgentTools", ctx, agentID, toolIDs)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BindAgentTools indicates an expected call of BindAgentTools.
+func (mr *MockPluginServiceMockRecorder) BindAgentTools(ctx, agentID, toolIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindAgentTools", reflect.TypeOf((*MockPluginService)(nil).BindAgentTools), ctx, agentID, toolIDs)
+}
+
+// CheckPluginToolsDebugStatus mocks base method.
+func (m *MockPluginService) CheckPluginToolsDebugStatus(ctx context.Context, pluginID int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CheckPluginToolsDebugStatus", ctx, pluginID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// CheckPluginToolsDebugStatus indicates an expected call of CheckPluginToolsDebugStatus.
+func (mr *MockPluginServiceMockRecorder) CheckPluginToolsDebugStatus(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckPluginToolsDebugStatus", reflect.TypeOf((*MockPluginService)(nil).CheckPluginToolsDebugStatus), ctx, pluginID)
+}
+
+// ConvertToOpenapi3Doc mocks base method.
+func (m *MockPluginService) ConvertToOpenapi3Doc(ctx context.Context, req *service.ConvertToOpenapi3DocRequest) *service.ConvertToOpenapi3DocResponse {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ConvertToOpenapi3Doc", ctx, req)
+	ret0, _ := ret[0].(*service.ConvertToOpenapi3DocResponse)
+	return ret0
+}
+
+// ConvertToOpenapi3Doc indicates an expected call of ConvertToOpenapi3Doc.
+func (mr *MockPluginServiceMockRecorder) ConvertToOpenapi3Doc(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConvertToOpenapi3Doc", reflect.TypeOf((*MockPluginService)(nil).ConvertToOpenapi3Doc), ctx, req)
+}
+
+// CopyPlugin mocks base method.
+func (m *MockPluginService) CopyPlugin(ctx context.Context, req *service.CopyPluginRequest) (*service.CopyPluginResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CopyPlugin", ctx, req)
+	ret0, _ := ret[0].(*service.CopyPluginResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CopyPlugin indicates an expected call of CopyPlugin.
+func (mr *MockPluginServiceMockRecorder) CopyPlugin(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CopyPlugin", reflect.TypeOf((*MockPluginService)(nil).CopyPlugin), ctx, req)
+}
+
+// CreateDraftPlugin mocks base method.
+func (m *MockPluginService) CreateDraftPlugin(ctx context.Context, req *service.CreateDraftPluginRequest) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDraftPlugin", ctx, req)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDraftPlugin indicates an expected call of CreateDraftPlugin.
+func (mr *MockPluginServiceMockRecorder) CreateDraftPlugin(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftPlugin", reflect.TypeOf((*MockPluginService)(nil).CreateDraftPlugin), ctx, req)
+}
+
+// CreateDraftPluginWithCode mocks base method.
+func (m *MockPluginService) CreateDraftPluginWithCode(ctx context.Context, req *service.CreateDraftPluginWithCodeRequest) (*service.CreateDraftPluginWithCodeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDraftPluginWithCode", ctx, req)
+	ret0, _ := ret[0].(*service.CreateDraftPluginWithCodeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDraftPluginWithCode indicates an expected call of CreateDraftPluginWithCode.
+func (mr *MockPluginServiceMockRecorder) CreateDraftPluginWithCode(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftPluginWithCode", reflect.TypeOf((*MockPluginService)(nil).CreateDraftPluginWithCode), ctx, req)
+}
+
+// CreateDraftToolsWithCode mocks base method.
+func (m *MockPluginService) CreateDraftToolsWithCode(ctx context.Context, req *service.CreateDraftToolsWithCodeRequest) (*service.CreateDraftToolsWithCodeResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateDraftToolsWithCode", ctx, req)
+	ret0, _ := ret[0].(*service.CreateDraftToolsWithCodeResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateDraftToolsWithCode indicates an expected call of CreateDraftToolsWithCode.
+func (mr *MockPluginServiceMockRecorder) CreateDraftToolsWithCode(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateDraftToolsWithCode", reflect.TypeOf((*MockPluginService)(nil).CreateDraftToolsWithCode), ctx, req)
+}
+
+// DeleteAPPAllPlugins mocks base method.
+func (m *MockPluginService) DeleteAPPAllPlugins(ctx context.Context, appID int64) ([]int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteAPPAllPlugins", ctx, appID)
+	ret0, _ := ret[0].([]int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteAPPAllPlugins indicates an expected call of DeleteAPPAllPlugins.
+func (mr *MockPluginServiceMockRecorder) DeleteAPPAllPlugins(ctx, appID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteAPPAllPlugins", reflect.TypeOf((*MockPluginService)(nil).DeleteAPPAllPlugins), ctx, appID)
+}
+
+// DeleteDraftPlugin mocks base method.
+func (m *MockPluginService) DeleteDraftPlugin(ctx context.Context, pluginID int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteDraftPlugin", ctx, pluginID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteDraftPlugin indicates an expected call of DeleteDraftPlugin.
+func (mr *MockPluginServiceMockRecorder) DeleteDraftPlugin(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteDraftPlugin", reflect.TypeOf((*MockPluginService)(nil).DeleteDraftPlugin), ctx, pluginID)
+}
+
+// DuplicateDraftAgentTools mocks base method.
+func (m *MockPluginService) DuplicateDraftAgentTools(ctx context.Context, fromAgentID, toAgentID int64) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DuplicateDraftAgentTools", ctx, fromAgentID, toAgentID)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DuplicateDraftAgentTools indicates an expected call of DuplicateDraftAgentTools.
+func (mr *MockPluginServiceMockRecorder) DuplicateDraftAgentTools(ctx, fromAgentID, toAgentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DuplicateDraftAgentTools", reflect.TypeOf((*MockPluginService)(nil).DuplicateDraftAgentTools), ctx, fromAgentID, toAgentID)
+}
+
+// ExecuteTool mocks base method.
+func (m *MockPluginService) ExecuteTool(ctx context.Context, req *service.ExecuteToolRequest, opts ...entity.ExecuteToolOpt) (*service.ExecuteToolResponse, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, req}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "ExecuteTool", varargs...)
+	ret0, _ := ret[0].(*service.ExecuteToolResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteTool indicates an expected call of ExecuteTool.
+func (mr *MockPluginServiceMockRecorder) ExecuteTool(ctx, req any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, req}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteTool", reflect.TypeOf((*MockPluginService)(nil).ExecuteTool), varargs...)
+}
+
+// GetAPPAllPlugins mocks base method.
+func (m *MockPluginService) GetAPPAllPlugins(ctx context.Context, appID int64) ([]*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAPPAllPlugins", ctx, appID)
+	ret0, _ := ret[0].([]*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAPPAllPlugins indicates an expected call of GetAPPAllPlugins.
+func (mr *MockPluginServiceMockRecorder) GetAPPAllPlugins(ctx, appID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAPPAllPlugins", reflect.TypeOf((*MockPluginService)(nil).GetAPPAllPlugins), ctx, appID)
+}
+
+// GetAccessToken mocks base method.
+func (m *MockPluginService) GetAccessToken(ctx context.Context, oa *entity.OAuthInfo) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAccessToken", ctx, oa)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAccessToken indicates an expected call of GetAccessToken.
+func (mr *MockPluginServiceMockRecorder) GetAccessToken(ctx, oa any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAccessToken", reflect.TypeOf((*MockPluginService)(nil).GetAccessToken), ctx, oa)
+}
+
+// GetAgentPluginsOAuthStatus mocks base method.
+func (m *MockPluginService) GetAgentPluginsOAuthStatus(ctx context.Context, userID, agentID int64) ([]*service.AgentPluginOAuthStatus, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetAgentPluginsOAuthStatus", ctx, userID, agentID)
+	ret0, _ := ret[0].([]*service.AgentPluginOAuthStatus)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetAgentPluginsOAuthStatus indicates an expected call of GetAgentPluginsOAuthStatus.
+func (mr *MockPluginServiceMockRecorder) GetAgentPluginsOAuthStatus(ctx, userID, agentID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAgentPluginsOAuthStatus", reflect.TypeOf((*MockPluginService)(nil).GetAgentPluginsOAuthStatus), ctx, userID, agentID)
+}
+
+// GetDraftAgentToolByName mocks base method.
+func (m *MockPluginService) GetDraftAgentToolByName(ctx context.Context, agentID int64, toolName string) (*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDraftAgentToolByName", ctx, agentID, toolName)
+	ret0, _ := ret[0].(*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDraftAgentToolByName indicates an expected call of GetDraftAgentToolByName.
+func (mr *MockPluginServiceMockRecorder) GetDraftAgentToolByName(ctx, agentID, toolName any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDraftAgentToolByName", reflect.TypeOf((*MockPluginService)(nil).GetDraftAgentToolByName), ctx, agentID, toolName)
+}
+
+// GetDraftPlugin mocks base method.
+func (m *MockPluginService) GetDraftPlugin(ctx context.Context, pluginID int64) (*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetDraftPlugin", ctx, pluginID)
+	ret0, _ := ret[0].(*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetDraftPlugin indicates an expected call of GetDraftPlugin.
+func (mr *MockPluginServiceMockRecorder) GetDraftPlugin(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDraftPlugin", reflect.TypeOf((*MockPluginService)(nil).GetDraftPlugin), ctx, pluginID)
+}
+
+// GetOAuthStatus mocks base method.
+func (m *MockPluginService) GetOAuthStatus(ctx context.Context, userID, pluginID int64) (*service.GetOAuthStatusResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOAuthStatus", ctx, userID, pluginID)
+	ret0, _ := ret[0].(*service.GetOAuthStatusResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOAuthStatus indicates an expected call of GetOAuthStatus.
+func (mr *MockPluginServiceMockRecorder) GetOAuthStatus(ctx, userID, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOAuthStatus", reflect.TypeOf((*MockPluginService)(nil).GetOAuthStatus), ctx, userID, pluginID)
+}
+
+// GetOnlinePlugin mocks base method.
+func (m *MockPluginService) GetOnlinePlugin(ctx context.Context, pluginID int64) (*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOnlinePlugin", ctx, pluginID)
+	ret0, _ := ret[0].(*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOnlinePlugin indicates an expected call of GetOnlinePlugin.
+func (mr *MockPluginServiceMockRecorder) GetOnlinePlugin(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOnlinePlugin", reflect.TypeOf((*MockPluginService)(nil).GetOnlinePlugin), ctx, pluginID)
+}
+
+// GetOnlineTool mocks base method.
+func (m *MockPluginService) GetOnlineTool(ctx context.Context, toolID int64) (*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetOnlineTool", ctx, toolID)
+	ret0, _ := ret[0].(*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetOnlineTool indicates an expected call of GetOnlineTool.
+func (mr *MockPluginServiceMockRecorder) GetOnlineTool(ctx, toolID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOnlineTool", reflect.TypeOf((*MockPluginService)(nil).GetOnlineTool), ctx, toolID)
+}
+
+// GetPluginNextVersion mocks base method.
+func (m *MockPluginService) GetPluginNextVersion(ctx context.Context, pluginID int64) (string, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPluginNextVersion", ctx, pluginID)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPluginNextVersion indicates an expected call of GetPluginNextVersion.
+func (mr *MockPluginServiceMockRecorder) GetPluginNextVersion(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginNextVersion", reflect.TypeOf((*MockPluginService)(nil).GetPluginNextVersion), ctx, pluginID)
+}
+
+// GetPluginProductAllTools mocks base method.
+func (m *MockPluginService) GetPluginProductAllTools(ctx context.Context, pluginID int64) ([]*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetPluginProductAllTools", ctx, pluginID)
+	ret0, _ := ret[0].([]*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetPluginProductAllTools indicates an expected call of GetPluginProductAllTools.
+func (mr *MockPluginServiceMockRecorder) GetPluginProductAllTools(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPluginProductAllTools", reflect.TypeOf((*MockPluginService)(nil).GetPluginProductAllTools), ctx, pluginID)
+}
+
+// ListCustomOnlinePlugins mocks base method.
+func (m *MockPluginService) ListCustomOnlinePlugins(ctx context.Context, spaceID int64, pageInfo entity.PageInfo) ([]*entity.PluginInfo, int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListCustomOnlinePlugins", ctx, spaceID, pageInfo)
+	ret0, _ := ret[0].([]*entity.PluginInfo)
+	ret1, _ := ret[1].(int64)
+	ret2, _ := ret[2].(error)
+	return ret0, ret1, ret2
+}
+
+// ListCustomOnlinePlugins indicates an expected call of ListCustomOnlinePlugins.
+func (mr *MockPluginServiceMockRecorder) ListCustomOnlinePlugins(ctx, spaceID, pageInfo any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListCustomOnlinePlugins", reflect.TypeOf((*MockPluginService)(nil).ListCustomOnlinePlugins), ctx, spaceID, pageInfo)
+}
+
+// ListDraftPlugins mocks base method.
+func (m *MockPluginService) ListDraftPlugins(ctx context.Context, req *service.ListDraftPluginsRequest) (*service.ListDraftPluginsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListDraftPlugins", ctx, req)
+	ret0, _ := ret[0].(*service.ListDraftPluginsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListDraftPlugins indicates an expected call of ListDraftPlugins.
+func (mr *MockPluginServiceMockRecorder) ListDraftPlugins(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListDraftPlugins", reflect.TypeOf((*MockPluginService)(nil).ListDraftPlugins), ctx, req)
+}
+
+// ListPluginProducts mocks base method.
+func (m *MockPluginService) ListPluginProducts(ctx context.Context, req *service.ListPluginProductsRequest) (*service.ListPluginProductsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ListPluginProducts", ctx, req)
+	ret0, _ := ret[0].(*service.ListPluginProductsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ListPluginProducts indicates an expected call of ListPluginProducts.
+func (mr *MockPluginServiceMockRecorder) ListPluginProducts(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPluginProducts", reflect.TypeOf((*MockPluginService)(nil).ListPluginProducts), ctx, req)
+}
+
+// MGetAgentTools mocks base method.
+func (m *MockPluginService) MGetAgentTools(ctx context.Context, req *service.MGetAgentToolsRequest) ([]*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetAgentTools", ctx, req)
+	ret0, _ := ret[0].([]*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetAgentTools indicates an expected call of MGetAgentTools.
+func (mr *MockPluginServiceMockRecorder) MGetAgentTools(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetAgentTools", reflect.TypeOf((*MockPluginService)(nil).MGetAgentTools), ctx, req)
+}
+
+// MGetDraftPlugins mocks base method.
+func (m *MockPluginService) MGetDraftPlugins(ctx context.Context, pluginIDs []int64) ([]*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetDraftPlugins", ctx, pluginIDs)
+	ret0, _ := ret[0].([]*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetDraftPlugins indicates an expected call of MGetDraftPlugins.
+func (mr *MockPluginServiceMockRecorder) MGetDraftPlugins(ctx, pluginIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetDraftPlugins", reflect.TypeOf((*MockPluginService)(nil).MGetDraftPlugins), ctx, pluginIDs)
+}
+
+// MGetDraftTools mocks base method.
+func (m *MockPluginService) MGetDraftTools(ctx context.Context, toolIDs []int64) ([]*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetDraftTools", ctx, toolIDs)
+	ret0, _ := ret[0].([]*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetDraftTools indicates an expected call of MGetDraftTools.
+func (mr *MockPluginServiceMockRecorder) MGetDraftTools(ctx, toolIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetDraftTools", reflect.TypeOf((*MockPluginService)(nil).MGetDraftTools), ctx, toolIDs)
+}
+
+// MGetOnlinePlugins mocks base method.
+func (m *MockPluginService) MGetOnlinePlugins(ctx context.Context, pluginIDs []int64) ([]*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetOnlinePlugins", ctx, pluginIDs)
+	ret0, _ := ret[0].([]*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetOnlinePlugins indicates an expected call of MGetOnlinePlugins.
+func (mr *MockPluginServiceMockRecorder) MGetOnlinePlugins(ctx, pluginIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetOnlinePlugins", reflect.TypeOf((*MockPluginService)(nil).MGetOnlinePlugins), ctx, pluginIDs)
+}
+
+// MGetOnlineTools mocks base method.
+func (m *MockPluginService) MGetOnlineTools(ctx context.Context, toolIDs []int64) ([]*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetOnlineTools", ctx, toolIDs)
+	ret0, _ := ret[0].([]*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetOnlineTools indicates an expected call of MGetOnlineTools.
+func (mr *MockPluginServiceMockRecorder) MGetOnlineTools(ctx, toolIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetOnlineTools", reflect.TypeOf((*MockPluginService)(nil).MGetOnlineTools), ctx, toolIDs)
+}
+
+// MGetPluginLatestVersion mocks base method.
+func (m *MockPluginService) MGetPluginLatestVersion(ctx context.Context, pluginIDs []int64) (*service.MGetPluginLatestVersionResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetPluginLatestVersion", ctx, pluginIDs)
+	ret0, _ := ret[0].(*service.MGetPluginLatestVersionResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetPluginLatestVersion indicates an expected call of MGetPluginLatestVersion.
+func (mr *MockPluginServiceMockRecorder) MGetPluginLatestVersion(ctx, pluginIDs any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetPluginLatestVersion", reflect.TypeOf((*MockPluginService)(nil).MGetPluginLatestVersion), ctx, pluginIDs)
+}
+
+// MGetVersionPlugins mocks base method.
+func (m *MockPluginService) MGetVersionPlugins(ctx context.Context, versionPlugins []entity.VersionPlugin) ([]*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetVersionPlugins", ctx, versionPlugins)
+	ret0, _ := ret[0].([]*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetVersionPlugins indicates an expected call of MGetVersionPlugins.
+func (mr *MockPluginServiceMockRecorder) MGetVersionPlugins(ctx, versionPlugins any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetVersionPlugins", reflect.TypeOf((*MockPluginService)(nil).MGetVersionPlugins), ctx, versionPlugins)
+}
+
+// MGetVersionTools mocks base method.
+func (m *MockPluginService) MGetVersionTools(ctx context.Context, versionTools []entity.VersionTool) ([]*entity.ToolInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MGetVersionTools", ctx, versionTools)
+	ret0, _ := ret[0].([]*entity.ToolInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MGetVersionTools indicates an expected call of MGetVersionTools.
+func (mr *MockPluginServiceMockRecorder) MGetVersionTools(ctx, versionTools any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MGetVersionTools", reflect.TypeOf((*MockPluginService)(nil).MGetVersionTools), ctx, versionTools)
+}
+
+// MoveAPPPluginToLibrary mocks base method.
+func (m *MockPluginService) MoveAPPPluginToLibrary(ctx context.Context, pluginID int64) (*entity.PluginInfo, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "MoveAPPPluginToLibrary", ctx, pluginID)
+	ret0, _ := ret[0].(*entity.PluginInfo)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// MoveAPPPluginToLibrary indicates an expected call of MoveAPPPluginToLibrary.
+func (mr *MockPluginServiceMockRecorder) MoveAPPPluginToLibrary(ctx, pluginID any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MoveAPPPluginToLibrary", reflect.TypeOf((*MockPluginService)(nil).MoveAPPPluginToLibrary), ctx, pluginID)
+}
+
+// OAuthCode mocks base method.
+func (m *MockPluginService) OAuthCode(ctx context.Context, code string, state *entity.OAuthState) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "OAuthCode", ctx, code, state)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// OAuthCode indicates an expected call of OAuthCode.
+func (mr *MockPluginServiceMockRecorder) OAuthCode(ctx, code, state any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "OAuthCode", reflect.TypeOf((*MockPluginService)(nil).OAuthCode), ctx, code, state)
+}
+
+// PublishAPPPlugins mocks base method.
+func (m *MockPluginService) PublishAPPPlugins(ctx context.Context, req *service.PublishAPPPluginsRequest) (*service.PublishAPPPluginsResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishAPPPlugins", ctx, req)
+	ret0, _ := ret[0].(*service.PublishAPPPluginsResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// PublishAPPPlugins indicates an expected call of PublishAPPPlugins.
+func (mr *MockPluginServiceMockRecorder) PublishAPPPlugins(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishAPPPlugins", reflect.TypeOf((*MockPluginService)(nil).PublishAPPPlugins), ctx, req)
+}
+
+// PublishAgentTools mocks base method.
+func (m *MockPluginService) PublishAgentTools(ctx context.Context, agentID int64, agentVersion string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishAgentTools", ctx, agentID, agentVersion)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PublishAgentTools indicates an expected call of PublishAgentTools.
+func (mr *MockPluginServiceMockRecorder) PublishAgentTools(ctx, agentID, agentVersion any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishAgentTools", reflect.TypeOf((*MockPluginService)(nil).PublishAgentTools), ctx, agentID, agentVersion)
+}
+
+// PublishPlugin mocks base method.
+func (m *MockPluginService) PublishPlugin(ctx context.Context, req *service.PublishPluginRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "PublishPlugin", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PublishPlugin indicates an expected call of PublishPlugin.
+func (mr *MockPluginServiceMockRecorder) PublishPlugin(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PublishPlugin", reflect.TypeOf((*MockPluginService)(nil).PublishPlugin), ctx, req)
+}
+
+// RevokeAccessToken mocks base method.
+func (m *MockPluginService) RevokeAccessToken(ctx context.Context, meta *entity.AuthorizationCodeMeta) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "RevokeAccessToken", ctx, meta)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// RevokeAccessToken indicates an expected call of RevokeAccessToken.
+func (mr *MockPluginServiceMockRecorder) RevokeAccessToken(ctx, meta any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RevokeAccessToken", reflect.TypeOf((*MockPluginService)(nil).RevokeAccessToken), ctx, meta)
+}
+
+// UpdateBotDefaultParams mocks base method.
+func (m *MockPluginService) UpdateBotDefaultParams(ctx context.Context, req *service.UpdateBotDefaultParamsRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateBotDefaultParams", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateBotDefaultParams indicates an expected call of UpdateBotDefaultParams.
+func (mr *MockPluginServiceMockRecorder) UpdateBotDefaultParams(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateBotDefaultParams", reflect.TypeOf((*MockPluginService)(nil).UpdateBotDefaultParams), ctx, req)
+}
+
+// UpdateDraftPlugin mocks base method.
+func (m *MockPluginService) UpdateDraftPlugin(ctx context.Context, plugin *service.UpdateDraftPluginRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDraftPlugin", ctx, plugin)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateDraftPlugin indicates an expected call of UpdateDraftPlugin.
+func (mr *MockPluginServiceMockRecorder) UpdateDraftPlugin(ctx, plugin any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftPlugin", reflect.TypeOf((*MockPluginService)(nil).UpdateDraftPlugin), ctx, plugin)
+}
+
+// UpdateDraftPluginWithCode mocks base method.
+func (m *MockPluginService) UpdateDraftPluginWithCode(ctx context.Context, req *service.UpdateDraftPluginWithCodeRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDraftPluginWithCode", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateDraftPluginWithCode indicates an expected call of UpdateDraftPluginWithCode.
+func (mr *MockPluginServiceMockRecorder) UpdateDraftPluginWithCode(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftPluginWithCode", reflect.TypeOf((*MockPluginService)(nil).UpdateDraftPluginWithCode), ctx, req)
+}
+
+// UpdateDraftTool mocks base method.
+func (m *MockPluginService) UpdateDraftTool(ctx context.Context, req *service.UpdateToolDraftRequest) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateDraftTool", ctx, req)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// UpdateDraftTool indicates an expected call of UpdateDraftTool.
+func (mr *MockPluginServiceMockRecorder) UpdateDraftTool(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateDraftTool", reflect.TypeOf((*MockPluginService)(nil).UpdateDraftTool), ctx, req)
+}

backend/internal/mock/domain/workflow/crossdomain/code/code_mock.go

@@ -0,0 +1,52 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: code.go
+
+// Package code is a generated GoMock package.
+package code
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+
+	code "github.com/coze-dev/coze-studio/backend/domain/workflow/crossdomain/code"
+)
+
+// MockRunner is a mock of Runner interface.
+type MockRunner struct {
+	ctrl     *gomock.Controller
+	recorder *MockRunnerMockRecorder
+}
+
+// MockRunnerMockRecorder is the mock recorder for MockRunner.
+type MockRunnerMockRecorder struct {
+	mock *MockRunner
+}
+
+// NewMockRunner creates a new mock instance.
+func NewMockRunner(ctrl *gomock.Controller) *MockRunner {
+	mock := &MockRunner{ctrl: ctrl}
+	mock.recorder = &MockRunnerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRunner) EXPECT() *MockRunnerMockRecorder {
+	return m.recorder
+}
+
+// Run mocks base method.
+func (m *MockRunner) Run(ctx context.Context, request *code.RunRequest) (*code.RunResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Run", ctx, request)
+	ret0, _ := ret[0].(*code.RunResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Run indicates an expected call of Run.
+func (mr *MockRunnerMockRecorder) Run(ctx, request interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockRunner)(nil).Run), ctx, request)
+}

backend/internal/mock/infra/contract/chatmodel/chat_model_factory_mock.go

@@ -0,0 +1,71 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: chat_model.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/chatmodel/chat_model_factory_mock.go -package mock -source chat_model.go Factory
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	chatmodel "github.com/coze-dev/coze-studio/backend/infra/contract/chatmodel"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockFactory is a mock of Factory interface.
+type MockFactory struct {
+	ctrl     *gomock.Controller
+	recorder *MockFactoryMockRecorder
+	isgomock struct{}
+}
+
+// MockFactoryMockRecorder is the mock recorder for MockFactory.
+type MockFactoryMockRecorder struct {
+	mock *MockFactory
+}
+
+// NewMockFactory creates a new mock instance.
+func NewMockFactory(ctrl *gomock.Controller) *MockFactory {
+	mock := &MockFactory{ctrl: ctrl}
+	mock.recorder = &MockFactoryMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockFactory) EXPECT() *MockFactoryMockRecorder {
+	return m.recorder
+}
+
+// CreateChatModel mocks base method.
+func (m *MockFactory) CreateChatModel(ctx context.Context, protocol chatmodel.Protocol, config *chatmodel.Config) (chatmodel.ToolCallingChatModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateChatModel", ctx, protocol, config)
+	ret0, _ := ret[0].(chatmodel.ToolCallingChatModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateChatModel indicates an expected call of CreateChatModel.
+func (mr *MockFactoryMockRecorder) CreateChatModel(ctx, protocol, config any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateChatModel", reflect.TypeOf((*MockFactory)(nil).CreateChatModel), ctx, protocol, config)
+}
+
+// SupportProtocol mocks base method.
+func (m *MockFactory) SupportProtocol(protocol chatmodel.Protocol) bool {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SupportProtocol", protocol)
+	ret0, _ := ret[0].(bool)
+	return ret0
+}
+
+// SupportProtocol indicates an expected call of SupportProtocol.
+func (mr *MockFactoryMockRecorder) SupportProtocol(protocol any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SupportProtocol", reflect.TypeOf((*MockFactory)(nil).SupportProtocol), protocol)
+}

backend/internal/mock/infra/contract/chatmodel/toolcalling_model_mock.go

@@ -0,0 +1,240 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: /Users/bytedance/gocode/src/github.com/cloudwego/eino/components/model/interface.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/chatmodel/toolcalling_model_mock.go -package mock -source /Users/bytedance/gocode/src/github.com/cloudwego/eino/components/model/interface.go ToolCallingChatModel
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	model "github.com/cloudwego/eino/components/model"
+	schema "github.com/cloudwego/eino/schema"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockBaseChatModel is a mock of BaseChatModel interface.
+type MockBaseChatModel struct {
+	ctrl     *gomock.Controller
+	recorder *MockBaseChatModelMockRecorder
+	isgomock struct{}
+}
+
+// MockBaseChatModelMockRecorder is the mock recorder for MockBaseChatModel.
+type MockBaseChatModelMockRecorder struct {
+	mock *MockBaseChatModel
+}
+
+// NewMockBaseChatModel creates a new mock instance.
+func NewMockBaseChatModel(ctrl *gomock.Controller) *MockBaseChatModel {
+	mock := &MockBaseChatModel{ctrl: ctrl}
+	mock.recorder = &MockBaseChatModelMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockBaseChatModel) EXPECT() *MockBaseChatModelMockRecorder {
+	return m.recorder
+}
+
+// Generate mocks base method.
+func (m *MockBaseChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Generate", varargs...)
+	ret0, _ := ret[0].(*schema.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Generate indicates an expected call of Generate.
+func (mr *MockBaseChatModelMockRecorder) Generate(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockBaseChatModel)(nil).Generate), varargs...)
+}
+
+// Stream mocks base method.
+func (m *MockBaseChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Stream", varargs...)
+	ret0, _ := ret[0].(*schema.StreamReader[*schema.Message])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockBaseChatModelMockRecorder) Stream(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockBaseChatModel)(nil).Stream), varargs...)
+}
+
+// MockChatModel is a mock of ChatModel interface.
+type MockChatModel struct {
+	ctrl     *gomock.Controller
+	recorder *MockChatModelMockRecorder
+	isgomock struct{}
+}
+
+// MockChatModelMockRecorder is the mock recorder for MockChatModel.
+type MockChatModelMockRecorder struct {
+	mock *MockChatModel
+}
+
+// NewMockChatModel creates a new mock instance.
+func NewMockChatModel(ctrl *gomock.Controller) *MockChatModel {
+	mock := &MockChatModel{ctrl: ctrl}
+	mock.recorder = &MockChatModelMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockChatModel) EXPECT() *MockChatModelMockRecorder {
+	return m.recorder
+}
+
+// BindTools mocks base method.
+func (m *MockChatModel) BindTools(tools []*schema.ToolInfo) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "BindTools", tools)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BindTools indicates an expected call of BindTools.
+func (mr *MockChatModelMockRecorder) BindTools(tools any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BindTools", reflect.TypeOf((*MockChatModel)(nil).BindTools), tools)
+}
+
+// Generate mocks base method.
+func (m *MockChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Generate", varargs...)
+	ret0, _ := ret[0].(*schema.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Generate indicates an expected call of Generate.
+func (mr *MockChatModelMockRecorder) Generate(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockChatModel)(nil).Generate), varargs...)
+}
+
+// Stream mocks base method.
+func (m *MockChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Stream", varargs...)
+	ret0, _ := ret[0].(*schema.StreamReader[*schema.Message])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockChatModelMockRecorder) Stream(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockChatModel)(nil).Stream), varargs...)
+}
+
+// MockToolCallingChatModel is a mock of ToolCallingChatModel interface.
+type MockToolCallingChatModel struct {
+	ctrl     *gomock.Controller
+	recorder *MockToolCallingChatModelMockRecorder
+	isgomock struct{}
+}
+
+// MockToolCallingChatModelMockRecorder is the mock recorder for MockToolCallingChatModel.
+type MockToolCallingChatModelMockRecorder struct {
+	mock *MockToolCallingChatModel
+}
+
+// NewMockToolCallingChatModel creates a new mock instance.
+func NewMockToolCallingChatModel(ctrl *gomock.Controller) *MockToolCallingChatModel {
+	mock := &MockToolCallingChatModel{ctrl: ctrl}
+	mock.recorder = &MockToolCallingChatModelMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockToolCallingChatModel) EXPECT() *MockToolCallingChatModelMockRecorder {
+	return m.recorder
+}
+
+// Generate mocks base method.
+func (m *MockToolCallingChatModel) Generate(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.Message, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Generate", varargs...)
+	ret0, _ := ret[0].(*schema.Message)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Generate indicates an expected call of Generate.
+func (mr *MockToolCallingChatModelMockRecorder) Generate(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Generate", reflect.TypeOf((*MockToolCallingChatModel)(nil).Generate), varargs...)
+}
+
+// Stream mocks base method.
+func (m *MockToolCallingChatModel) Stream(ctx context.Context, input []*schema.Message, opts ...model.Option) (*schema.StreamReader[*schema.Message], error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, input}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Stream", varargs...)
+	ret0, _ := ret[0].(*schema.StreamReader[*schema.Message])
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Stream indicates an expected call of Stream.
+func (mr *MockToolCallingChatModelMockRecorder) Stream(ctx, input any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, input}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Stream", reflect.TypeOf((*MockToolCallingChatModel)(nil).Stream), varargs...)
+}
+
+// WithTools mocks base method.
+func (m *MockToolCallingChatModel) WithTools(tools []*schema.ToolInfo) (model.ToolCallingChatModel, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "WithTools", tools)
+	ret0, _ := ret[0].(model.ToolCallingChatModel)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// WithTools indicates an expected call of WithTools.
+func (mr *MockToolCallingChatModelMockRecorder) WithTools(tools any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithTools", reflect.TypeOf((*MockToolCallingChatModel)(nil).WithTools), tools)
+}

backend/internal/mock/infra/contract/eventbus/eventbus_mock.go

@@ -0,0 +1,142 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: eventbus.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/eventbus/eventbus_mock.go -package mock -source eventbus.go Factory
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	eventbus "github.com/coze-dev/coze-studio/backend/infra/contract/eventbus"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockProducer is a mock of Producer interface.
+type MockProducer struct {
+	ctrl     *gomock.Controller
+	recorder *MockProducerMockRecorder
+	isgomock struct{}
+}
+
+// MockProducerMockRecorder is the mock recorder for MockProducer.
+type MockProducerMockRecorder struct {
+	mock *MockProducer
+}
+
+// NewMockProducer creates a new mock instance.
+func NewMockProducer(ctrl *gomock.Controller) *MockProducer {
+	mock := &MockProducer{ctrl: ctrl}
+	mock.recorder = &MockProducerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockProducer) EXPECT() *MockProducerMockRecorder {
+	return m.recorder
+}
+
+// BatchSend mocks base method.
+func (m *MockProducer) BatchSend(ctx context.Context, bodyArr [][]byte, opts ...eventbus.SendOpt) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, bodyArr}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "BatchSend", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// BatchSend indicates an expected call of BatchSend.
+func (mr *MockProducerMockRecorder) BatchSend(ctx, bodyArr any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, bodyArr}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BatchSend", reflect.TypeOf((*MockProducer)(nil).BatchSend), varargs...)
+}
+
+// Send mocks base method.
+func (m *MockProducer) Send(ctx context.Context, body []byte, opts ...eventbus.SendOpt) error {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, body}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Send", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// Send indicates an expected call of Send.
+func (mr *MockProducerMockRecorder) Send(ctx, body any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, body}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Send", reflect.TypeOf((*MockProducer)(nil).Send), varargs...)
+}
+
+// MockConsumer is a mock of Consumer interface.
+type MockConsumer struct {
+	ctrl     *gomock.Controller
+	recorder *MockConsumerMockRecorder
+	isgomock struct{}
+}
+
+// MockConsumerMockRecorder is the mock recorder for MockConsumer.
+type MockConsumerMockRecorder struct {
+	mock *MockConsumer
+}
+
+// NewMockConsumer creates a new mock instance.
+func NewMockConsumer(ctrl *gomock.Controller) *MockConsumer {
+	mock := &MockConsumer{ctrl: ctrl}
+	mock.recorder = &MockConsumerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConsumer) EXPECT() *MockConsumerMockRecorder {
+	return m.recorder
+}
+
+// MockConsumerHandler is a mock of ConsumerHandler interface.
+type MockConsumerHandler struct {
+	ctrl     *gomock.Controller
+	recorder *MockConsumerHandlerMockRecorder
+	isgomock struct{}
+}
+
+// MockConsumerHandlerMockRecorder is the mock recorder for MockConsumerHandler.
+type MockConsumerHandlerMockRecorder struct {
+	mock *MockConsumerHandler
+}
+
+// NewMockConsumerHandler creates a new mock instance.
+func NewMockConsumerHandler(ctrl *gomock.Controller) *MockConsumerHandler {
+	mock := &MockConsumerHandler{ctrl: ctrl}
+	mock.recorder = &MockConsumerHandlerMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockConsumerHandler) EXPECT() *MockConsumerHandlerMockRecorder {
+	return m.recorder
+}
+
+// HandleMessage mocks base method.
+func (m *MockConsumerHandler) HandleMessage(ctx context.Context, msg *eventbus.Message) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "HandleMessage", ctx, msg)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// HandleMessage indicates an expected call of HandleMessage.
+func (mr *MockConsumerHandlerMockRecorder) HandleMessage(ctx, msg any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "HandleMessage", reflect.TypeOf((*MockConsumerHandler)(nil).HandleMessage), ctx, msg)
+}

backend/internal/mock/infra/contract/idgen/idgen_mock.go

@@ -0,0 +1,71 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: idgen.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/idgen/idgen_mock.go --package mock -source idgen.go
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockIDGenerator is a mock of IDGenerator interface.
+type MockIDGenerator struct {
+	ctrl     *gomock.Controller
+	recorder *MockIDGeneratorMockRecorder
+	isgomock struct{}
+}
+
+// MockIDGeneratorMockRecorder is the mock recorder for MockIDGenerator.
+type MockIDGeneratorMockRecorder struct {
+	mock *MockIDGenerator
+}
+
+// NewMockIDGenerator creates a new mock instance.
+func NewMockIDGenerator(ctrl *gomock.Controller) *MockIDGenerator {
+	mock := &MockIDGenerator{ctrl: ctrl}
+	mock.recorder = &MockIDGeneratorMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockIDGenerator) EXPECT() *MockIDGeneratorMockRecorder {
+	return m.recorder
+}
+
+// GenID mocks base method.
+func (m *MockIDGenerator) GenID(ctx context.Context) (int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GenID", ctx)
+	ret0, _ := ret[0].(int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GenID indicates an expected call of GenID.
+func (mr *MockIDGeneratorMockRecorder) GenID(ctx any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenID", reflect.TypeOf((*MockIDGenerator)(nil).GenID), ctx)
+}
+
+// GenMultiIDs mocks base method.
+func (m *MockIDGenerator) GenMultiIDs(ctx context.Context, counts int) ([]int64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GenMultiIDs", ctx, counts)
+	ret0, _ := ret[0].([]int64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GenMultiIDs indicates an expected call of GenMultiIDs.
+func (mr *MockIDGeneratorMockRecorder) GenMultiIDs(ctx, counts any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GenMultiIDs", reflect.TypeOf((*MockIDGenerator)(nil).GenMultiIDs), ctx, counts)
+}

backend/internal/mock/infra/contract/imagex/imagex_mock.go

@@ -0,0 +1,152 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: imagex.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/imagex/imagex_mock.go --package imagex -source imagex.go
+//
+
+// Package imagex is a generated GoMock package.
+package imagex
+
+import (
+	context "context"
+	reflect "reflect"
+	time "time"
+
+	gomock "go.uber.org/mock/gomock"
+
+	imagex "github.com/coze-dev/coze-studio/backend/infra/contract/imagex"
+)
+
+// MockImageX is a mock of ImageX interface.
+type MockImageX struct {
+	ctrl     *gomock.Controller
+	recorder *MockImageXMockRecorder
+	isgomock struct{}
+}
+
+// MockImageXMockRecorder is the mock recorder for MockImageX.
+type MockImageXMockRecorder struct {
+	mock *MockImageX
+}
+
+// NewMockImageX creates a new mock instance.
+func NewMockImageX(ctrl *gomock.Controller) *MockImageX {
+	mock := &MockImageX{ctrl: ctrl}
+	mock.recorder = &MockImageXMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockImageX) EXPECT() *MockImageXMockRecorder {
+	return m.recorder
+}
+
+// GetResourceURL mocks base method.
+func (m *MockImageX) GetResourceURL(ctx context.Context, uri string, opts ...imagex.GetResourceOpt) (*imagex.ResourceURL, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, uri}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetResourceURL", varargs...)
+	ret0, _ := ret[0].(*imagex.ResourceURL)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetResourceURL indicates an expected call of GetResourceURL.
+func (mr *MockImageXMockRecorder) GetResourceURL(ctx, uri any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, uri}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetResourceURL", reflect.TypeOf((*MockImageX)(nil).GetResourceURL), varargs...)
+}
+
+// GetServerID mocks base method.
+func (m *MockImageX) GetServerID() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetServerID")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetServerID indicates an expected call of GetServerID.
+func (mr *MockImageXMockRecorder) GetServerID() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetServerID", reflect.TypeOf((*MockImageX)(nil).GetServerID))
+}
+
+// GetUploadAuth mocks base method.
+func (m *MockImageX) GetUploadAuth(ctx context.Context, opt ...imagex.UploadAuthOpt) (*imagex.SecurityToken, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx}
+	for _, a := range opt {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUploadAuth", varargs...)
+	ret0, _ := ret[0].(*imagex.SecurityToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUploadAuth indicates an expected call of GetUploadAuth.
+func (mr *MockImageXMockRecorder) GetUploadAuth(ctx any, opt ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx}, opt...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadAuth", reflect.TypeOf((*MockImageX)(nil).GetUploadAuth), varargs...)
+}
+
+// GetUploadAuthWithExpire mocks base method.
+func (m *MockImageX) GetUploadAuthWithExpire(ctx context.Context, expire time.Duration, opt ...imagex.UploadAuthOpt) (*imagex.SecurityToken, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, expire}
+	for _, a := range opt {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetUploadAuthWithExpire", varargs...)
+	ret0, _ := ret[0].(*imagex.SecurityToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUploadAuthWithExpire indicates an expected call of GetUploadAuthWithExpire.
+func (mr *MockImageXMockRecorder) GetUploadAuthWithExpire(ctx, expire any, opt ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, expire}, opt...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadAuthWithExpire", reflect.TypeOf((*MockImageX)(nil).GetUploadAuthWithExpire), varargs...)
+}
+
+// GetUploadHost mocks base method.
+func (m *MockImageX) GetUploadHost() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUploadHost")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// GetUploadHost indicates an expected call of GetUploadHost.
+func (mr *MockImageXMockRecorder) GetUploadHost() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadHost", reflect.TypeOf((*MockImageX)(nil).GetUploadHost))
+}
+
+// Upload mocks base method.
+func (m *MockImageX) Upload(ctx context.Context, data []byte, opts ...imagex.UploadAuthOpt) (*imagex.UploadResult, error) {
+	m.ctrl.T.Helper()
+	varargs := []any{ctx, data}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "Upload", varargs...)
+	ret0, _ := ret[0].(*imagex.UploadResult)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Upload indicates an expected call of Upload.
+func (mr *MockImageXMockRecorder) Upload(ctx, data any, opts ...any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]any{ctx, data}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Upload", reflect.TypeOf((*MockImageX)(nil).Upload), varargs...)
+}

backend/internal/mock/infra/contract/orm/sqlitedb.go

@@ -0,0 +1,154 @@
+package orm
+
+import (
+	"fmt"
+	"reflect"
+
+	"gorm.io/driver/sqlite"
+	"gorm.io/gorm"
+	"gorm.io/gorm/logger"
+)
+
+// MockDB represents a test database setup helper
+type MockDB struct {
+	db     *gorm.DB
+	tables map[any]*Table
+}
+
+// NewMockDB creates a new MockDB instance
+func NewMockDB() *MockDB {
+	return &MockDB{
+		tables: make(map[any]*Table),
+	}
+}
+
+// AddTable adds a table to the test database
+func (s *MockDB) AddTable(tableModel any) *Table {
+	if tb, ok := s.tables[tableModel]; ok {
+		return tb
+	}
+
+	tb := &Table{
+		rows: make([]any, 0, 10),
+	}
+
+	s.tables[tableModel] = tb
+	return tb
+}
+
+type Table struct {
+	rows []any
+}
+
+func (t *Table) AddRows(rows ...any) *Table {
+	t.rows = append(t.rows, rows...)
+	return t
+}
+
+// DB returns the underlying gorm.DB instance
+func (s *MockDB) DB() (*gorm.DB, error) {
+	db, err := newSQLiteDB(":memory:")
+	if err != nil {
+		return nil, err
+	}
+	s.db = db
+
+	if err := s.setup(); err != nil {
+		return nil, err
+	}
+
+	return s.db, nil
+}
+
+func (s *MockDB) SharedDB(name string) (*gorm.DB, error) {
+	db, err := newSQLiteDB(fmt.Sprintf("file:%s?mode=memory&cache=shared", name))
+	if err != nil {
+		return nil, err
+	}
+	s.db = db
+
+	if err := s.setup(); err != nil {
+		return nil, err
+	}
+
+	return s.db, nil
+}
+
+// Close cleans up the test database
+func (s *MockDB) Close() error {
+	tables := make([]any, 0, len(s.tables))
+	for tb := range s.tables {
+		tables = append(tables, tb)
+	}
+	if err := s.tearDown(tables...); err != nil {
+		return fmt.Errorf("failed to tear down database: %w", err)
+	}
+	return nil
+}
+
+func (s *MockDB) setup() error {
+
+	for tableModel, tb := range s.tables {
+		// Create tables
+		if err := s.createTableFromStruct(tableModel); err != nil {
+			return fmt.Errorf("failed to create table: %w", err)
+		}
+
+		// Insert test data
+		if err := s.tearUp(tableModel, tb.rows); err != nil {
+			return fmt.Errorf("failed to insert test data: %w", err)
+		}
+	}
+
+	return nil
+}
+
+// newSQLiteDB creates a new in-memory SQLite database for testing
+func newSQLiteDB(dsn string) (*gorm.DB, error) {
+	db, err := gorm.Open(sqlite.Open(dsn), &gorm.Config{
+		Logger: logger.Default.LogMode(logger.Info),
+	})
+	if err != nil {
+		return nil, fmt.Errorf("failed to connect database: %w", err)
+	}
+	return db, nil
+}
+
+// createTableFromStruct creates a table in the database based on the provided struct
+func (s *MockDB) createTableFromStruct(model any) error {
+	if reflect.TypeOf(model).Kind() != reflect.Ptr {
+		return fmt.Errorf("model must be a pointer to struct")
+	}
+
+	return s.db.AutoMigrate(model)
+}
+
+// tearUp inserts test data into the database
+func (s *MockDB) tearUp(tableModel any, rows []any) error {
+	if len(rows) == 0 {
+		return nil
+	}
+
+	for _, row := range rows {
+		err := s.db.Model(tableModel).Create(row).Error
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// tearDown cleans up the test data
+func (s *MockDB) tearDown(models ...any) error {
+	for _, model := range models {
+		if err := s.db.Where("1 = 1").Delete(model).Error; err != nil {
+			return err
+		}
+
+		if err := s.db.Migrator().DropTable(model); err != nil {
+			return err
+		}
+	}
+	return nil
+}

backend/internal/mock/infra/contract/rdb/rdb_mock.go

@@ -0,0 +1,191 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: rdb.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/rdb/rdb_mock.go --package rdb -source rdb.go
+//
+
+// Package rdb is a generated GoMock package.
+package rdb
+
+import (
+	context "context"
+	reflect "reflect"
+
+	rdb "github.com/coze-dev/coze-studio/backend/infra/contract/rdb"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockRDB is a mock of RDB interface.
+type MockRDB struct {
+	ctrl     *gomock.Controller
+	recorder *MockRDBMockRecorder
+}
+
+// MockRDBMockRecorder is the mock recorder for MockRDB.
+type MockRDBMockRecorder struct {
+	mock *MockRDB
+}
+
+// NewMockRDB creates a new mock instance.
+func NewMockRDB(ctrl *gomock.Controller) *MockRDB {
+	mock := &MockRDB{ctrl: ctrl}
+	mock.recorder = &MockRDBMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockRDB) EXPECT() *MockRDBMockRecorder {
+	return m.recorder
+}
+
+// AlterTable mocks base method.
+func (m *MockRDB) AlterTable(ctx context.Context, req *rdb.AlterTableRequest) (*rdb.AlterTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "AlterTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.AlterTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// AlterTable indicates an expected call of AlterTable.
+func (mr *MockRDBMockRecorder) AlterTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AlterTable", reflect.TypeOf((*MockRDB)(nil).AlterTable), ctx, req)
+}
+
+// CreateTable mocks base method.
+func (m *MockRDB) CreateTable(ctx context.Context, req *rdb.CreateTableRequest) (*rdb.CreateTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "CreateTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.CreateTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// CreateTable indicates an expected call of CreateTable.
+func (mr *MockRDBMockRecorder) CreateTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateTable", reflect.TypeOf((*MockRDB)(nil).CreateTable), ctx, req)
+}
+
+// DeleteData mocks base method.
+func (m *MockRDB) DeleteData(ctx context.Context, req *rdb.DeleteDataRequest) (*rdb.DeleteDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteData", ctx, req)
+	ret0, _ := ret[0].(*rdb.DeleteDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DeleteData indicates an expected call of DeleteData.
+func (mr *MockRDBMockRecorder) DeleteData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteData", reflect.TypeOf((*MockRDB)(nil).DeleteData), ctx, req)
+}
+
+// DropTable mocks base method.
+func (m *MockRDB) DropTable(ctx context.Context, req *rdb.DropTableRequest) (*rdb.DropTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DropTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.DropTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// DropTable indicates an expected call of DropTable.
+func (mr *MockRDBMockRecorder) DropTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DropTable", reflect.TypeOf((*MockRDB)(nil).DropTable), ctx, req)
+}
+
+// ExecuteSQL mocks base method.
+func (m *MockRDB) ExecuteSQL(ctx context.Context, req *rdb.ExecuteSQLRequest) (*rdb.ExecuteSQLResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ExecuteSQL", ctx, req)
+	ret0, _ := ret[0].(*rdb.ExecuteSQLResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// ExecuteSQL indicates an expected call of ExecuteSQL.
+func (mr *MockRDBMockRecorder) ExecuteSQL(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ExecuteSQL", reflect.TypeOf((*MockRDB)(nil).ExecuteSQL), ctx, req)
+}
+
+// GetTable mocks base method.
+func (m *MockRDB) GetTable(ctx context.Context, req *rdb.GetTableRequest) (*rdb.GetTableResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetTable", ctx, req)
+	ret0, _ := ret[0].(*rdb.GetTableResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetTable indicates an expected call of GetTable.
+func (mr *MockRDBMockRecorder) GetTable(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTable", reflect.TypeOf((*MockRDB)(nil).GetTable), ctx, req)
+}
+
+// InsertData mocks base method.
+func (m *MockRDB) InsertData(ctx context.Context, req *rdb.InsertDataRequest) (*rdb.InsertDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "InsertData", ctx, req)
+	ret0, _ := ret[0].(*rdb.InsertDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// InsertData indicates an expected call of InsertData.
+func (mr *MockRDBMockRecorder) InsertData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "InsertData", reflect.TypeOf((*MockRDB)(nil).InsertData), ctx, req)
+}
+
+// SelectData mocks base method.
+func (m *MockRDB) SelectData(ctx context.Context, req *rdb.SelectDataRequest) (*rdb.SelectDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "SelectData", ctx, req)
+	ret0, _ := ret[0].(*rdb.SelectDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// SelectData indicates an expected call of SelectData.
+func (mr *MockRDBMockRecorder) SelectData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SelectData", reflect.TypeOf((*MockRDB)(nil).SelectData), ctx, req)
+}
+
+// UpdateData mocks base method.
+func (m *MockRDB) UpdateData(ctx context.Context, req *rdb.UpdateDataRequest) (*rdb.UpdateDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpdateData", ctx, req)
+	ret0, _ := ret[0].(*rdb.UpdateDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpdateData indicates an expected call of UpdateData.
+func (mr *MockRDBMockRecorder) UpdateData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdateData", reflect.TypeOf((*MockRDB)(nil).UpdateData), ctx, req)
+}
+
+// UpsertData mocks base method.
+func (m *MockRDB) UpsertData(ctx context.Context, req *rdb.UpsertDataRequest) (*rdb.UpsertDataResponse, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "UpsertData", ctx, req)
+	ret0, _ := ret[0].(*rdb.UpsertDataResponse)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// UpsertData indicates an expected call of UpsertData.
+func (mr *MockRDBMockRecorder) UpsertData(ctx, req any) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpsertData", reflect.TypeOf((*MockRDB)(nil).UpsertData), ctx, req)
+}

backend/internal/mock/infra/contract/storage/storage_mock.go

@@ -0,0 +1,125 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: storage.go
+//
+// Generated by this command:
+//
+//	mockgen -destination ../../../internal/mock/infra/contract/storage/storage_mock.go -package mock -source storage.go Factory
+//
+
+// Package mock is a generated GoMock package.
+package mock
+
+import (
+	context "context"
+	reflect "reflect"
+
+	storage "github.com/coze-dev/coze-studio/backend/infra/contract/storage"
+	gomock "go.uber.org/mock/gomock"
+)
+
+// MockStorage is a mock of Storage interface.
+type MockStorage struct {
+	ctrl     *gomock.Controller
+	recorder *MockStorageMockRecorder
+	isgomock struct{}
+}
+
+// MockStorageMockRecorder is the mock recorder for MockStorage.
+type MockStorageMockRecorder struct {
+	mock *MockStorage
+}
+
+// NewMockStorage creates a new mock instance.
+func NewMockStorage(ctrl *gomock.Controller) *MockStorage {
+	mock := &MockStorage{ctrl: ctrl}
+	mock.recorder = &MockStorageMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockStorage) EXPECT() *MockStorageMockRecorder {
+	return m.recorder
+}
+
+// DeleteObject mocks base method.
+func (m *MockStorage) DeleteObject(ctx context.Context, objectKey string) error {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "DeleteObject", ctx, objectKey)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// DeleteObject indicates an expected call of DeleteObject.
+func (mr *MockStorageMockRecorder) DeleteObject(ctx, objectKey interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DeleteObject", reflect.TypeOf((*MockStorage)(nil).DeleteObject), ctx, objectKey)
+}
+
+// GetObject mocks base method.
+func (m *MockStorage) GetObject(ctx context.Context, objectKey string) ([]byte, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetObject", ctx, objectKey)
+	ret0, _ := ret[0].([]byte)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetObject indicates an expected call of GetObject.
+func (mr *MockStorageMockRecorder) GetObject(ctx, objectKey interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObject", reflect.TypeOf((*MockStorage)(nil).GetObject), ctx, objectKey)
+}
+
+// GetObjectUrl mocks base method.
+func (m *MockStorage) GetObjectUrl(ctx context.Context, objectKey string, opts ...storage.GetOptFn) (string, error) {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, objectKey}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "GetObjectUrl", varargs...)
+	ret0, _ := ret[0].(string)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetObjectUrl indicates an expected call of GetObjectUrl.
+func (mr *MockStorageMockRecorder) GetObjectUrl(ctx, objectKey interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, objectKey}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetObjectUrl", reflect.TypeOf((*MockStorage)(nil).GetObjectUrl), varargs...)
+}
+
+// GetUploadAuth mocks base method.
+func (m *MockStorage) GetUploadAuth(ctx context.Context) (*storage.SecurityToken, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "GetUploadAuth", ctx)
+	ret0, _ := ret[0].(*storage.SecurityToken)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// GetUploadAuth indicates an expected call of GetUploadAuth.
+func (mr *MockStorageMockRecorder) GetUploadAuth(ctx interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetUploadAuth", reflect.TypeOf((*MockStorage)(nil).GetUploadAuth), ctx)
+}
+
+// PutObject mocks base method.
+func (m *MockStorage) PutObject(ctx context.Context, objectKey string, content []byte, opts ...storage.PutOptFn) error {
+	m.ctrl.T.Helper()
+	varargs := []interface{}{ctx, objectKey, content}
+	for _, a := range opts {
+		varargs = append(varargs, a)
+	}
+	ret := m.ctrl.Call(m, "PutObject", varargs...)
+	ret0, _ := ret[0].(error)
+	return ret0
+}
+
+// PutObject indicates an expected call of PutObject.
+func (mr *MockStorageMockRecorder) PutObject(ctx, objectKey, content interface{}, opts ...interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	varargs := append([]interface{}{ctx, objectKey, content}, opts...)
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PutObject", reflect.TypeOf((*MockStorage)(nil).PutObject), varargs...)
+}