diff --git a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common.go b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common.go
index 9439ea24c..d0d26f492 100644
--- a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common.go
+++ b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common.go
@@ -26,6 +26,8 @@ const (
 	RoleUser = "user"
 
 	RoleAssistant = "assistant"
+
+	AgentTypeVibe = "vibe"
 )
 
 // 内容类型枚举
@@ -34,6 +36,8 @@ type ContentType = string
 // 消息角色
 type Role = string
 
+type AgentType = string
+
 // 内容结构
 type Content struct {
 	ContentType *ContentType `thrift:"content_type,1,optional" frugal:"1,optional,string" form:"content_type" json:"content_type,omitempty" query:"content_type"`
@@ -5631,3 +5635,442 @@ func (p *Message) Field3DeepEqual(src map[string]string) bool {
 	}
 	return true
 }
+
+type AgentConfig struct {
+	AgentType *AgentType `thrift:"agent_type,1,optional" frugal:"1,optional,string" form:"agent_type" json:"agent_type,omitempty" query:"agent_type"`
+}
+
+func NewAgentConfig() *AgentConfig {
+	return &AgentConfig{}
+}
+
+func (p *AgentConfig) InitDefault() {
+}
+
+var AgentConfig_AgentType_DEFAULT AgentType
+
+func (p *AgentConfig) GetAgentType() (v AgentType) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetAgentType() {
+		return AgentConfig_AgentType_DEFAULT
+	}
+	return *p.AgentType
+}
+func (p *AgentConfig) SetAgentType(val *AgentType) {
+	p.AgentType = val
+}
+
+var fieldIDToName_AgentConfig = map[int16]string{
+	1: "agent_type",
+}
+
+func (p *AgentConfig) IsSetAgentType() bool {
+	return p.AgentType != nil
+}
+
+func (p *AgentConfig) Read(iprot thrift.TProtocol) (err error) {
+	var fieldTypeId thrift.TType
+	var fieldId int16
+
+	if _, err = iprot.ReadStructBegin(); err != nil {
+		goto ReadStructBeginError
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.STRING {
+				if err = p.ReadField1(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		default:
+			if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		}
+		if err = iprot.ReadFieldEnd(); err != nil {
+			goto ReadFieldEndError
+		}
+	}
+	if err = iprot.ReadStructEnd(); err != nil {
+		goto ReadStructEndError
+	}
+
+	return nil
+ReadStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
+ReadFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentConfig[fieldId]), err)
+SkipFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+
+ReadFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
+ReadStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+}
+
+func (p *AgentConfig) ReadField1(iprot thrift.TProtocol) error {
+
+	var _field *AgentType
+	if v, err := iprot.ReadString(); err != nil {
+		return err
+	} else {
+		_field = &v
+	}
+	p.AgentType = _field
+	return nil
+}
+
+func (p *AgentConfig) Write(oprot thrift.TProtocol) (err error) {
+	var fieldId int16
+	if err = oprot.WriteStructBegin("AgentConfig"); err != nil {
+		goto WriteStructBeginError
+	}
+	if p != nil {
+		if err = p.writeField1(oprot); err != nil {
+			fieldId = 1
+			goto WriteFieldError
+		}
+	}
+	if err = oprot.WriteFieldStop(); err != nil {
+		goto WriteFieldStopError
+	}
+	if err = oprot.WriteStructEnd(); err != nil {
+		goto WriteStructEndError
+	}
+	return nil
+WriteStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+WriteFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
+WriteFieldStopError:
+	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
+WriteStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
+}
+
+func (p *AgentConfig) writeField1(oprot thrift.TProtocol) (err error) {
+	if p.IsSetAgentType() {
+		if err = oprot.WriteFieldBegin("agent_type", thrift.STRING, 1); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := oprot.WriteString(*p.AgentType); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
+}
+
+func (p *AgentConfig) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("AgentConfig(%+v)", *p)
+
+}
+
+func (p *AgentConfig) DeepEqual(ano *AgentConfig) bool {
+	if p == ano {
+		return true
+	} else if p == nil || ano == nil {
+		return false
+	}
+	if !p.Field1DeepEqual(ano.AgentType) {
+		return false
+	}
+	return true
+}
+
+func (p *AgentConfig) Field1DeepEqual(src *AgentType) bool {
+
+	if p.AgentType == src {
+		return true
+	} else if p.AgentType == nil || src == nil {
+		return false
+	}
+	if strings.Compare(*p.AgentType, *src) != 0 {
+		return false
+	}
+	return true
+}
+
+type SkillConfig struct {
+	SkillID *int64  `thrift:"skill_id,1,optional" frugal:"1,optional,i64" json:"skill_id" form:"skill_id" query:"skill_id"`
+	Version *string `thrift:"version,2,optional" frugal:"2,optional,string" form:"version" json:"version,omitempty" query:"version"`
+}
+
+func NewSkillConfig() *SkillConfig {
+	return &SkillConfig{}
+}
+
+func (p *SkillConfig) InitDefault() {
+}
+
+var SkillConfig_SkillID_DEFAULT int64
+
+func (p *SkillConfig) GetSkillID() (v int64) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetSkillID() {
+		return SkillConfig_SkillID_DEFAULT
+	}
+	return *p.SkillID
+}
+
+var SkillConfig_Version_DEFAULT string
+
+func (p *SkillConfig) GetVersion() (v string) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetVersion() {
+		return SkillConfig_Version_DEFAULT
+	}
+	return *p.Version
+}
+func (p *SkillConfig) SetSkillID(val *int64) {
+	p.SkillID = val
+}
+func (p *SkillConfig) SetVersion(val *string) {
+	p.Version = val
+}
+
+var fieldIDToName_SkillConfig = map[int16]string{
+	1: "skill_id",
+	2: "version",
+}
+
+func (p *SkillConfig) IsSetSkillID() bool {
+	return p.SkillID != nil
+}
+
+func (p *SkillConfig) IsSetVersion() bool {
+	return p.Version != nil
+}
+
+func (p *SkillConfig) Read(iprot thrift.TProtocol) (err error) {
+	var fieldTypeId thrift.TType
+	var fieldId int16
+
+	if _, err = iprot.ReadStructBegin(); err != nil {
+		goto ReadStructBeginError
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.I64 {
+				if err = p.ReadField1(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 2:
+			if fieldTypeId == thrift.STRING {
+				if err = p.ReadField2(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		default:
+			if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		}
+		if err = iprot.ReadFieldEnd(); err != nil {
+			goto ReadFieldEndError
+		}
+	}
+	if err = iprot.ReadStructEnd(); err != nil {
+		goto ReadStructEndError
+	}
+
+	return nil
+ReadStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
+ReadFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_SkillConfig[fieldId]), err)
+SkipFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+
+ReadFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
+ReadStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+}
+
+func (p *SkillConfig) ReadField1(iprot thrift.TProtocol) error {
+
+	var _field *int64
+	if v, err := iprot.ReadI64(); err != nil {
+		return err
+	} else {
+		_field = &v
+	}
+	p.SkillID = _field
+	return nil
+}
+func (p *SkillConfig) ReadField2(iprot thrift.TProtocol) error {
+
+	var _field *string
+	if v, err := iprot.ReadString(); err != nil {
+		return err
+	} else {
+		_field = &v
+	}
+	p.Version = _field
+	return nil
+}
+
+func (p *SkillConfig) Write(oprot thrift.TProtocol) (err error) {
+	var fieldId int16
+	if err = oprot.WriteStructBegin("SkillConfig"); err != nil {
+		goto WriteStructBeginError
+	}
+	if p != nil {
+		if err = p.writeField1(oprot); err != nil {
+			fieldId = 1
+			goto WriteFieldError
+		}
+		if err = p.writeField2(oprot); err != nil {
+			fieldId = 2
+			goto WriteFieldError
+		}
+	}
+	if err = oprot.WriteFieldStop(); err != nil {
+		goto WriteFieldStopError
+	}
+	if err = oprot.WriteStructEnd(); err != nil {
+		goto WriteStructEndError
+	}
+	return nil
+WriteStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+WriteFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
+WriteFieldStopError:
+	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
+WriteStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
+}
+
+func (p *SkillConfig) writeField1(oprot thrift.TProtocol) (err error) {
+	if p.IsSetSkillID() {
+		if err = oprot.WriteFieldBegin("skill_id", thrift.I64, 1); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := oprot.WriteI64(*p.SkillID); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
+}
+func (p *SkillConfig) writeField2(oprot thrift.TProtocol) (err error) {
+	if p.IsSetVersion() {
+		if err = oprot.WriteFieldBegin("version", thrift.STRING, 2); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := oprot.WriteString(*p.Version); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
+}
+
+func (p *SkillConfig) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("SkillConfig(%+v)", *p)
+
+}
+
+func (p *SkillConfig) DeepEqual(ano *SkillConfig) bool {
+	if p == ano {
+		return true
+	} else if p == nil || ano == nil {
+		return false
+	}
+	if !p.Field1DeepEqual(ano.SkillID) {
+		return false
+	}
+	if !p.Field2DeepEqual(ano.Version) {
+		return false
+	}
+	return true
+}
+
+func (p *SkillConfig) Field1DeepEqual(src *int64) bool {
+
+	if p.SkillID == src {
+		return true
+	} else if p.SkillID == nil || src == nil {
+		return false
+	}
+	if *p.SkillID != *src {
+		return false
+	}
+	return true
+}
+func (p *SkillConfig) Field2DeepEqual(src *string) bool {
+
+	if p.Version == src {
+		return true
+	} else if p.Version == nil || src == nil {
+		return false
+	}
+	if strings.Compare(*p.Version, *src) != 0 {
+		return false
+	}
+	return true
+}
diff --git a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common_validator.go b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common_validator.go
index 072eee270..11f52d5d5 100644
--- a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common_validator.go
+++ b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/common_validator.go
@@ -101,3 +101,9 @@ func (p *Message) IsValid() error {
 	}
 	return nil
 }
+func (p *AgentConfig) IsValid() error {
+	return nil
+}
+func (p *SkillConfig) IsValid() error {
+	return nil
+}
diff --git a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/k-common.go b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/k-common.go
index 195ec4b0d..d88014888 100644
--- a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/k-common.go
+++ b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common/k-common.go
@@ -3923,3 +3923,293 @@ func (p *Message) DeepCopy(s interface{}) error {
 
 	return nil
 }
+
+func (p *AgentConfig) FastRead(buf []byte) (int, error) {
+
+	var err error
+	var offset int
+	var l int
+	var fieldTypeId thrift.TType
+	var fieldId int16
+	for {
+		fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:])
+		offset += l
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.STRING {
+				l, err = p.FastReadField1(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		default:
+			l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+			offset += l
+			if err != nil {
+				goto SkipFieldError
+			}
+		}
+	}
+
+	return offset, nil
+ReadFieldBeginError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentConfig[fieldId]), err)
+SkipFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+}
+
+func (p *AgentConfig) FastReadField1(buf []byte) (int, error) {
+	offset := 0
+
+	var _field *AgentType
+	if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+		_field = &v
+	}
+	p.AgentType = _field
+	return offset, nil
+}
+
+func (p *AgentConfig) FastWrite(buf []byte) int {
+	return p.FastWriteNocopy(buf, nil)
+}
+
+func (p *AgentConfig) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p != nil {
+		offset += p.fastWriteField1(buf[offset:], w)
+	}
+	offset += thrift.Binary.WriteFieldStop(buf[offset:])
+	return offset
+}
+
+func (p *AgentConfig) BLength() int {
+	l := 0
+	if p != nil {
+		l += p.field1Length()
+	}
+	l += thrift.Binary.FieldStopLength()
+	return l
+}
+
+func (p *AgentConfig) fastWriteField1(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetAgentType() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 1)
+		offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.AgentType)
+	}
+	return offset
+}
+
+func (p *AgentConfig) field1Length() int {
+	l := 0
+	if p.IsSetAgentType() {
+		l += thrift.Binary.FieldBeginLength()
+		l += thrift.Binary.StringLengthNocopy(*p.AgentType)
+	}
+	return l
+}
+
+func (p *AgentConfig) DeepCopy(s interface{}) error {
+	src, ok := s.(*AgentConfig)
+	if !ok {
+		return fmt.Errorf("%T's type not matched %T", s, p)
+	}
+
+	if src.AgentType != nil {
+		tmp := *src.AgentType
+		p.AgentType = &tmp
+	}
+
+	return nil
+}
+
+func (p *SkillConfig) FastRead(buf []byte) (int, error) {
+
+	var err error
+	var offset int
+	var l int
+	var fieldTypeId thrift.TType
+	var fieldId int16
+	for {
+		fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:])
+		offset += l
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.I64 {
+				l, err = p.FastReadField1(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 2:
+			if fieldTypeId == thrift.STRING {
+				l, err = p.FastReadField2(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		default:
+			l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+			offset += l
+			if err != nil {
+				goto SkipFieldError
+			}
+		}
+	}
+
+	return offset, nil
+ReadFieldBeginError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_SkillConfig[fieldId]), err)
+SkipFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+}
+
+func (p *SkillConfig) FastReadField1(buf []byte) (int, error) {
+	offset := 0
+
+	var _field *int64
+	if v, l, err := thrift.Binary.ReadI64(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+		_field = &v
+	}
+	p.SkillID = _field
+	return offset, nil
+}
+
+func (p *SkillConfig) FastReadField2(buf []byte) (int, error) {
+	offset := 0
+
+	var _field *string
+	if v, l, err := thrift.Binary.ReadString(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+		_field = &v
+	}
+	p.Version = _field
+	return offset, nil
+}
+
+func (p *SkillConfig) FastWrite(buf []byte) int {
+	return p.FastWriteNocopy(buf, nil)
+}
+
+func (p *SkillConfig) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p != nil {
+		offset += p.fastWriteField1(buf[offset:], w)
+		offset += p.fastWriteField2(buf[offset:], w)
+	}
+	offset += thrift.Binary.WriteFieldStop(buf[offset:])
+	return offset
+}
+
+func (p *SkillConfig) BLength() int {
+	l := 0
+	if p != nil {
+		l += p.field1Length()
+		l += p.field2Length()
+	}
+	l += thrift.Binary.FieldStopLength()
+	return l
+}
+
+func (p *SkillConfig) fastWriteField1(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetSkillID() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.I64, 1)
+		offset += thrift.Binary.WriteI64(buf[offset:], *p.SkillID)
+	}
+	return offset
+}
+
+func (p *SkillConfig) fastWriteField2(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetVersion() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRING, 2)
+		offset += thrift.Binary.WriteStringNocopy(buf[offset:], w, *p.Version)
+	}
+	return offset
+}
+
+func (p *SkillConfig) field1Length() int {
+	l := 0
+	if p.IsSetSkillID() {
+		l += thrift.Binary.FieldBeginLength()
+		l += thrift.Binary.I64Length()
+	}
+	return l
+}
+
+func (p *SkillConfig) field2Length() int {
+	l := 0
+	if p.IsSetVersion() {
+		l += thrift.Binary.FieldBeginLength()
+		l += thrift.Binary.StringLengthNocopy(*p.Version)
+	}
+	return l
+}
+
+func (p *SkillConfig) DeepCopy(s interface{}) error {
+	src, ok := s.(*SkillConfig)
+	if !ok {
+		return fmt.Errorf("%T's type not matched %T", s, p)
+	}
+
+	if src.SkillID != nil {
+		tmp := *src.SkillID
+		p.SkillID = &tmp
+	}
+
+	if src.Version != nil {
+		var tmp string
+		if *src.Version != "" {
+			tmp = kutils.StringDeepCopy(*src.Version)
+		}
+		p.Version = &tmp
+	}
+
+	return nil
+}
diff --git a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator.go b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator.go
index 3a6775293..c2341025d 100644
--- a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator.go
+++ b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator.go
@@ -1591,6 +1591,1000 @@ func (p *CustomRPCEvaluator) Field12DeepEqual(src map[string]string) bool {
 	return true
 }
 
+// Agent评估器Prompt配置输出规则
+type AgentEvaluatorPromptConfigOutputRules struct {
+	ScorePrompt       *common.Message `thrift:"score_prompt,1,optional" frugal:"1,optional,common.Message" form:"score_prompt" json:"score_prompt,omitempty" query:"score_prompt"`
+	ReasoningPrompt   *common.Message `thrift:"reasoning_prompt,2,optional" frugal:"2,optional,common.Message" form:"reasoning_prompt" json:"reasoning_prompt,omitempty" query:"reasoning_prompt"`
+	ExtraOutputPrompt *common.Message `thrift:"extra_output_prompt,3,optional" frugal:"3,optional,common.Message" form:"extra_output_prompt" json:"extra_output_prompt,omitempty" query:"extra_output_prompt"`
+}
+
+func NewAgentEvaluatorPromptConfigOutputRules() *AgentEvaluatorPromptConfigOutputRules {
+	return &AgentEvaluatorPromptConfigOutputRules{}
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) InitDefault() {
+}
+
+var AgentEvaluatorPromptConfigOutputRules_ScorePrompt_DEFAULT *common.Message
+
+func (p *AgentEvaluatorPromptConfigOutputRules) GetScorePrompt() (v *common.Message) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetScorePrompt() {
+		return AgentEvaluatorPromptConfigOutputRules_ScorePrompt_DEFAULT
+	}
+	return p.ScorePrompt
+}
+
+var AgentEvaluatorPromptConfigOutputRules_ReasoningPrompt_DEFAULT *common.Message
+
+func (p *AgentEvaluatorPromptConfigOutputRules) GetReasoningPrompt() (v *common.Message) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetReasoningPrompt() {
+		return AgentEvaluatorPromptConfigOutputRules_ReasoningPrompt_DEFAULT
+	}
+	return p.ReasoningPrompt
+}
+
+var AgentEvaluatorPromptConfigOutputRules_ExtraOutputPrompt_DEFAULT *common.Message
+
+func (p *AgentEvaluatorPromptConfigOutputRules) GetExtraOutputPrompt() (v *common.Message) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetExtraOutputPrompt() {
+		return AgentEvaluatorPromptConfigOutputRules_ExtraOutputPrompt_DEFAULT
+	}
+	return p.ExtraOutputPrompt
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) SetScorePrompt(val *common.Message) {
+	p.ScorePrompt = val
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) SetReasoningPrompt(val *common.Message) {
+	p.ReasoningPrompt = val
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) SetExtraOutputPrompt(val *common.Message) {
+	p.ExtraOutputPrompt = val
+}
+
+var fieldIDToName_AgentEvaluatorPromptConfigOutputRules = map[int16]string{
+	1: "score_prompt",
+	2: "reasoning_prompt",
+	3: "extra_output_prompt",
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) IsSetScorePrompt() bool {
+	return p.ScorePrompt != nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) IsSetReasoningPrompt() bool {
+	return p.ReasoningPrompt != nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) IsSetExtraOutputPrompt() bool {
+	return p.ExtraOutputPrompt != nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) Read(iprot thrift.TProtocol) (err error) {
+	var fieldTypeId thrift.TType
+	var fieldId int16
+
+	if _, err = iprot.ReadStructBegin(); err != nil {
+		goto ReadStructBeginError
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField1(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 2:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField2(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 3:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField3(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		default:
+			if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		}
+		if err = iprot.ReadFieldEnd(); err != nil {
+			goto ReadFieldEndError
+		}
+	}
+	if err = iprot.ReadStructEnd(); err != nil {
+		goto ReadStructEndError
+	}
+
+	return nil
+ReadStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
+ReadFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentEvaluatorPromptConfigOutputRules[fieldId]), err)
+SkipFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+
+ReadFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
+ReadStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) ReadField1(iprot thrift.TProtocol) error {
+	_field := common.NewMessage()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.ScorePrompt = _field
+	return nil
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) ReadField2(iprot thrift.TProtocol) error {
+	_field := common.NewMessage()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.ReasoningPrompt = _field
+	return nil
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) ReadField3(iprot thrift.TProtocol) error {
+	_field := common.NewMessage()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.ExtraOutputPrompt = _field
+	return nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) Write(oprot thrift.TProtocol) (err error) {
+	var fieldId int16
+	if err = oprot.WriteStructBegin("AgentEvaluatorPromptConfigOutputRules"); err != nil {
+		goto WriteStructBeginError
+	}
+	if p != nil {
+		if err = p.writeField1(oprot); err != nil {
+			fieldId = 1
+			goto WriteFieldError
+		}
+		if err = p.writeField2(oprot); err != nil {
+			fieldId = 2
+			goto WriteFieldError
+		}
+		if err = p.writeField3(oprot); err != nil {
+			fieldId = 3
+			goto WriteFieldError
+		}
+	}
+	if err = oprot.WriteFieldStop(); err != nil {
+		goto WriteFieldStopError
+	}
+	if err = oprot.WriteStructEnd(); err != nil {
+		goto WriteStructEndError
+	}
+	return nil
+WriteStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+WriteFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
+WriteFieldStopError:
+	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
+WriteStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) writeField1(oprot thrift.TProtocol) (err error) {
+	if p.IsSetScorePrompt() {
+		if err = oprot.WriteFieldBegin("score_prompt", thrift.STRUCT, 1); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.ScorePrompt.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) writeField2(oprot thrift.TProtocol) (err error) {
+	if p.IsSetReasoningPrompt() {
+		if err = oprot.WriteFieldBegin("reasoning_prompt", thrift.STRUCT, 2); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.ReasoningPrompt.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) writeField3(oprot thrift.TProtocol) (err error) {
+	if p.IsSetExtraOutputPrompt() {
+		if err = oprot.WriteFieldBegin("extra_output_prompt", thrift.STRUCT, 3); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.ExtraOutputPrompt.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("AgentEvaluatorPromptConfigOutputRules(%+v)", *p)
+
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) DeepEqual(ano *AgentEvaluatorPromptConfigOutputRules) bool {
+	if p == ano {
+		return true
+	} else if p == nil || ano == nil {
+		return false
+	}
+	if !p.Field1DeepEqual(ano.ScorePrompt) {
+		return false
+	}
+	if !p.Field2DeepEqual(ano.ReasoningPrompt) {
+		return false
+	}
+	if !p.Field3DeepEqual(ano.ExtraOutputPrompt) {
+		return false
+	}
+	return true
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) Field1DeepEqual(src *common.Message) bool {
+
+	if !p.ScorePrompt.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) Field2DeepEqual(src *common.Message) bool {
+
+	if !p.ReasoningPrompt.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+func (p *AgentEvaluatorPromptConfigOutputRules) Field3DeepEqual(src *common.Message) bool {
+
+	if !p.ExtraOutputPrompt.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+
+// Agent评估器Prompt配置
+type AgentEvaluatorPromptConfig struct {
+	MessageList []*common.Message                      `thrift:"message_list,1,optional" frugal:"1,optional,list<common.Message>" form:"message_list" json:"message_list,omitempty" query:"message_list"`
+	OutputRules *AgentEvaluatorPromptConfigOutputRules `thrift:"output_rules,2,optional" frugal:"2,optional,AgentEvaluatorPromptConfigOutputRules" form:"output_rules" json:"output_rules,omitempty" query:"output_rules"`
+}
+
+func NewAgentEvaluatorPromptConfig() *AgentEvaluatorPromptConfig {
+	return &AgentEvaluatorPromptConfig{}
+}
+
+func (p *AgentEvaluatorPromptConfig) InitDefault() {
+}
+
+var AgentEvaluatorPromptConfig_MessageList_DEFAULT []*common.Message
+
+func (p *AgentEvaluatorPromptConfig) GetMessageList() (v []*common.Message) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetMessageList() {
+		return AgentEvaluatorPromptConfig_MessageList_DEFAULT
+	}
+	return p.MessageList
+}
+
+var AgentEvaluatorPromptConfig_OutputRules_DEFAULT *AgentEvaluatorPromptConfigOutputRules
+
+func (p *AgentEvaluatorPromptConfig) GetOutputRules() (v *AgentEvaluatorPromptConfigOutputRules) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetOutputRules() {
+		return AgentEvaluatorPromptConfig_OutputRules_DEFAULT
+	}
+	return p.OutputRules
+}
+func (p *AgentEvaluatorPromptConfig) SetMessageList(val []*common.Message) {
+	p.MessageList = val
+}
+func (p *AgentEvaluatorPromptConfig) SetOutputRules(val *AgentEvaluatorPromptConfigOutputRules) {
+	p.OutputRules = val
+}
+
+var fieldIDToName_AgentEvaluatorPromptConfig = map[int16]string{
+	1: "message_list",
+	2: "output_rules",
+}
+
+func (p *AgentEvaluatorPromptConfig) IsSetMessageList() bool {
+	return p.MessageList != nil
+}
+
+func (p *AgentEvaluatorPromptConfig) IsSetOutputRules() bool {
+	return p.OutputRules != nil
+}
+
+func (p *AgentEvaluatorPromptConfig) Read(iprot thrift.TProtocol) (err error) {
+	var fieldTypeId thrift.TType
+	var fieldId int16
+
+	if _, err = iprot.ReadStructBegin(); err != nil {
+		goto ReadStructBeginError
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.LIST {
+				if err = p.ReadField1(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 2:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField2(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		default:
+			if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		}
+		if err = iprot.ReadFieldEnd(); err != nil {
+			goto ReadFieldEndError
+		}
+	}
+	if err = iprot.ReadStructEnd(); err != nil {
+		goto ReadStructEndError
+	}
+
+	return nil
+ReadStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
+ReadFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentEvaluatorPromptConfig[fieldId]), err)
+SkipFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+
+ReadFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
+ReadStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+}
+
+func (p *AgentEvaluatorPromptConfig) ReadField1(iprot thrift.TProtocol) error {
+	_, size, err := iprot.ReadListBegin()
+	if err != nil {
+		return err
+	}
+	_field := make([]*common.Message, 0, size)
+	values := make([]common.Message, size)
+	for i := 0; i < size; i++ {
+		_elem := &values[i]
+		_elem.InitDefault()
+
+		if err := _elem.Read(iprot); err != nil {
+			return err
+		}
+
+		_field = append(_field, _elem)
+	}
+	if err := iprot.ReadListEnd(); err != nil {
+		return err
+	}
+	p.MessageList = _field
+	return nil
+}
+func (p *AgentEvaluatorPromptConfig) ReadField2(iprot thrift.TProtocol) error {
+	_field := NewAgentEvaluatorPromptConfigOutputRules()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.OutputRules = _field
+	return nil
+}
+
+func (p *AgentEvaluatorPromptConfig) Write(oprot thrift.TProtocol) (err error) {
+	var fieldId int16
+	if err = oprot.WriteStructBegin("AgentEvaluatorPromptConfig"); err != nil {
+		goto WriteStructBeginError
+	}
+	if p != nil {
+		if err = p.writeField1(oprot); err != nil {
+			fieldId = 1
+			goto WriteFieldError
+		}
+		if err = p.writeField2(oprot); err != nil {
+			fieldId = 2
+			goto WriteFieldError
+		}
+	}
+	if err = oprot.WriteFieldStop(); err != nil {
+		goto WriteFieldStopError
+	}
+	if err = oprot.WriteStructEnd(); err != nil {
+		goto WriteStructEndError
+	}
+	return nil
+WriteStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+WriteFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
+WriteFieldStopError:
+	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
+WriteStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
+}
+
+func (p *AgentEvaluatorPromptConfig) writeField1(oprot thrift.TProtocol) (err error) {
+	if p.IsSetMessageList() {
+		if err = oprot.WriteFieldBegin("message_list", thrift.LIST, 1); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.MessageList)); err != nil {
+			return err
+		}
+		for _, v := range p.MessageList {
+			if err := v.Write(oprot); err != nil {
+				return err
+			}
+		}
+		if err := oprot.WriteListEnd(); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
+}
+func (p *AgentEvaluatorPromptConfig) writeField2(oprot thrift.TProtocol) (err error) {
+	if p.IsSetOutputRules() {
+		if err = oprot.WriteFieldBegin("output_rules", thrift.STRUCT, 2); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.OutputRules.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
+}
+
+func (p *AgentEvaluatorPromptConfig) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("AgentEvaluatorPromptConfig(%+v)", *p)
+
+}
+
+func (p *AgentEvaluatorPromptConfig) DeepEqual(ano *AgentEvaluatorPromptConfig) bool {
+	if p == ano {
+		return true
+	} else if p == nil || ano == nil {
+		return false
+	}
+	if !p.Field1DeepEqual(ano.MessageList) {
+		return false
+	}
+	if !p.Field2DeepEqual(ano.OutputRules) {
+		return false
+	}
+	return true
+}
+
+func (p *AgentEvaluatorPromptConfig) Field1DeepEqual(src []*common.Message) bool {
+
+	if len(p.MessageList) != len(src) {
+		return false
+	}
+	for i, v := range p.MessageList {
+		_src := src[i]
+		if !v.DeepEqual(_src) {
+			return false
+		}
+	}
+	return true
+}
+func (p *AgentEvaluatorPromptConfig) Field2DeepEqual(src *AgentEvaluatorPromptConfigOutputRules) bool {
+
+	if !p.OutputRules.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+
+// Agent评估器
+type AgentEvaluator struct {
+	AgentConfig  *common.AgentConfig         `thrift:"agent_config,1,optional" frugal:"1,optional,common.AgentConfig" form:"agent_config" json:"agent_config,omitempty" query:"agent_config"`
+	ModelConfig  *common.ModelConfig         `thrift:"model_config,2,optional" frugal:"2,optional,common.ModelConfig" form:"model_config" json:"model_config,omitempty" query:"model_config"`
+	SkillConfigs []*common.SkillConfig       `thrift:"skill_configs,3,optional" frugal:"3,optional,list<common.SkillConfig>" form:"skill_configs" json:"skill_configs,omitempty" query:"skill_configs"`
+	PromptConfig *AgentEvaluatorPromptConfig `thrift:"prompt_config,4,optional" frugal:"4,optional,AgentEvaluatorPromptConfig" form:"prompt_config" json:"prompt_config,omitempty" query:"prompt_config"`
+}
+
+func NewAgentEvaluator() *AgentEvaluator {
+	return &AgentEvaluator{}
+}
+
+func (p *AgentEvaluator) InitDefault() {
+}
+
+var AgentEvaluator_AgentConfig_DEFAULT *common.AgentConfig
+
+func (p *AgentEvaluator) GetAgentConfig() (v *common.AgentConfig) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetAgentConfig() {
+		return AgentEvaluator_AgentConfig_DEFAULT
+	}
+	return p.AgentConfig
+}
+
+var AgentEvaluator_ModelConfig_DEFAULT *common.ModelConfig
+
+func (p *AgentEvaluator) GetModelConfig() (v *common.ModelConfig) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetModelConfig() {
+		return AgentEvaluator_ModelConfig_DEFAULT
+	}
+	return p.ModelConfig
+}
+
+var AgentEvaluator_SkillConfigs_DEFAULT []*common.SkillConfig
+
+func (p *AgentEvaluator) GetSkillConfigs() (v []*common.SkillConfig) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetSkillConfigs() {
+		return AgentEvaluator_SkillConfigs_DEFAULT
+	}
+	return p.SkillConfigs
+}
+
+var AgentEvaluator_PromptConfig_DEFAULT *AgentEvaluatorPromptConfig
+
+func (p *AgentEvaluator) GetPromptConfig() (v *AgentEvaluatorPromptConfig) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetPromptConfig() {
+		return AgentEvaluator_PromptConfig_DEFAULT
+	}
+	return p.PromptConfig
+}
+func (p *AgentEvaluator) SetAgentConfig(val *common.AgentConfig) {
+	p.AgentConfig = val
+}
+func (p *AgentEvaluator) SetModelConfig(val *common.ModelConfig) {
+	p.ModelConfig = val
+}
+func (p *AgentEvaluator) SetSkillConfigs(val []*common.SkillConfig) {
+	p.SkillConfigs = val
+}
+func (p *AgentEvaluator) SetPromptConfig(val *AgentEvaluatorPromptConfig) {
+	p.PromptConfig = val
+}
+
+var fieldIDToName_AgentEvaluator = map[int16]string{
+	1: "agent_config",
+	2: "model_config",
+	3: "skill_configs",
+	4: "prompt_config",
+}
+
+func (p *AgentEvaluator) IsSetAgentConfig() bool {
+	return p.AgentConfig != nil
+}
+
+func (p *AgentEvaluator) IsSetModelConfig() bool {
+	return p.ModelConfig != nil
+}
+
+func (p *AgentEvaluator) IsSetSkillConfigs() bool {
+	return p.SkillConfigs != nil
+}
+
+func (p *AgentEvaluator) IsSetPromptConfig() bool {
+	return p.PromptConfig != nil
+}
+
+func (p *AgentEvaluator) Read(iprot thrift.TProtocol) (err error) {
+	var fieldTypeId thrift.TType
+	var fieldId int16
+
+	if _, err = iprot.ReadStructBegin(); err != nil {
+		goto ReadStructBeginError
+	}
+
+	for {
+		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField1(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 2:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField2(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 3:
+			if fieldTypeId == thrift.LIST {
+				if err = p.ReadField3(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		case 4:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField4(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		default:
+			if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
+		}
+		if err = iprot.ReadFieldEnd(); err != nil {
+			goto ReadFieldEndError
+		}
+	}
+	if err = iprot.ReadStructEnd(); err != nil {
+		goto ReadStructEndError
+	}
+
+	return nil
+ReadStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
+ReadFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentEvaluator[fieldId]), err)
+SkipFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+
+ReadFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
+ReadStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
+}
+
+func (p *AgentEvaluator) ReadField1(iprot thrift.TProtocol) error {
+	_field := common.NewAgentConfig()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.AgentConfig = _field
+	return nil
+}
+func (p *AgentEvaluator) ReadField2(iprot thrift.TProtocol) error {
+	_field := common.NewModelConfig()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.ModelConfig = _field
+	return nil
+}
+func (p *AgentEvaluator) ReadField3(iprot thrift.TProtocol) error {
+	_, size, err := iprot.ReadListBegin()
+	if err != nil {
+		return err
+	}
+	_field := make([]*common.SkillConfig, 0, size)
+	values := make([]common.SkillConfig, size)
+	for i := 0; i < size; i++ {
+		_elem := &values[i]
+		_elem.InitDefault()
+
+		if err := _elem.Read(iprot); err != nil {
+			return err
+		}
+
+		_field = append(_field, _elem)
+	}
+	if err := iprot.ReadListEnd(); err != nil {
+		return err
+	}
+	p.SkillConfigs = _field
+	return nil
+}
+func (p *AgentEvaluator) ReadField4(iprot thrift.TProtocol) error {
+	_field := NewAgentEvaluatorPromptConfig()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.PromptConfig = _field
+	return nil
+}
+
+func (p *AgentEvaluator) Write(oprot thrift.TProtocol) (err error) {
+	var fieldId int16
+	if err = oprot.WriteStructBegin("AgentEvaluator"); err != nil {
+		goto WriteStructBeginError
+	}
+	if p != nil {
+		if err = p.writeField1(oprot); err != nil {
+			fieldId = 1
+			goto WriteFieldError
+		}
+		if err = p.writeField2(oprot); err != nil {
+			fieldId = 2
+			goto WriteFieldError
+		}
+		if err = p.writeField3(oprot); err != nil {
+			fieldId = 3
+			goto WriteFieldError
+		}
+		if err = p.writeField4(oprot); err != nil {
+			fieldId = 4
+			goto WriteFieldError
+		}
+	}
+	if err = oprot.WriteFieldStop(); err != nil {
+		goto WriteFieldStopError
+	}
+	if err = oprot.WriteStructEnd(); err != nil {
+		goto WriteStructEndError
+	}
+	return nil
+WriteStructBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
+WriteFieldError:
+	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
+WriteFieldStopError:
+	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
+WriteStructEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
+}
+
+func (p *AgentEvaluator) writeField1(oprot thrift.TProtocol) (err error) {
+	if p.IsSetAgentConfig() {
+		if err = oprot.WriteFieldBegin("agent_config", thrift.STRUCT, 1); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.AgentConfig.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
+}
+func (p *AgentEvaluator) writeField2(oprot thrift.TProtocol) (err error) {
+	if p.IsSetModelConfig() {
+		if err = oprot.WriteFieldBegin("model_config", thrift.STRUCT, 2); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.ModelConfig.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
+}
+func (p *AgentEvaluator) writeField3(oprot thrift.TProtocol) (err error) {
+	if p.IsSetSkillConfigs() {
+		if err = oprot.WriteFieldBegin("skill_configs", thrift.LIST, 3); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := oprot.WriteListBegin(thrift.STRUCT, len(p.SkillConfigs)); err != nil {
+			return err
+		}
+		for _, v := range p.SkillConfigs {
+			if err := v.Write(oprot); err != nil {
+				return err
+			}
+		}
+		if err := oprot.WriteListEnd(); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
+}
+func (p *AgentEvaluator) writeField4(oprot thrift.TProtocol) (err error) {
+	if p.IsSetPromptConfig() {
+		if err = oprot.WriteFieldBegin("prompt_config", thrift.STRUCT, 4); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.PromptConfig.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err)
+}
+
+func (p *AgentEvaluator) String() string {
+	if p == nil {
+		return "<nil>"
+	}
+	return fmt.Sprintf("AgentEvaluator(%+v)", *p)
+
+}
+
+func (p *AgentEvaluator) DeepEqual(ano *AgentEvaluator) bool {
+	if p == ano {
+		return true
+	} else if p == nil || ano == nil {
+		return false
+	}
+	if !p.Field1DeepEqual(ano.AgentConfig) {
+		return false
+	}
+	if !p.Field2DeepEqual(ano.ModelConfig) {
+		return false
+	}
+	if !p.Field3DeepEqual(ano.SkillConfigs) {
+		return false
+	}
+	if !p.Field4DeepEqual(ano.PromptConfig) {
+		return false
+	}
+	return true
+}
+
+func (p *AgentEvaluator) Field1DeepEqual(src *common.AgentConfig) bool {
+
+	if !p.AgentConfig.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+func (p *AgentEvaluator) Field2DeepEqual(src *common.ModelConfig) bool {
+
+	if !p.ModelConfig.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+func (p *AgentEvaluator) Field3DeepEqual(src []*common.SkillConfig) bool {
+
+	if len(p.SkillConfigs) != len(src) {
+		return false
+	}
+	for i, v := range p.SkillConfigs {
+		_src := src[i]
+		if !v.DeepEqual(_src) {
+			return false
+		}
+	}
+	return true
+}
+func (p *AgentEvaluator) Field4DeepEqual(src *AgentEvaluatorPromptConfig) bool {
+
+	if !p.PromptConfig.DeepEqual(src) {
+		return false
+	}
+	return true
+}
+
 // 评估器内容
 type EvaluatorContent struct {
 	IsReceiveChatHistory *bool                `thrift:"is_receive_chat_history,1,optional" frugal:"1,optional,bool" form:"is_receive_chat_history" json:"is_receive_chat_history,omitempty" query:"is_receive_chat_history"`
@@ -1600,6 +2594,7 @@ type EvaluatorContent struct {
 	PromptEvaluator    *PromptEvaluator    `thrift:"prompt_evaluator,101,optional" frugal:"101,optional,PromptEvaluator" form:"prompt_evaluator" json:"prompt_evaluator,omitempty" query:"prompt_evaluator"`
 	CodeEvaluator      *CodeEvaluator      `thrift:"code_evaluator,102,optional" frugal:"102,optional,CodeEvaluator" form:"code_evaluator" json:"code_evaluator,omitempty" query:"code_evaluator"`
 	CustomRPCEvaluator *CustomRPCEvaluator `thrift:"custom_rpc_evaluator,103,optional" frugal:"103,optional,CustomRPCEvaluator" form:"custom_rpc_evaluator" json:"custom_rpc_evaluator,omitempty" query:"custom_rpc_evaluator"`
+	AgentEvaluator     *AgentEvaluator     `thrift:"agent_evaluator,104,optional" frugal:"104,optional,AgentEvaluator" form:"agent_evaluator" json:"agent_evaluator,omitempty" query:"agent_evaluator"`
 }
 
 func NewEvaluatorContent() *EvaluatorContent {
@@ -1680,6 +2675,18 @@ func (p *EvaluatorContent) GetCustomRPCEvaluator() (v *CustomRPCEvaluator) {
 	}
 	return p.CustomRPCEvaluator
 }
+
+var EvaluatorContent_AgentEvaluator_DEFAULT *AgentEvaluator
+
+func (p *EvaluatorContent) GetAgentEvaluator() (v *AgentEvaluator) {
+	if p == nil {
+		return
+	}
+	if !p.IsSetAgentEvaluator() {
+		return EvaluatorContent_AgentEvaluator_DEFAULT
+	}
+	return p.AgentEvaluator
+}
 func (p *EvaluatorContent) SetIsReceiveChatHistory(val *bool) {
 	p.IsReceiveChatHistory = val
 }
@@ -1698,6 +2705,9 @@ func (p *EvaluatorContent) SetCodeEvaluator(val *CodeEvaluator) {
 func (p *EvaluatorContent) SetCustomRPCEvaluator(val *CustomRPCEvaluator) {
 	p.CustomRPCEvaluator = val
 }
+func (p *EvaluatorContent) SetAgentEvaluator(val *AgentEvaluator) {
+	p.AgentEvaluator = val
+}
 
 var fieldIDToName_EvaluatorContent = map[int16]string{
 	1:   "is_receive_chat_history",
@@ -1706,6 +2716,7 @@ var fieldIDToName_EvaluatorContent = map[int16]string{
 	101: "prompt_evaluator",
 	102: "code_evaluator",
 	103: "custom_rpc_evaluator",
+	104: "agent_evaluator",
 }
 
 func (p *EvaluatorContent) IsSetIsReceiveChatHistory() bool {
@@ -1732,6 +2743,10 @@ func (p *EvaluatorContent) IsSetCustomRPCEvaluator() bool {
 	return p.CustomRPCEvaluator != nil
 }
 
+func (p *EvaluatorContent) IsSetAgentEvaluator() bool {
+	return p.AgentEvaluator != nil
+}
+
 func (p *EvaluatorContent) Read(iprot thrift.TProtocol) (err error) {
 	var fieldTypeId thrift.TType
 	var fieldId int16
@@ -1798,6 +2813,14 @@ func (p *EvaluatorContent) Read(iprot thrift.TProtocol) (err error) {
 			} else if err = iprot.Skip(fieldTypeId); err != nil {
 				goto SkipFieldError
 			}
+		case 104:
+			if fieldTypeId == thrift.STRUCT {
+				if err = p.ReadField104(iprot); err != nil {
+					goto ReadFieldError
+				}
+			} else if err = iprot.Skip(fieldTypeId); err != nil {
+				goto SkipFieldError
+			}
 		default:
 			if err = iprot.Skip(fieldTypeId); err != nil {
 				goto SkipFieldError
@@ -1908,6 +2931,14 @@ func (p *EvaluatorContent) ReadField103(iprot thrift.TProtocol) error {
 	p.CustomRPCEvaluator = _field
 	return nil
 }
+func (p *EvaluatorContent) ReadField104(iprot thrift.TProtocol) error {
+	_field := NewAgentEvaluator()
+	if err := _field.Read(iprot); err != nil {
+		return err
+	}
+	p.AgentEvaluator = _field
+	return nil
+}
 
 func (p *EvaluatorContent) Write(oprot thrift.TProtocol) (err error) {
 	var fieldId int16
@@ -1939,6 +2970,10 @@ func (p *EvaluatorContent) Write(oprot thrift.TProtocol) (err error) {
 			fieldId = 103
 			goto WriteFieldError
 		}
+		if err = p.writeField104(oprot); err != nil {
+			fieldId = 104
+			goto WriteFieldError
+		}
 	}
 	if err = oprot.WriteFieldStop(); err != nil {
 		goto WriteFieldStopError
@@ -2081,6 +3116,24 @@ WriteFieldBeginError:
 WriteFieldEndError:
 	return thrift.PrependError(fmt.Sprintf("%T write field 103 end error: ", p), err)
 }
+func (p *EvaluatorContent) writeField104(oprot thrift.TProtocol) (err error) {
+	if p.IsSetAgentEvaluator() {
+		if err = oprot.WriteFieldBegin("agent_evaluator", thrift.STRUCT, 104); err != nil {
+			goto WriteFieldBeginError
+		}
+		if err := p.AgentEvaluator.Write(oprot); err != nil {
+			return err
+		}
+		if err = oprot.WriteFieldEnd(); err != nil {
+			goto WriteFieldEndError
+		}
+	}
+	return nil
+WriteFieldBeginError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 104 begin error: ", p), err)
+WriteFieldEndError:
+	return thrift.PrependError(fmt.Sprintf("%T write field 104 end error: ", p), err)
+}
 
 func (p *EvaluatorContent) String() string {
 	if p == nil {
@@ -2114,6 +3167,9 @@ func (p *EvaluatorContent) DeepEqual(ano *EvaluatorContent) bool {
 	if !p.Field103DeepEqual(ano.CustomRPCEvaluator) {
 		return false
 	}
+	if !p.Field104DeepEqual(ano.AgentEvaluator) {
+		return false
+	}
 	return true
 }
 
@@ -2176,6 +3232,13 @@ func (p *EvaluatorContent) Field103DeepEqual(src *CustomRPCEvaluator) bool {
 	}
 	return true
 }
+func (p *EvaluatorContent) Field104DeepEqual(src *AgentEvaluator) bool {
+
+	if !p.AgentEvaluator.DeepEqual(src) {
+		return false
+	}
+	return true
+}
 
 // 评估器版本
 type EvaluatorVersion struct {
diff --git a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator_validator.go b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator_validator.go
index b3d3b7288..00c436ad1 100644
--- a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator_validator.go
+++ b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/evaluator_validator.go
@@ -48,6 +48,50 @@ func (p *CustomRPCEvaluator) IsValid() error {
 	}
 	return nil
 }
+func (p *AgentEvaluatorPromptConfigOutputRules) IsValid() error {
+	if p.ScorePrompt != nil {
+		if err := p.ScorePrompt.IsValid(); err != nil {
+			return fmt.Errorf("field ScorePrompt not valid, %w", err)
+		}
+	}
+	if p.ReasoningPrompt != nil {
+		if err := p.ReasoningPrompt.IsValid(); err != nil {
+			return fmt.Errorf("field ReasoningPrompt not valid, %w", err)
+		}
+	}
+	if p.ExtraOutputPrompt != nil {
+		if err := p.ExtraOutputPrompt.IsValid(); err != nil {
+			return fmt.Errorf("field ExtraOutputPrompt not valid, %w", err)
+		}
+	}
+	return nil
+}
+func (p *AgentEvaluatorPromptConfig) IsValid() error {
+	if p.OutputRules != nil {
+		if err := p.OutputRules.IsValid(); err != nil {
+			return fmt.Errorf("field OutputRules not valid, %w", err)
+		}
+	}
+	return nil
+}
+func (p *AgentEvaluator) IsValid() error {
+	if p.AgentConfig != nil {
+		if err := p.AgentConfig.IsValid(); err != nil {
+			return fmt.Errorf("field AgentConfig not valid, %w", err)
+		}
+	}
+	if p.ModelConfig != nil {
+		if err := p.ModelConfig.IsValid(); err != nil {
+			return fmt.Errorf("field ModelConfig not valid, %w", err)
+		}
+	}
+	if p.PromptConfig != nil {
+		if err := p.PromptConfig.IsValid(); err != nil {
+			return fmt.Errorf("field PromptConfig not valid, %w", err)
+		}
+	}
+	return nil
+}
 func (p *EvaluatorContent) IsValid() error {
 	if p.PromptEvaluator != nil {
 		if err := p.PromptEvaluator.IsValid(); err != nil {
@@ -64,6 +108,11 @@ func (p *EvaluatorContent) IsValid() error {
 			return fmt.Errorf("field CustomRPCEvaluator not valid, %w", err)
 		}
 	}
+	if p.AgentEvaluator != nil {
+		if err := p.AgentEvaluator.IsValid(); err != nil {
+			return fmt.Errorf("field AgentEvaluator not valid, %w", err)
+		}
+	}
 	return nil
 }
 func (p *EvaluatorVersion) IsValid() error {
diff --git a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/k-evaluator.go b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/k-evaluator.go
index 2fbe0e058..5b3daafbb 100644
--- a/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/k-evaluator.go
+++ b/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator/k-evaluator.go
@@ -1122,6 +1122,753 @@ func (p *CustomRPCEvaluator) DeepCopy(s interface{}) error {
 	return nil
 }
 
+func (p *AgentEvaluatorPromptConfigOutputRules) FastRead(buf []byte) (int, error) {
+
+	var err error
+	var offset int
+	var l int
+	var fieldTypeId thrift.TType
+	var fieldId int16
+	for {
+		fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:])
+		offset += l
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField1(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 2:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField2(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 3:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField3(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		default:
+			l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+			offset += l
+			if err != nil {
+				goto SkipFieldError
+			}
+		}
+	}
+
+	return offset, nil
+ReadFieldBeginError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentEvaluatorPromptConfigOutputRules[fieldId]), err)
+SkipFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) FastReadField1(buf []byte) (int, error) {
+	offset := 0
+	_field := common.NewMessage()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.ScorePrompt = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) FastReadField2(buf []byte) (int, error) {
+	offset := 0
+	_field := common.NewMessage()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.ReasoningPrompt = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) FastReadField3(buf []byte) (int, error) {
+	offset := 0
+	_field := common.NewMessage()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.ExtraOutputPrompt = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) FastWrite(buf []byte) int {
+	return p.FastWriteNocopy(buf, nil)
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p != nil {
+		offset += p.fastWriteField1(buf[offset:], w)
+		offset += p.fastWriteField2(buf[offset:], w)
+		offset += p.fastWriteField3(buf[offset:], w)
+	}
+	offset += thrift.Binary.WriteFieldStop(buf[offset:])
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) BLength() int {
+	l := 0
+	if p != nil {
+		l += p.field1Length()
+		l += p.field2Length()
+		l += p.field3Length()
+	}
+	l += thrift.Binary.FieldStopLength()
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) fastWriteField1(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetScorePrompt() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1)
+		offset += p.ScorePrompt.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) fastWriteField2(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetReasoningPrompt() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 2)
+		offset += p.ReasoningPrompt.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) fastWriteField3(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetExtraOutputPrompt() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 3)
+		offset += p.ExtraOutputPrompt.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) field1Length() int {
+	l := 0
+	if p.IsSetScorePrompt() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.ScorePrompt.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) field2Length() int {
+	l := 0
+	if p.IsSetReasoningPrompt() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.ReasoningPrompt.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) field3Length() int {
+	l := 0
+	if p.IsSetExtraOutputPrompt() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.ExtraOutputPrompt.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfigOutputRules) DeepCopy(s interface{}) error {
+	src, ok := s.(*AgentEvaluatorPromptConfigOutputRules)
+	if !ok {
+		return fmt.Errorf("%T's type not matched %T", s, p)
+	}
+
+	var _scorePrompt *common.Message
+	if src.ScorePrompt != nil {
+		_scorePrompt = &common.Message{}
+		if err := _scorePrompt.DeepCopy(src.ScorePrompt); err != nil {
+			return err
+		}
+	}
+	p.ScorePrompt = _scorePrompt
+
+	var _reasoningPrompt *common.Message
+	if src.ReasoningPrompt != nil {
+		_reasoningPrompt = &common.Message{}
+		if err := _reasoningPrompt.DeepCopy(src.ReasoningPrompt); err != nil {
+			return err
+		}
+	}
+	p.ReasoningPrompt = _reasoningPrompt
+
+	var _extraOutputPrompt *common.Message
+	if src.ExtraOutputPrompt != nil {
+		_extraOutputPrompt = &common.Message{}
+		if err := _extraOutputPrompt.DeepCopy(src.ExtraOutputPrompt); err != nil {
+			return err
+		}
+	}
+	p.ExtraOutputPrompt = _extraOutputPrompt
+
+	return nil
+}
+
+func (p *AgentEvaluatorPromptConfig) FastRead(buf []byte) (int, error) {
+
+	var err error
+	var offset int
+	var l int
+	var fieldTypeId thrift.TType
+	var fieldId int16
+	for {
+		fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:])
+		offset += l
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.LIST {
+				l, err = p.FastReadField1(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 2:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField2(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		default:
+			l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+			offset += l
+			if err != nil {
+				goto SkipFieldError
+			}
+		}
+	}
+
+	return offset, nil
+ReadFieldBeginError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentEvaluatorPromptConfig[fieldId]), err)
+SkipFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+}
+
+func (p *AgentEvaluatorPromptConfig) FastReadField1(buf []byte) (int, error) {
+	offset := 0
+
+	_, size, l, err := thrift.Binary.ReadListBegin(buf[offset:])
+	offset += l
+	if err != nil {
+		return offset, err
+	}
+	_field := make([]*common.Message, 0, size)
+	values := make([]common.Message, size)
+	for i := 0; i < size; i++ {
+		_elem := &values[i]
+		_elem.InitDefault()
+		if l, err := _elem.FastRead(buf[offset:]); err != nil {
+			return offset, err
+		} else {
+			offset += l
+		}
+
+		_field = append(_field, _elem)
+	}
+	p.MessageList = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluatorPromptConfig) FastReadField2(buf []byte) (int, error) {
+	offset := 0
+	_field := NewAgentEvaluatorPromptConfigOutputRules()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.OutputRules = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluatorPromptConfig) FastWrite(buf []byte) int {
+	return p.FastWriteNocopy(buf, nil)
+}
+
+func (p *AgentEvaluatorPromptConfig) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p != nil {
+		offset += p.fastWriteField1(buf[offset:], w)
+		offset += p.fastWriteField2(buf[offset:], w)
+	}
+	offset += thrift.Binary.WriteFieldStop(buf[offset:])
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfig) BLength() int {
+	l := 0
+	if p != nil {
+		l += p.field1Length()
+		l += p.field2Length()
+	}
+	l += thrift.Binary.FieldStopLength()
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfig) fastWriteField1(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetMessageList() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 1)
+		listBeginOffset := offset
+		offset += thrift.Binary.ListBeginLength()
+		var length int
+		for _, v := range p.MessageList {
+			length++
+			offset += v.FastWriteNocopy(buf[offset:], w)
+		}
+		thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length)
+	}
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfig) fastWriteField2(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetOutputRules() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 2)
+		offset += p.OutputRules.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluatorPromptConfig) field1Length() int {
+	l := 0
+	if p.IsSetMessageList() {
+		l += thrift.Binary.FieldBeginLength()
+		l += thrift.Binary.ListBeginLength()
+		for _, v := range p.MessageList {
+			_ = v
+			l += v.BLength()
+		}
+	}
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfig) field2Length() int {
+	l := 0
+	if p.IsSetOutputRules() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.OutputRules.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluatorPromptConfig) DeepCopy(s interface{}) error {
+	src, ok := s.(*AgentEvaluatorPromptConfig)
+	if !ok {
+		return fmt.Errorf("%T's type not matched %T", s, p)
+	}
+
+	if src.MessageList != nil {
+		p.MessageList = make([]*common.Message, 0, len(src.MessageList))
+		for _, elem := range src.MessageList {
+			var _elem *common.Message
+			if elem != nil {
+				_elem = &common.Message{}
+				if err := _elem.DeepCopy(elem); err != nil {
+					return err
+				}
+			}
+
+			p.MessageList = append(p.MessageList, _elem)
+		}
+	}
+
+	var _outputRules *AgentEvaluatorPromptConfigOutputRules
+	if src.OutputRules != nil {
+		_outputRules = &AgentEvaluatorPromptConfigOutputRules{}
+		if err := _outputRules.DeepCopy(src.OutputRules); err != nil {
+			return err
+		}
+	}
+	p.OutputRules = _outputRules
+
+	return nil
+}
+
+func (p *AgentEvaluator) FastRead(buf []byte) (int, error) {
+
+	var err error
+	var offset int
+	var l int
+	var fieldTypeId thrift.TType
+	var fieldId int16
+	for {
+		fieldTypeId, fieldId, l, err = thrift.Binary.ReadFieldBegin(buf[offset:])
+		offset += l
+		if err != nil {
+			goto ReadFieldBeginError
+		}
+		if fieldTypeId == thrift.STOP {
+			break
+		}
+		switch fieldId {
+		case 1:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField1(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 2:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField2(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 3:
+			if fieldTypeId == thrift.LIST {
+				l, err = p.FastReadField3(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		case 4:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField4(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
+		default:
+			l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+			offset += l
+			if err != nil {
+				goto SkipFieldError
+			}
+		}
+	}
+
+	return offset, nil
+ReadFieldBeginError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
+ReadFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_AgentEvaluator[fieldId]), err)
+SkipFieldError:
+	return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)
+}
+
+func (p *AgentEvaluator) FastReadField1(buf []byte) (int, error) {
+	offset := 0
+	_field := common.NewAgentConfig()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.AgentConfig = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluator) FastReadField2(buf []byte) (int, error) {
+	offset := 0
+	_field := common.NewModelConfig()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.ModelConfig = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluator) FastReadField3(buf []byte) (int, error) {
+	offset := 0
+
+	_, size, l, err := thrift.Binary.ReadListBegin(buf[offset:])
+	offset += l
+	if err != nil {
+		return offset, err
+	}
+	_field := make([]*common.SkillConfig, 0, size)
+	values := make([]common.SkillConfig, size)
+	for i := 0; i < size; i++ {
+		_elem := &values[i]
+		_elem.InitDefault()
+		if l, err := _elem.FastRead(buf[offset:]); err != nil {
+			return offset, err
+		} else {
+			offset += l
+		}
+
+		_field = append(_field, _elem)
+	}
+	p.SkillConfigs = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluator) FastReadField4(buf []byte) (int, error) {
+	offset := 0
+	_field := NewAgentEvaluatorPromptConfig()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.PromptConfig = _field
+	return offset, nil
+}
+
+func (p *AgentEvaluator) FastWrite(buf []byte) int {
+	return p.FastWriteNocopy(buf, nil)
+}
+
+func (p *AgentEvaluator) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p != nil {
+		offset += p.fastWriteField1(buf[offset:], w)
+		offset += p.fastWriteField2(buf[offset:], w)
+		offset += p.fastWriteField3(buf[offset:], w)
+		offset += p.fastWriteField4(buf[offset:], w)
+	}
+	offset += thrift.Binary.WriteFieldStop(buf[offset:])
+	return offset
+}
+
+func (p *AgentEvaluator) BLength() int {
+	l := 0
+	if p != nil {
+		l += p.field1Length()
+		l += p.field2Length()
+		l += p.field3Length()
+		l += p.field4Length()
+	}
+	l += thrift.Binary.FieldStopLength()
+	return l
+}
+
+func (p *AgentEvaluator) fastWriteField1(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetAgentConfig() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 1)
+		offset += p.AgentConfig.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluator) fastWriteField2(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetModelConfig() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 2)
+		offset += p.ModelConfig.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluator) fastWriteField3(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetSkillConfigs() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.LIST, 3)
+		listBeginOffset := offset
+		offset += thrift.Binary.ListBeginLength()
+		var length int
+		for _, v := range p.SkillConfigs {
+			length++
+			offset += v.FastWriteNocopy(buf[offset:], w)
+		}
+		thrift.Binary.WriteListBegin(buf[listBeginOffset:], thrift.STRUCT, length)
+	}
+	return offset
+}
+
+func (p *AgentEvaluator) fastWriteField4(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetPromptConfig() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 4)
+		offset += p.PromptConfig.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
+func (p *AgentEvaluator) field1Length() int {
+	l := 0
+	if p.IsSetAgentConfig() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.AgentConfig.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluator) field2Length() int {
+	l := 0
+	if p.IsSetModelConfig() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.ModelConfig.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluator) field3Length() int {
+	l := 0
+	if p.IsSetSkillConfigs() {
+		l += thrift.Binary.FieldBeginLength()
+		l += thrift.Binary.ListBeginLength()
+		for _, v := range p.SkillConfigs {
+			_ = v
+			l += v.BLength()
+		}
+	}
+	return l
+}
+
+func (p *AgentEvaluator) field4Length() int {
+	l := 0
+	if p.IsSetPromptConfig() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.PromptConfig.BLength()
+	}
+	return l
+}
+
+func (p *AgentEvaluator) DeepCopy(s interface{}) error {
+	src, ok := s.(*AgentEvaluator)
+	if !ok {
+		return fmt.Errorf("%T's type not matched %T", s, p)
+	}
+
+	var _agentConfig *common.AgentConfig
+	if src.AgentConfig != nil {
+		_agentConfig = &common.AgentConfig{}
+		if err := _agentConfig.DeepCopy(src.AgentConfig); err != nil {
+			return err
+		}
+	}
+	p.AgentConfig = _agentConfig
+
+	var _modelConfig *common.ModelConfig
+	if src.ModelConfig != nil {
+		_modelConfig = &common.ModelConfig{}
+		if err := _modelConfig.DeepCopy(src.ModelConfig); err != nil {
+			return err
+		}
+	}
+	p.ModelConfig = _modelConfig
+
+	if src.SkillConfigs != nil {
+		p.SkillConfigs = make([]*common.SkillConfig, 0, len(src.SkillConfigs))
+		for _, elem := range src.SkillConfigs {
+			var _elem *common.SkillConfig
+			if elem != nil {
+				_elem = &common.SkillConfig{}
+				if err := _elem.DeepCopy(elem); err != nil {
+					return err
+				}
+			}
+
+			p.SkillConfigs = append(p.SkillConfigs, _elem)
+		}
+	}
+
+	var _promptConfig *AgentEvaluatorPromptConfig
+	if src.PromptConfig != nil {
+		_promptConfig = &AgentEvaluatorPromptConfig{}
+		if err := _promptConfig.DeepCopy(src.PromptConfig); err != nil {
+			return err
+		}
+	}
+	p.PromptConfig = _promptConfig
+
+	return nil
+}
+
 func (p *EvaluatorContent) FastRead(buf []byte) (int, error) {
 
 	var err error
@@ -1223,6 +1970,20 @@ func (p *EvaluatorContent) FastRead(buf []byte) (int, error) {
 					goto SkipFieldError
 				}
 			}
+		case 104:
+			if fieldTypeId == thrift.STRUCT {
+				l, err = p.FastReadField104(buf[offset:])
+				offset += l
+				if err != nil {
+					goto ReadFieldError
+				}
+			} else {
+				l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
+				offset += l
+				if err != nil {
+					goto SkipFieldError
+				}
+			}
 		default:
 			l, err = thrift.Binary.Skip(buf[offset:], fieldTypeId)
 			offset += l
@@ -1341,6 +2102,18 @@ func (p *EvaluatorContent) FastReadField103(buf []byte) (int, error) {
 	return offset, nil
 }
 
+func (p *EvaluatorContent) FastReadField104(buf []byte) (int, error) {
+	offset := 0
+	_field := NewAgentEvaluator()
+	if l, err := _field.FastRead(buf[offset:]); err != nil {
+		return offset, err
+	} else {
+		offset += l
+	}
+	p.AgentEvaluator = _field
+	return offset, nil
+}
+
 func (p *EvaluatorContent) FastWrite(buf []byte) int {
 	return p.FastWriteNocopy(buf, nil)
 }
@@ -1354,6 +2127,7 @@ func (p *EvaluatorContent) FastWriteNocopy(buf []byte, w thrift.NocopyWriter) in
 		offset += p.fastWriteField101(buf[offset:], w)
 		offset += p.fastWriteField102(buf[offset:], w)
 		offset += p.fastWriteField103(buf[offset:], w)
+		offset += p.fastWriteField104(buf[offset:], w)
 	}
 	offset += thrift.Binary.WriteFieldStop(buf[offset:])
 	return offset
@@ -1368,6 +2142,7 @@ func (p *EvaluatorContent) BLength() int {
 		l += p.field101Length()
 		l += p.field102Length()
 		l += p.field103Length()
+		l += p.field104Length()
 	}
 	l += thrift.Binary.FieldStopLength()
 	return l
@@ -1441,6 +2216,15 @@ func (p *EvaluatorContent) fastWriteField103(buf []byte, w thrift.NocopyWriter)
 	return offset
 }
 
+func (p *EvaluatorContent) fastWriteField104(buf []byte, w thrift.NocopyWriter) int {
+	offset := 0
+	if p.IsSetAgentEvaluator() {
+		offset += thrift.Binary.WriteFieldBegin(buf[offset:], thrift.STRUCT, 104)
+		offset += p.AgentEvaluator.FastWriteNocopy(buf[offset:], w)
+	}
+	return offset
+}
+
 func (p *EvaluatorContent) field1Length() int {
 	l := 0
 	if p.IsSetIsReceiveChatHistory() {
@@ -1503,6 +2287,15 @@ func (p *EvaluatorContent) field103Length() int {
 	return l
 }
 
+func (p *EvaluatorContent) field104Length() int {
+	l := 0
+	if p.IsSetAgentEvaluator() {
+		l += thrift.Binary.FieldBeginLength()
+		l += p.AgentEvaluator.BLength()
+	}
+	return l
+}
+
 func (p *EvaluatorContent) DeepCopy(s interface{}) error {
 	src, ok := s.(*EvaluatorContent)
 	if !ok {
@@ -1571,6 +2364,15 @@ func (p *EvaluatorContent) DeepCopy(s interface{}) error {
 	}
 	p.CustomRPCEvaluator = _customRPCEvaluator
 
+	var _agentEvaluator *AgentEvaluator
+	if src.AgentEvaluator != nil {
+		_agentEvaluator = &AgentEvaluator{}
+		if err := _agentEvaluator.DeepCopy(src.AgentEvaluator); err != nil {
+			return err
+		}
+	}
+	p.AgentEvaluator = _agentEvaluator
+
 	return nil
 }
 
diff --git a/backend/modules/evaluation/application/convertor/evaluator/openapi.go b/backend/modules/evaluation/application/convertor/evaluator/openapi.go
index 92e8d11bc..0da7baefe 100644
--- a/backend/modules/evaluation/application/convertor/evaluator/openapi.go
+++ b/backend/modules/evaluation/application/convertor/evaluator/openapi.go
@@ -7,11 +7,10 @@ import (
 	"strings"
 
 	"github.com/bytedance/gg/gptr"
+	openapiCommon "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common"
 	openapiEvaluator "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator"
 	common_convertor "github.com/coze-dev/coze-loop/backend/modules/evaluation/application/convertor/common"
 	"github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/entity"
-	"github.com/coze-dev/coze-loop/backend/modules/evaluation/pkg/errno"
-	"github.com/coze-dev/coze-loop/backend/pkg/errorx"
 )
 
 func OpenAPIEvaluatorDO2DTO(do *entity.Evaluator) *openapiEvaluator.Evaluator {
@@ -57,6 +56,8 @@ func OpenAPIEvaluatorTypeDO2DTO(doType entity.EvaluatorType) *openapiEvaluator.E
 		openapiType = openapiEvaluator.EvaluatorTypeCode
 	case entity.EvaluatorTypeCustomRPC:
 		openapiType = openapiEvaluator.EvaluatorTypeCustomRPC
+	case entity.EvaluatorTypeAgent:
+		openapiType = openapiEvaluator.EvaluatorTypeAgent
 	default:
 		return nil
 	}
@@ -94,6 +95,13 @@ func OpenAPIEvaluatorVersionDO2DTO(do *entity.Evaluator) *openapiEvaluator.Evalu
 			description = do.CustomRPCEvaluatorVersion.Description
 			baseInfo = do.CustomRPCEvaluatorVersion.BaseInfo
 		}
+	case entity.EvaluatorTypeAgent:
+		if do.AgentEvaluatorVersion != nil {
+			id = do.AgentEvaluatorVersion.ID
+			version = do.AgentEvaluatorVersion.Version
+			description = do.AgentEvaluatorVersion.Description
+			baseInfo = do.AgentEvaluatorVersion.BaseInfo
+		}
 	}
 
 	if id == 0 && version == "" {
@@ -165,6 +173,17 @@ func OpenAPIEvaluatorContentDO2DTO(do *entity.Evaluator) *openapiEvaluator.Evalu
 				Ext:                   v.Ext,
 			}
 		}
+	case entity.EvaluatorTypeAgent:
+		if v := do.AgentEvaluatorVersion; v != nil {
+			dto.InputSchemas = common_convertor.OpenAPIArgsSchemaDO2DTOs(v.InputSchemas)
+			dto.OutputSchemas = common_convertor.OpenAPIArgsSchemaDO2DTOs(v.OutputSchemas)
+			dto.AgentEvaluator = &openapiEvaluator.AgentEvaluator{
+				AgentConfig:  OpenAPIAgentConfigDO2DTO(v.AgentConfig),
+				ModelConfig:  common_convertor.OpenAPIModelConfigDO2DTO(v.ModelConfig),
+				SkillConfigs: OpenAPISkillConfigsDO2DTOs(v.SkillConfigs),
+				PromptConfig: OpenAPIAgentEvaluatorPromptConfigDO2DTO(v.PromptConfig),
+			}
+		}
 	}
 
 	return dto
@@ -509,6 +528,18 @@ func OpenAPIEvaluatorContentDTO2DO(dto *openapiEvaluator.EvaluatorContent, evalT
 				res.CustomRPCEvaluatorVersion.RateLimit = rateLimit
 			}
 		}
+	case entity.EvaluatorTypeAgent:
+		res.AgentEvaluatorVersion = &entity.AgentEvaluatorVersion{
+			InputSchemas:  common_convertor.OpenAPIArgsSchemaDTO2DOs(dto.InputSchemas),
+			OutputSchemas: common_convertor.OpenAPIArgsSchemaDTO2DOs(dto.OutputSchemas),
+		}
+		if dto.AgentEvaluator != nil {
+			a := dto.AgentEvaluator
+			res.AgentEvaluatorVersion.AgentConfig = OpenAPIAgentConfigDTO2DO(a.AgentConfig)
+			res.AgentEvaluatorVersion.ModelConfig = common_convertor.OpenAPIModelConfigDTO2DO(a.ModelConfig)
+			res.AgentEvaluatorVersion.SkillConfigs = OpenAPISkillConfigsDTO2DOs(a.SkillConfigs)
+			res.AgentEvaluatorVersion.PromptConfig = OpenAPIAgentEvaluatorPromptConfigDTO2DO(a.PromptConfig)
+		}
 	}
 	return res, nil
 }
@@ -531,9 +562,6 @@ func OpenAPIEvaluatorDTO2DO(dto *openapiEvaluator.Evaluator) (*entity.Evaluator,
 	if dto == nil {
 		return nil, nil
 	}
-	if dto.EvaluatorType != nil && *dto.EvaluatorType == openapiEvaluator.EvaluatorTypeAgent {
-		return nil, errorx.NewByCode(errno.CommonInvalidParamCode, errorx.WithExtraMsg("agent evaluator is not supported in evaluator openapi"))
-	}
 	evalType := OpenAPIEvaluatorTypeDTO2DO(dto.EvaluatorType)
 	res := &entity.Evaluator{
 		ID:            dto.GetID(),
@@ -565,7 +593,93 @@ func OpenAPIEvaluatorTypeDTO2DO(dto *openapiEvaluator.EvaluatorType) entity.Eval
 		return entity.EvaluatorTypeCode
 	case openapiEvaluator.EvaluatorTypeCustomRPC:
 		return entity.EvaluatorTypeCustomRPC
+	case openapiEvaluator.EvaluatorTypeAgent:
+		return entity.EvaluatorTypeAgent
 	default:
 		return entity.EvaluatorTypePrompt
 	}
 }
+
+func OpenAPIAgentConfigDO2DTO(do *entity.AgentConfig) *openapiCommon.AgentConfig {
+	if do == nil {
+		return nil
+	}
+	return &openapiCommon.AgentConfig{
+		AgentType: gptr.Of(openapiCommon.AgentType(do.AgentType)),
+	}
+}
+
+func OpenAPIAgentConfigDTO2DO(dto *openapiCommon.AgentConfig) *entity.AgentConfig {
+	if dto == nil {
+		return nil
+	}
+	return &entity.AgentConfig{
+		AgentType: entity.AgentType(dto.GetAgentType()),
+	}
+}
+
+func OpenAPISkillConfigsDO2DTOs(dos []*entity.SkillConfig) []*openapiCommon.SkillConfig {
+	if dos == nil {
+		return nil
+	}
+	dtos := make([]*openapiCommon.SkillConfig, 0, len(dos))
+	for _, do := range dos {
+		if do != nil {
+			dtos = append(dtos, &openapiCommon.SkillConfig{
+				SkillID: do.SkillID,
+				Version: do.Version,
+			})
+		}
+	}
+	return dtos
+}
+
+func OpenAPISkillConfigsDTO2DOs(dtos []*openapiCommon.SkillConfig) []*entity.SkillConfig {
+	if dtos == nil {
+		return nil
+	}
+	dos := make([]*entity.SkillConfig, 0, len(dtos))
+	for _, dto := range dtos {
+		if dto != nil {
+			dos = append(dos, &entity.SkillConfig{
+				SkillID: dto.SkillID,
+				Version: dto.Version,
+			})
+		}
+	}
+	return dos
+}
+
+func OpenAPIAgentEvaluatorPromptConfigDO2DTO(do *entity.AgentEvaluatorPromptConfig) *openapiEvaluator.AgentEvaluatorPromptConfig {
+	if do == nil {
+		return nil
+	}
+	dto := &openapiEvaluator.AgentEvaluatorPromptConfig{
+		MessageList: common_convertor.OpenAPIMessageDO2DTOs(do.MessageList),
+	}
+	if do.OutputRules != nil {
+		dto.OutputRules = &openapiEvaluator.AgentEvaluatorPromptConfigOutputRules{
+			ScorePrompt:       common_convertor.OpenAPIMessageDO2DTO(do.OutputRules.ScorePrompt),
+			ReasoningPrompt:   common_convertor.OpenAPIMessageDO2DTO(do.OutputRules.ReasoningPrompt),
+			ExtraOutputPrompt: common_convertor.OpenAPIMessageDO2DTO(do.OutputRules.ExtraOutputPrompt),
+		}
+	}
+	return dto
+}
+
+func OpenAPIAgentEvaluatorPromptConfigDTO2DO(dto *openapiEvaluator.AgentEvaluatorPromptConfig) *entity.AgentEvaluatorPromptConfig {
+	if dto == nil {
+		return nil
+	}
+	do := &entity.AgentEvaluatorPromptConfig{
+		MessageList: common_convertor.OpenAPIMessageDTO2DOs(dto.MessageList),
+	}
+	if dto.OutputRules != nil {
+		do.OutputRules = &entity.AgentEvaluatorPromptConfigOutputRules{
+			ScorePrompt:       common_convertor.OpenAPIMessageDTO2DO(dto.OutputRules.GetScorePrompt()),
+			ReasoningPrompt:   common_convertor.OpenAPIMessageDTO2DO(dto.OutputRules.GetReasoningPrompt()),
+			ExtraOutputPrompt: common_convertor.OpenAPIMessageDTO2DO(dto.OutputRules.GetExtraOutputPrompt()),
+		}
+	}
+	return do
+}
diff --git a/backend/modules/evaluation/application/convertor/evaluator/openapi_test.go b/backend/modules/evaluation/application/convertor/evaluator/openapi_test.go
index fd9897a82..48cdf0741 100644
--- a/backend/modules/evaluation/application/convertor/evaluator/openapi_test.go
+++ b/backend/modules/evaluation/application/convertor/evaluator/openapi_test.go
@@ -10,8 +10,6 @@ import (
 	openapiCommon "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/evaluation/domain_openapi/common"
 	openapiEvaluator "github.com/coze-dev/coze-loop/backend/kitex_gen/coze/loop/evaluation/domain_openapi/evaluator"
 	"github.com/coze-dev/coze-loop/backend/modules/evaluation/domain/entity"
-	"github.com/coze-dev/coze-loop/backend/modules/evaluation/pkg/errno"
-	"github.com/coze-dev/coze-loop/backend/pkg/errorx"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -61,6 +59,7 @@ func TestOpenAPIEvaluatorTypeDO2DTO(t *testing.T) {
 	assert.Equal(t, openapiEvaluator.EvaluatorTypePrompt, *OpenAPIEvaluatorTypeDO2DTO(entity.EvaluatorTypePrompt))
 	assert.Equal(t, openapiEvaluator.EvaluatorTypeCode, *OpenAPIEvaluatorTypeDO2DTO(entity.EvaluatorTypeCode))
 	assert.Equal(t, openapiEvaluator.EvaluatorTypeCustomRPC, *OpenAPIEvaluatorTypeDO2DTO(entity.EvaluatorTypeCustomRPC))
+	assert.Equal(t, openapiEvaluator.EvaluatorTypeAgent, *OpenAPIEvaluatorTypeDO2DTO(entity.EvaluatorTypeAgent))
 	assert.Nil(t, OpenAPIEvaluatorTypeDO2DTO(entity.EvaluatorType(999)))
 }
 
@@ -114,6 +113,29 @@ func TestOpenAPIEvaluatorVersionDO2DTO(t *testing.T) {
 		}
 		assert.Nil(t, OpenAPIEvaluatorVersionDO2DTO(do))
 	})
+
+	t.Run("agent type", func(t *testing.T) {
+		do := &entity.Evaluator{
+			EvaluatorType: entity.EvaluatorTypeAgent,
+			AgentEvaluatorVersion: &entity.AgentEvaluatorVersion{
+				ID:          4,
+				Version:     "v4",
+				Description: "agent desc",
+			},
+		}
+		dto := OpenAPIEvaluatorVersionDO2DTO(do)
+		assert.NotNil(t, dto)
+		assert.Equal(t, int64(4), *dto.ID)
+		assert.Equal(t, "v4", *dto.Version)
+		assert.Equal(t, "agent desc", *dto.Description)
+	})
+
+	t.Run("agent type empty version", func(t *testing.T) {
+		do := &entity.Evaluator{
+			EvaluatorType: entity.EvaluatorTypeAgent,
+		}
+		assert.Nil(t, OpenAPIEvaluatorVersionDO2DTO(do))
+	})
 }
 
 func TestOpenAPIEvaluatorVersionDO2DTOs(t *testing.T) {
@@ -430,6 +452,52 @@ func TestOpenAPIEvaluatorContentDTO2DO(t *testing.T) {
 		assert.Equal(t, "svc", *do.CustomRPCEvaluatorVersion.ServiceName)
 		assert.Equal(t, "cls", *do.CustomRPCEvaluatorVersion.Cluster)
 	})
+
+	t.Run("agent type", func(t *testing.T) {
+		dto := &openapiEvaluator.EvaluatorContent{
+			InputSchemas: []*openapiCommon.ArgsSchema{{Key: gptr.Of("input1")}},
+			AgentEvaluator: &openapiEvaluator.AgentEvaluator{
+				AgentConfig: &openapiCommon.AgentConfig{
+					AgentType: gptr.Of(openapiCommon.AgentType("vibe")),
+				},
+				ModelConfig: &openapiCommon.ModelConfig{
+					ModelName: gptr.Of("gpt-4"),
+				},
+				SkillConfigs: []*openapiCommon.SkillConfig{
+					{SkillID: gptr.Of(int64(1)), Version: gptr.Of("v1")},
+				},
+				PromptConfig: &openapiEvaluator.AgentEvaluatorPromptConfig{
+					MessageList: []*openapiCommon.Message{
+						{Role: gptr.Of("user")},
+					},
+					OutputRules: &openapiEvaluator.AgentEvaluatorPromptConfigOutputRules{
+						ScorePrompt: &openapiCommon.Message{Role: gptr.Of("system")},
+					},
+				},
+			},
+		}
+		do, err := OpenAPIEvaluatorContentDTO2DO(dto, entity.EvaluatorTypeAgent)
+		assert.NoError(t, err)
+		assert.NotNil(t, do)
+		assert.NotNil(t, do.AgentEvaluatorVersion)
+		assert.Equal(t, 1, len(do.AgentEvaluatorVersion.InputSchemas))
+		assert.Equal(t, entity.AgentType_Vibe, do.AgentEvaluatorVersion.AgentConfig.AgentType)
+		assert.Equal(t, "gpt-4", do.AgentEvaluatorVersion.ModelConfig.ModelName)
+		assert.Equal(t, 1, len(do.AgentEvaluatorVersion.SkillConfigs))
+		assert.Equal(t, int64(1), *do.AgentEvaluatorVersion.SkillConfigs[0].SkillID)
+		assert.NotNil(t, do.AgentEvaluatorVersion.PromptConfig)
+		assert.Equal(t, 1, len(do.AgentEvaluatorVersion.PromptConfig.MessageList))
+		assert.NotNil(t, do.AgentEvaluatorVersion.PromptConfig.OutputRules)
+	})
+
+	t.Run("agent type nil agent evaluator", func(t *testing.T) {
+		dto := &openapiEvaluator.EvaluatorContent{}
+		do, err := OpenAPIEvaluatorContentDTO2DO(dto, entity.EvaluatorTypeAgent)
+		assert.NoError(t, err)
+		assert.NotNil(t, do)
+		assert.NotNil(t, do.AgentEvaluatorVersion)
+		assert.Nil(t, do.AgentEvaluatorVersion.AgentConfig)
+	})
 }
 
 func TestOpenAPILanguageTypeDTO2DO(t *testing.T) {
@@ -446,16 +514,14 @@ func TestOpenAPIEvaluatorDTO2DO(t *testing.T) {
 		assert.Nil(t, do)
 	})
 
-	t.Run("agent evaluator rejected", func(t *testing.T) {
+	t.Run("agent evaluator accepted", func(t *testing.T) {
 		dto := &openapiEvaluator.Evaluator{
 			EvaluatorType: gptr.Of(openapiEvaluator.EvaluatorTypeAgent),
 		}
 		do, err := OpenAPIEvaluatorDTO2DO(dto)
-		assert.Error(t, err)
-		statusErr, ok := errorx.FromStatusError(err)
-		assert.True(t, ok)
-		assert.EqualValues(t, errno.CommonInvalidParamCode, statusErr.Code())
-		assert.Nil(t, do)
+		assert.NoError(t, err)
+		assert.NotNil(t, do)
+		assert.Equal(t, entity.EvaluatorTypeAgent, do.EvaluatorType)
 	})
 
 	t.Run("normal input", func(t *testing.T) {
@@ -482,6 +548,7 @@ func TestOpenAPIEvaluatorTypeDTO2DO(t *testing.T) {
 	assert.Equal(t, entity.EvaluatorTypePrompt, OpenAPIEvaluatorTypeDTO2DO(gptr.Of(openapiEvaluator.EvaluatorTypePrompt)))
 	assert.Equal(t, entity.EvaluatorTypeCode, OpenAPIEvaluatorTypeDTO2DO(gptr.Of(openapiEvaluator.EvaluatorTypeCode)))
 	assert.Equal(t, entity.EvaluatorTypeCustomRPC, OpenAPIEvaluatorTypeDTO2DO(gptr.Of(openapiEvaluator.EvaluatorTypeCustomRPC)))
+	assert.Equal(t, entity.EvaluatorTypeAgent, OpenAPIEvaluatorTypeDTO2DO(gptr.Of(openapiEvaluator.EvaluatorTypeAgent)))
 	assert.Equal(t, entity.EvaluatorTypePrompt, OpenAPIEvaluatorTypeDTO2DO(nil))
 	assert.Equal(t, entity.EvaluatorTypePrompt, OpenAPIEvaluatorTypeDTO2DO(gptr.Of(openapiEvaluator.EvaluatorType("999"))))
 }
@@ -527,4 +594,240 @@ func TestOpenAPIEvaluatorContentDO2DTO(t *testing.T) {
 		assert.NotNil(t, dto)
 		assert.Equal(t, "svc", dto.CustomRPCEvaluator.GetServiceName())
 	})
+
+	t.Run("agent type", func(t *testing.T) {
+		do := &entity.Evaluator{
+			EvaluatorType: entity.EvaluatorTypeAgent,
+			AgentEvaluatorVersion: &entity.AgentEvaluatorVersion{
+				InputSchemas: []*entity.ArgsSchema{{Key: gptr.Of("input1")}},
+				AgentConfig:  &entity.AgentConfig{AgentType: entity.AgentType_Vibe},
+				ModelConfig:  &entity.ModelConfig{ModelName: "gpt-4"},
+				SkillConfigs: []*entity.SkillConfig{
+					{SkillID: gptr.Of(int64(1)), Version: gptr.Of("v1")},
+				},
+				PromptConfig: &entity.AgentEvaluatorPromptConfig{
+					MessageList: []*entity.Message{{Role: entity.RoleUser}},
+					OutputRules: &entity.AgentEvaluatorPromptConfigOutputRules{
+						ScorePrompt: &entity.Message{Role: entity.RoleSystem},
+					},
+				},
+			},
+		}
+		dto := OpenAPIEvaluatorContentDO2DTO(do)
+		assert.NotNil(t, dto)
+		assert.NotNil(t, dto.AgentEvaluator)
+		assert.NotNil(t, dto.AgentEvaluator.AgentConfig)
+		assert.Equal(t, openapiCommon.AgentType("vibe"), dto.AgentEvaluator.AgentConfig.GetAgentType())
+		assert.Equal(t, "gpt-4", dto.AgentEvaluator.ModelConfig.GetModelName())
+		assert.Equal(t, 1, len(dto.AgentEvaluator.SkillConfigs))
+		assert.Equal(t, int64(1), *dto.AgentEvaluator.SkillConfigs[0].SkillID)
+		assert.NotNil(t, dto.AgentEvaluator.PromptConfig)
+		assert.Equal(t, 1, len(dto.AgentEvaluator.PromptConfig.MessageList))
+		assert.NotNil(t, dto.AgentEvaluator.PromptConfig.OutputRules)
+		assert.NotNil(t, dto.AgentEvaluator.PromptConfig.OutputRules.ScorePrompt)
+		assert.Equal(t, 1, len(dto.InputSchemas))
+	})
+
+	t.Run("agent type nil version", func(t *testing.T) {
+		do := &entity.Evaluator{
+			EvaluatorType: entity.EvaluatorTypeAgent,
+		}
+		dto := OpenAPIEvaluatorContentDO2DTO(do)
+		assert.NotNil(t, dto)
+		assert.Nil(t, dto.AgentEvaluator)
+	})
+}
+
+func TestOpenAPIAgentConfigDO2DTO(t *testing.T) {
+	t.Run("nil input", func(t *testing.T) {
+		assert.Nil(t, OpenAPIAgentConfigDO2DTO(nil))
+	})
+
+	t.Run("normal input", func(t *testing.T) {
+		do := &entity.AgentConfig{AgentType: entity.AgentType_Vibe}
+		dto := OpenAPIAgentConfigDO2DTO(do)
+		assert.NotNil(t, dto)
+		assert.Equal(t, openapiCommon.AgentType("vibe"), dto.GetAgentType())
+	})
+}
+
+func TestOpenAPIAgentConfigDTO2DO(t *testing.T) {
+	t.Run("nil input", func(t *testing.T) {
+		assert.Nil(t, OpenAPIAgentConfigDTO2DO(nil))
+	})
+
+	t.Run("normal input", func(t *testing.T) {
+		dto := &openapiCommon.AgentConfig{AgentType: gptr.Of(openapiCommon.AgentType("vibe"))}
+		do := OpenAPIAgentConfigDTO2DO(dto)
+		assert.NotNil(t, do)
+		assert.Equal(t, entity.AgentType_Vibe, do.AgentType)
+	})
+}
+
+func TestOpenAPISkillConfigsDO2DTOs(t *testing.T) {
+	t.Run("nil input", func(t *testing.T) {
+		assert.Nil(t, OpenAPISkillConfigsDO2DTOs(nil))
+	})
+
+	t.Run("normal input with nil items", func(t *testing.T) {
+		dos := []*entity.SkillConfig{
+			{SkillID: gptr.Of(int64(1)), Version: gptr.Of("v1")},
+			nil,
+			{SkillID: gptr.Of(int64(2)), Version: gptr.Of("v2")},
+		}
+		dtos := OpenAPISkillConfigsDO2DTOs(dos)
+		assert.Equal(t, 2, len(dtos))
+		assert.Equal(t, int64(1), *dtos[0].SkillID)
+		assert.Equal(t, "v1", *dtos[0].Version)
+		assert.Equal(t, int64(2), *dtos[1].SkillID)
+		assert.Equal(t, "v2", *dtos[1].Version)
+	})
+
+	t.Run("empty input", func(t *testing.T) {
+		dtos := OpenAPISkillConfigsDO2DTOs([]*entity.SkillConfig{})
+		assert.NotNil(t, dtos)
+		assert.Equal(t, 0, len(dtos))
+	})
+}
+
+func TestOpenAPISkillConfigsDTO2DOs(t *testing.T) {
+	t.Run("nil input", func(t *testing.T) {
+		assert.Nil(t, OpenAPISkillConfigsDTO2DOs(nil))
+	})
+
+	t.Run("normal input with nil items", func(t *testing.T) {
+		dtos := []*openapiCommon.SkillConfig{
+			{SkillID: gptr.Of(int64(10)), Version: gptr.Of("v10")},
+			nil,
+			{SkillID: gptr.Of(int64(20)), Version: gptr.Of("v20")},
+		}
+		dos := OpenAPISkillConfigsDTO2DOs(dtos)
+		assert.Equal(t, 2, len(dos))
+		assert.Equal(t, int64(10), *dos[0].SkillID)
+		assert.Equal(t, "v10", *dos[0].Version)
+		assert.Equal(t, int64(20), *dos[1].SkillID)
+		assert.Equal(t, "v20", *dos[1].Version)
+	})
+
+	t.Run("empty input", func(t *testing.T) {
+		dos := OpenAPISkillConfigsDTO2DOs([]*openapiCommon.SkillConfig{})
+		assert.NotNil(t, dos)
+		assert.Equal(t, 0, len(dos))
+	})
+}
+
+func TestOpenAPIAgentEvaluatorPromptConfigDO2DTO(t *testing.T) {
+	t.Run("nil input", func(t *testing.T) {
+		assert.Nil(t, OpenAPIAgentEvaluatorPromptConfigDO2DTO(nil))
+	})
+
+	t.Run("without output rules", func(t *testing.T) {
+		do := &entity.AgentEvaluatorPromptConfig{
+			MessageList: []*entity.Message{{Role: entity.RoleUser}},
+		}
+		dto := OpenAPIAgentEvaluatorPromptConfigDO2DTO(do)
+		assert.NotNil(t, dto)
+		assert.Equal(t, 1, len(dto.MessageList))
+		assert.Nil(t, dto.OutputRules)
+	})
+
+	t.Run("with output rules", func(t *testing.T) {
+		do := &entity.AgentEvaluatorPromptConfig{
+			MessageList: []*entity.Message{{Role: entity.RoleUser}},
+			OutputRules: &entity.AgentEvaluatorPromptConfigOutputRules{
+				ScorePrompt:       &entity.Message{Role: entity.RoleSystem},
+				ReasoningPrompt:   &entity.Message{Role: entity.RoleAssistant},
+				ExtraOutputPrompt: &entity.Message{Role: entity.RoleUser},
+			},
+		}
+		dto := OpenAPIAgentEvaluatorPromptConfigDO2DTO(do)
+		assert.NotNil(t, dto)
+		assert.NotNil(t, dto.OutputRules)
+		assert.NotNil(t, dto.OutputRules.ScorePrompt)
+		assert.NotNil(t, dto.OutputRules.ReasoningPrompt)
+		assert.NotNil(t, dto.OutputRules.ExtraOutputPrompt)
+	})
+}
+
+func TestOpenAPIAgentEvaluatorPromptConfigDTO2DO(t *testing.T) {
+	t.Run("nil input", func(t *testing.T) {
+		assert.Nil(t, OpenAPIAgentEvaluatorPromptConfigDTO2DO(nil))
+	})
+
+	t.Run("without output rules", func(t *testing.T) {
+		dto := &openapiEvaluator.AgentEvaluatorPromptConfig{
+			MessageList: []*openapiCommon.Message{{Role: gptr.Of("user")}},
+		}
+		do := OpenAPIAgentEvaluatorPromptConfigDTO2DO(dto)
+		assert.NotNil(t, do)
+		assert.Equal(t, 1, len(do.MessageList))
+		assert.Nil(t, do.OutputRules)
+	})
+
+	t.Run("with output rules", func(t *testing.T) {
+		dto := &openapiEvaluator.AgentEvaluatorPromptConfig{
+			MessageList: []*openapiCommon.Message{{Role: gptr.Of("user")}},
+			OutputRules: &openapiEvaluator.AgentEvaluatorPromptConfigOutputRules{
+				ScorePrompt:       &openapiCommon.Message{Role: gptr.Of("system")},
+				ReasoningPrompt:   &openapiCommon.Message{Role: gptr.Of("assistant")},
+				ExtraOutputPrompt: &openapiCommon.Message{Role: gptr.Of("user")},
+			},
+		}
+		do := OpenAPIAgentEvaluatorPromptConfigDTO2DO(dto)
+		assert.NotNil(t, do)
+		assert.NotNil(t, do.OutputRules)
+		assert.NotNil(t, do.OutputRules.ScorePrompt)
+		assert.NotNil(t, do.OutputRules.ReasoningPrompt)
+		assert.NotNil(t, do.OutputRules.ExtraOutputPrompt)
+	})
+}
+
+func TestOpenAPIEvaluatorDO2DTO_AgentType(t *testing.T) {
+	do := &entity.Evaluator{
+		ID:            100,
+		Name:          "agent-eval",
+		Description:   "agent evaluator desc",
+		EvaluatorType: entity.EvaluatorTypeAgent,
+		AgentEvaluatorVersion: &entity.AgentEvaluatorVersion{
+			ID:      200,
+			Version: "v1",
+			AgentConfig: &entity.AgentConfig{
+				AgentType: entity.AgentType_Vibe,
+			},
+		},
+	}
+	dto := OpenAPIEvaluatorDO2DTO(do)
+	assert.NotNil(t, dto)
+	assert.Equal(t, int64(100), *dto.ID)
+	assert.Equal(t, "agent-eval", *dto.Name)
+	assert.Equal(t, openapiEvaluator.EvaluatorTypeAgent, *dto.EvaluatorType)
+	assert.NotNil(t, dto.CurrentVersion)
+	assert.Equal(t, int64(200), *dto.CurrentVersion.ID)
+	assert.Equal(t, "v1", *dto.CurrentVersion.Version)
+}
+
+func TestOpenAPIEvaluatorDTO2DO_AgentWithVersion(t *testing.T) {
+	dto := &openapiEvaluator.Evaluator{
+		ID:            gptr.Of(int64(100)),
+		Name:          gptr.Of("agent-eval"),
+		EvaluatorType: gptr.Of(openapiEvaluator.EvaluatorTypeAgent),
+		CurrentVersion: &openapiEvaluator.EvaluatorVersion{
+			Version: gptr.Of("v1"),
+			EvaluatorContent: &openapiEvaluator.EvaluatorContent{
+				AgentEvaluator: &openapiEvaluator.AgentEvaluator{
+					AgentConfig: &openapiCommon.AgentConfig{
+						AgentType: gptr.Of(openapiCommon.AgentType("vibe")),
+					},
+				},
+			},
+		},
+	}
+	do, err := OpenAPIEvaluatorDTO2DO(dto)
+	assert.NoError(t, err)
+	assert.NotNil(t, do)
+	assert.Equal(t, int64(100), do.ID)
+	assert.Equal(t, entity.EvaluatorTypeAgent, do.EvaluatorType)
+	assert.NotNil(t, do.AgentEvaluatorVersion)
+	assert.Equal(t, entity.AgentType_Vibe, do.AgentEvaluatorVersion.AgentConfig.AgentType)
+	assert.Equal(t, "v1", do.GetVersion())
 }
diff --git a/idl/thrift/coze/loop/evaluation/domain_openapi/common.thrift b/idl/thrift/coze/loop/evaluation/domain_openapi/common.thrift
index 0dacb05cf..9c95c1447 100644
--- a/idl/thrift/coze/loop/evaluation/domain_openapi/common.thrift
+++ b/idl/thrift/coze/loop/evaluation/domain_openapi/common.thrift
@@ -124,4 +124,16 @@ struct Message {
     1: optional Role role
     2: optional Content content
     3: optional map<string, string> ext
+}
+
+typedef string AgentType(ts.enum="true")
+const AgentType AgentType_Vibe = "vibe"
+
+struct AgentConfig {
+    1: optional AgentType agent_type
+}
+
+struct SkillConfig {
+    1: optional i64 skill_id (api.js_conv="true", go.tag = 'json:"skill_id"')
+    2: optional string version
 }
\ No newline at end of file
diff --git a/idl/thrift/coze/loop/evaluation/domain_openapi/evaluator.thrift b/idl/thrift/coze/loop/evaluation/domain_openapi/evaluator.thrift
index 197d9bafb..a25098a52 100644
--- a/idl/thrift/coze/loop/evaluation/domain_openapi/evaluator.thrift
+++ b/idl/thrift/coze/loop/evaluation/domain_openapi/evaluator.thrift
@@ -62,6 +62,27 @@ struct CustomRPCEvaluator {
     12: optional map<string, string> ext
 }
 
+// Agent评估器Prompt配置输出规则
+struct AgentEvaluatorPromptConfigOutputRules {
+    1: optional common.Message score_prompt
+    2: optional common.Message reasoning_prompt
+    3: optional common.Message extra_output_prompt
+}
+
+// Agent评估器Prompt配置
+struct AgentEvaluatorPromptConfig {
+    1: optional list<common.Message> message_list
+    2: optional AgentEvaluatorPromptConfigOutputRules output_rules
+}
+
+// Agent评估器
+struct AgentEvaluator {
+    1: optional common.AgentConfig agent_config
+    2: optional common.ModelConfig model_config
+    3: optional list<common.SkillConfig> skill_configs
+    4: optional AgentEvaluatorPromptConfig prompt_config
+}
+
 // 评估器内容
 struct EvaluatorContent {
     1: optional bool is_receive_chat_history
@@ -72,6 +93,7 @@ struct EvaluatorContent {
     101: optional PromptEvaluator prompt_evaluator
     102: optional CodeEvaluator code_evaluator
     103: optional CustomRPCEvaluator custom_rpc_evaluator
+    104: optional AgentEvaluator agent_evaluator
 }
 
 // 评估器版本