diff --git a/agent/agent.pb.go b/agent/agent.pb.go
index e4ad178a..a70a1392 100644
--- a/agent/agent.pb.go
+++ b/agent/agent.pb.go
@@ -472,7 +472,7 @@ func (x *IMAMeasurementsResponse) GetPcr10() []byte {
 	return nil
 }
 
-type AttestationResultRequest struct {
+type AttestationTokenRequest struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	TokenNonce    []byte                 `protobuf:"bytes,1,opt,name=tokenNonce,proto3" json:"tokenNonce,omitempty"` // Should be less or equal 32 bytes
 	Type          int32                  `protobuf:"varint,3,opt,name=type,proto3" json:"type,omitempty"`
@@ -480,20 +480,20 @@ type AttestationResultRequest struct {
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *AttestationResultRequest) Reset() {
-	*x = AttestationResultRequest{}
+func (x *AttestationTokenRequest) Reset() {
+	*x = AttestationTokenRequest{}
 	mi := &file_agent_agent_proto_msgTypes[10]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *AttestationResultRequest) String() string {
+func (x *AttestationTokenRequest) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*AttestationResultRequest) ProtoMessage() {}
+func (*AttestationTokenRequest) ProtoMessage() {}
 
-func (x *AttestationResultRequest) ProtoReflect() protoreflect.Message {
+func (x *AttestationTokenRequest) ProtoReflect() protoreflect.Message {
 	mi := &file_agent_agent_proto_msgTypes[10]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -505,46 +505,46 @@ func (x *AttestationResultRequest) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use AttestationResultRequest.ProtoReflect.Descriptor instead.
-func (*AttestationResultRequest) Descriptor() ([]byte, []int) {
+// Deprecated: Use AttestationTokenRequest.ProtoReflect.Descriptor instead.
+func (*AttestationTokenRequest) Descriptor() ([]byte, []int) {
 	return file_agent_agent_proto_rawDescGZIP(), []int{10}
 }
 
-func (x *AttestationResultRequest) GetTokenNonce() []byte {
+func (x *AttestationTokenRequest) GetTokenNonce() []byte {
 	if x != nil {
 		return x.TokenNonce
 	}
 	return nil
 }
 
-func (x *AttestationResultRequest) GetType() int32 {
+func (x *AttestationTokenRequest) GetType() int32 {
 	if x != nil {
 		return x.Type
 	}
 	return 0
 }
 
-type AttestationResultResponse struct {
+type AttestationTokenResponse struct {
 	state         protoimpl.MessageState `protogen:"open.v1"`
 	File          []byte                 `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
 }
 
-func (x *AttestationResultResponse) Reset() {
-	*x = AttestationResultResponse{}
+func (x *AttestationTokenResponse) Reset() {
+	*x = AttestationTokenResponse{}
 	mi := &file_agent_agent_proto_msgTypes[11]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *AttestationResultResponse) String() string {
+func (x *AttestationTokenResponse) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*AttestationResultResponse) ProtoMessage() {}
+func (*AttestationTokenResponse) ProtoMessage() {}
 
-func (x *AttestationResultResponse) ProtoReflect() protoreflect.Message {
+func (x *AttestationTokenResponse) ProtoReflect() protoreflect.Message {
 	mi := &file_agent_agent_proto_msgTypes[11]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -556,12 +556,12 @@ func (x *AttestationResultResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use AttestationResultResponse.ProtoReflect.Descriptor instead.
-func (*AttestationResultResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use AttestationTokenResponse.ProtoReflect.Descriptor instead.
+func (*AttestationTokenResponse) Descriptor() ([]byte, []int) {
 	return file_agent_agent_proto_rawDescGZIP(), []int{11}
 }
 
-func (x *AttestationResultResponse) GetFile() []byte {
+func (x *AttestationTokenResponse) GetFile() []byte {
 	if x != nil {
 		return x.File
 	}
@@ -602,41 +602,41 @@ var file_agent_agent_proto_rawDesc = string([]byte{
 	0x6e, 0x74, 0x73, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66,
 	0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12,
 	0x14, 0x0a, 0x05, 0x70, 0x63, 0x72, 0x31, 0x30, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x05,
-	0x70, 0x63, 0x72, 0x31, 0x30, 0x22, 0x4e, 0x0a, 0x18, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x12, 0x1e, 0x0a, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4e, 0x6f, 0x6e, 0x63,
-	0x65, 0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52,
-	0x04, 0x74, 0x79, 0x70, 0x65, 0x22, 0x2f, 0x0a, 0x19, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61,
-	0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c,
-	0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x32, 0xad, 0x03, 0x0a, 0x0c, 0x41, 0x67, 0x65, 0x6e, 0x74,
-	0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x04, 0x41, 0x6c, 0x67, 0x6f, 0x12,
-	0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65, 0x71, 0x75,
-	0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12, 0x33, 0x0a, 0x04,
-	0x44, 0x61, 0x74, 0x61, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x44, 0x61, 0x74,
-	0x61, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74,
-	0x2e, 0x44, 0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28,
-	0x01, 0x12, 0x39, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x14, 0x2e, 0x61, 0x67,
-	0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
-	0x74, 0x1a, 0x15, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x48, 0x0a, 0x0b,
-	0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x2e, 0x61, 0x67,
-	0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52,
-	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41,
-	0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x54, 0x0a, 0x0f, 0x49, 0x4d, 0x41, 0x4d, 0x65, 0x61,
-	0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x2e, 0x61, 0x67, 0x65, 0x6e,
-	0x74, 0x2e, 0x49, 0x4d, 0x41, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74,
-	0x73, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74,
-	0x2e, 0x49, 0x4d, 0x41, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73,
-	0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x58, 0x0a, 0x11,
-	0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c,
-	0x74, 0x12, 0x1f, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74,
-	0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65,
-	0x73, 0x74, 0x1a, 0x20, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x73, 0x70,
+	0x70, 0x63, 0x72, 0x31, 0x30, 0x22, 0x4d, 0x0a, 0x17, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61,
+	0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74,
+	0x12, 0x1e, 0x0a, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4e, 0x6f, 0x6e, 0x63, 0x65, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x0c, 0x52, 0x0a, 0x74, 0x6f, 0x6b, 0x65, 0x6e, 0x4e, 0x6f, 0x6e, 0x63, 0x65,
+	0x12, 0x12, 0x0a, 0x04, 0x74, 0x79, 0x70, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x05, 0x52, 0x04,
+	0x74, 0x79, 0x70, 0x65, 0x22, 0x2e, 0x0a, 0x18, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74,
+	0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04,
+	0x66, 0x69, 0x6c, 0x65, 0x32, 0xaf, 0x03, 0x0a, 0x0c, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x65,
+	0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x33, 0x0a, 0x04, 0x41, 0x6c, 0x67, 0x6f, 0x12, 0x12, 0x2e,
+	0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73,
+	0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12, 0x33, 0x0a, 0x04, 0x44, 0x61,
+	0x74, 0x61, 0x12, 0x12, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x13, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x44,
+	0x61, 0x74, 0x61, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x28, 0x01, 0x12,
+	0x39, 0x0a, 0x06, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x12, 0x14, 0x2e, 0x61, 0x67, 0x65, 0x6e,
+	0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a,
+	0x15, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x48, 0x0a, 0x0b, 0x41, 0x74,
+	0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x19, 0x2e, 0x61, 0x67, 0x65, 0x6e,
+	0x74, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x71,
+	0x75, 0x65, 0x73, 0x74, 0x1a, 0x1a, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74,
+	0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65,
+	0x22, 0x00, 0x30, 0x01, 0x12, 0x54, 0x0a, 0x0f, 0x49, 0x4d, 0x41, 0x4d, 0x65, 0x61, 0x73, 0x75,
+	0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x12, 0x1d, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e,
+	0x49, 0x4d, 0x41, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52,
+	0x65, 0x71, 0x75, 0x65, 0x73, 0x74, 0x1a, 0x1e, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x49,
+	0x4d, 0x41, 0x4d, 0x65, 0x61, 0x73, 0x75, 0x72, 0x65, 0x6d, 0x65, 0x6e, 0x74, 0x73, 0x52, 0x65,
+	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x30, 0x01, 0x12, 0x5a, 0x0a, 0x15, 0x41, 0x7a,
+	0x75, 0x72, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f,
+	0x6b, 0x65, 0x6e, 0x12, 0x1e, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65,
+	0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x71, 0x75,
+	0x65, 0x73, 0x74, 0x1a, 0x1f, 0x2e, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x2e, 0x41, 0x74, 0x74, 0x65,
+	0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x52, 0x65, 0x73, 0x70,
 	0x6f, 0x6e, 0x73, 0x65, 0x22, 0x00, 0x42, 0x09, 0x5a, 0x07, 0x2e, 0x2f, 0x61, 0x67, 0x65, 0x6e,
 	0x74, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
 })
@@ -655,18 +655,18 @@ func file_agent_agent_proto_rawDescGZIP() []byte {
 
 var file_agent_agent_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
 var file_agent_agent_proto_goTypes = []any{
-	(*AlgoRequest)(nil),               // 0: agent.AlgoRequest
-	(*AlgoResponse)(nil),              // 1: agent.AlgoResponse
-	(*DataRequest)(nil),               // 2: agent.DataRequest
-	(*DataResponse)(nil),              // 3: agent.DataResponse
-	(*ResultRequest)(nil),             // 4: agent.ResultRequest
-	(*ResultResponse)(nil),            // 5: agent.ResultResponse
-	(*AttestationRequest)(nil),        // 6: agent.AttestationRequest
-	(*AttestationResponse)(nil),       // 7: agent.AttestationResponse
-	(*IMAMeasurementsRequest)(nil),    // 8: agent.IMAMeasurementsRequest
-	(*IMAMeasurementsResponse)(nil),   // 9: agent.IMAMeasurementsResponse
-	(*AttestationResultRequest)(nil),  // 10: agent.AttestationResultRequest
-	(*AttestationResultResponse)(nil), // 11: agent.AttestationResultResponse
+	(*AlgoRequest)(nil),              // 0: agent.AlgoRequest
+	(*AlgoResponse)(nil),             // 1: agent.AlgoResponse
+	(*DataRequest)(nil),              // 2: agent.DataRequest
+	(*DataResponse)(nil),             // 3: agent.DataResponse
+	(*ResultRequest)(nil),            // 4: agent.ResultRequest
+	(*ResultResponse)(nil),           // 5: agent.ResultResponse
+	(*AttestationRequest)(nil),       // 6: agent.AttestationRequest
+	(*AttestationResponse)(nil),      // 7: agent.AttestationResponse
+	(*IMAMeasurementsRequest)(nil),   // 8: agent.IMAMeasurementsRequest
+	(*IMAMeasurementsResponse)(nil),  // 9: agent.IMAMeasurementsResponse
+	(*AttestationTokenRequest)(nil),  // 10: agent.AttestationTokenRequest
+	(*AttestationTokenResponse)(nil), // 11: agent.AttestationTokenResponse
 }
 var file_agent_agent_proto_depIdxs = []int32{
 	0,  // 0: agent.AgentService.Algo:input_type -> agent.AlgoRequest
@@ -674,13 +674,13 @@ var file_agent_agent_proto_depIdxs = []int32{
 	4,  // 2: agent.AgentService.Result:input_type -> agent.ResultRequest
 	6,  // 3: agent.AgentService.Attestation:input_type -> agent.AttestationRequest
 	8,  // 4: agent.AgentService.IMAMeasurements:input_type -> agent.IMAMeasurementsRequest
-	10, // 5: agent.AgentService.AttestationResult:input_type -> agent.AttestationResultRequest
+	10, // 5: agent.AgentService.AzureAttestationToken:input_type -> agent.AttestationTokenRequest
 	1,  // 6: agent.AgentService.Algo:output_type -> agent.AlgoResponse
 	3,  // 7: agent.AgentService.Data:output_type -> agent.DataResponse
 	5,  // 8: agent.AgentService.Result:output_type -> agent.ResultResponse
 	7,  // 9: agent.AgentService.Attestation:output_type -> agent.AttestationResponse
 	9,  // 10: agent.AgentService.IMAMeasurements:output_type -> agent.IMAMeasurementsResponse
-	11, // 11: agent.AgentService.AttestationResult:output_type -> agent.AttestationResultResponse
+	11, // 11: agent.AgentService.AzureAttestationToken:output_type -> agent.AttestationTokenResponse
 	6,  // [6:12] is the sub-list for method output_type
 	0,  // [0:6] is the sub-list for method input_type
 	0,  // [0:0] is the sub-list for extension type_name
diff --git a/agent/agent.proto b/agent/agent.proto
index b9c4726f..9dcc9474 100644
--- a/agent/agent.proto
+++ b/agent/agent.proto
@@ -13,7 +13,7 @@ service AgentService {
   rpc Result(ResultRequest) returns (stream ResultResponse) {}
   rpc Attestation(AttestationRequest) returns (stream AttestationResponse) {}
   rpc IMAMeasurements(IMAMeasurementsRequest) returns (stream IMAMeasurementsResponse) {}
-  rpc AttestationResult(AttestationResultRequest) returns (AttestationResultResponse) {}
+  rpc AzureAttestationToken(AttestationTokenRequest) returns (AttestationTokenResponse) {}
 }
 
 message AlgoRequest {
@@ -55,10 +55,10 @@ message IMAMeasurementsResponse {
   bytes pcr10 = 2;
 }
 
-message AttestationResultRequest{
+message AttestationTokenRequest{
   bytes tokenNonce = 1; // Should be less or equal 32 bytes
   int32 type = 3;
 }
-message AttestationResultResponse{
+message AttestationTokenResponse{
   bytes file = 1;
 }
diff --git a/agent/agent_grpc.pb.go b/agent/agent_grpc.pb.go
index 546835a4..56fc0533 100644
--- a/agent/agent_grpc.pb.go
+++ b/agent/agent_grpc.pb.go
@@ -22,12 +22,12 @@ import (
 const _ = grpc.SupportPackageIsVersion9
 
 const (
-	AgentService_Algo_FullMethodName              = "/agent.AgentService/Algo"
-	AgentService_Data_FullMethodName              = "/agent.AgentService/Data"
-	AgentService_Result_FullMethodName            = "/agent.AgentService/Result"
-	AgentService_Attestation_FullMethodName       = "/agent.AgentService/Attestation"
-	AgentService_IMAMeasurements_FullMethodName   = "/agent.AgentService/IMAMeasurements"
-	AgentService_AttestationResult_FullMethodName = "/agent.AgentService/AttestationResult"
+	AgentService_Algo_FullMethodName                  = "/agent.AgentService/Algo"
+	AgentService_Data_FullMethodName                  = "/agent.AgentService/Data"
+	AgentService_Result_FullMethodName                = "/agent.AgentService/Result"
+	AgentService_Attestation_FullMethodName           = "/agent.AgentService/Attestation"
+	AgentService_IMAMeasurements_FullMethodName       = "/agent.AgentService/IMAMeasurements"
+	AgentService_AzureAttestationToken_FullMethodName = "/agent.AgentService/AzureAttestationToken"
 )
 
 // AgentServiceClient is the client API for AgentService service.
@@ -39,7 +39,7 @@ type AgentServiceClient interface {
 	Result(ctx context.Context, in *ResultRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[ResultResponse], error)
 	Attestation(ctx context.Context, in *AttestationRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[AttestationResponse], error)
 	IMAMeasurements(ctx context.Context, in *IMAMeasurementsRequest, opts ...grpc.CallOption) (grpc.ServerStreamingClient[IMAMeasurementsResponse], error)
-	AttestationResult(ctx context.Context, in *AttestationResultRequest, opts ...grpc.CallOption) (*AttestationResultResponse, error)
+	AzureAttestationToken(ctx context.Context, in *AttestationTokenRequest, opts ...grpc.CallOption) (*AttestationTokenResponse, error)
 }
 
 type agentServiceClient struct {
@@ -133,10 +133,10 @@ func (c *agentServiceClient) IMAMeasurements(ctx context.Context, in *IMAMeasure
 // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
 type AgentService_IMAMeasurementsClient = grpc.ServerStreamingClient[IMAMeasurementsResponse]
 
-func (c *agentServiceClient) AttestationResult(ctx context.Context, in *AttestationResultRequest, opts ...grpc.CallOption) (*AttestationResultResponse, error) {
+func (c *agentServiceClient) AzureAttestationToken(ctx context.Context, in *AttestationTokenRequest, opts ...grpc.CallOption) (*AttestationTokenResponse, error) {
 	cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)
-	out := new(AttestationResultResponse)
-	err := c.cc.Invoke(ctx, AgentService_AttestationResult_FullMethodName, in, out, cOpts...)
+	out := new(AttestationTokenResponse)
+	err := c.cc.Invoke(ctx, AgentService_AzureAttestationToken_FullMethodName, in, out, cOpts...)
 	if err != nil {
 		return nil, err
 	}
@@ -152,7 +152,7 @@ type AgentServiceServer interface {
 	Result(*ResultRequest, grpc.ServerStreamingServer[ResultResponse]) error
 	Attestation(*AttestationRequest, grpc.ServerStreamingServer[AttestationResponse]) error
 	IMAMeasurements(*IMAMeasurementsRequest, grpc.ServerStreamingServer[IMAMeasurementsResponse]) error
-	AttestationResult(context.Context, *AttestationResultRequest) (*AttestationResultResponse, error)
+	AzureAttestationToken(context.Context, *AttestationTokenRequest) (*AttestationTokenResponse, error)
 	mustEmbedUnimplementedAgentServiceServer()
 }
 
@@ -178,8 +178,8 @@ func (UnimplementedAgentServiceServer) Attestation(*AttestationRequest, grpc.Ser
 func (UnimplementedAgentServiceServer) IMAMeasurements(*IMAMeasurementsRequest, grpc.ServerStreamingServer[IMAMeasurementsResponse]) error {
 	return status.Errorf(codes.Unimplemented, "method IMAMeasurements not implemented")
 }
-func (UnimplementedAgentServiceServer) AttestationResult(context.Context, *AttestationResultRequest) (*AttestationResultResponse, error) {
-	return nil, status.Errorf(codes.Unimplemented, "method AttestationResult not implemented")
+func (UnimplementedAgentServiceServer) AzureAttestationToken(context.Context, *AttestationTokenRequest) (*AttestationTokenResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method AzureAttestationToken not implemented")
 }
 func (UnimplementedAgentServiceServer) mustEmbedUnimplementedAgentServiceServer() {}
 func (UnimplementedAgentServiceServer) testEmbeddedByValue()                      {}
@@ -249,20 +249,20 @@ func _AgentService_IMAMeasurements_Handler(srv interface{}, stream grpc.ServerSt
 // This type alias is provided for backwards compatibility with existing code that references the prior non-generic stream type by name.
 type AgentService_IMAMeasurementsServer = grpc.ServerStreamingServer[IMAMeasurementsResponse]
 
-func _AgentService_AttestationResult_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
-	in := new(AttestationResultRequest)
+func _AgentService_AzureAttestationToken_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AttestationTokenRequest)
 	if err := dec(in); err != nil {
 		return nil, err
 	}
 	if interceptor == nil {
-		return srv.(AgentServiceServer).AttestationResult(ctx, in)
+		return srv.(AgentServiceServer).AzureAttestationToken(ctx, in)
 	}
 	info := &grpc.UnaryServerInfo{
 		Server:     srv,
-		FullMethod: AgentService_AttestationResult_FullMethodName,
+		FullMethod: AgentService_AzureAttestationToken_FullMethodName,
 	}
 	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
-		return srv.(AgentServiceServer).AttestationResult(ctx, req.(*AttestationResultRequest))
+		return srv.(AgentServiceServer).AzureAttestationToken(ctx, req.(*AttestationTokenRequest))
 	}
 	return interceptor(ctx, in, info, handler)
 }
@@ -275,8 +275,8 @@ var AgentService_ServiceDesc = grpc.ServiceDesc{
 	HandlerType: (*AgentServiceServer)(nil),
 	Methods: []grpc.MethodDesc{
 		{
-			MethodName: "AttestationResult",
-			Handler:    _AgentService_AttestationResult_Handler,
+			MethodName: "AzureAttestationToken",
+			Handler:    _AgentService_AzureAttestationToken_Handler,
 		},
 	},
 	Streams: []grpc.StreamDesc{
diff --git a/agent/api/grpc/endpoint.go b/agent/api/grpc/endpoint.go
index f4ec62aa..75c8e4f4 100644
--- a/agent/api/grpc/endpoint.go
+++ b/agent/api/grpc/endpoint.go
@@ -96,16 +96,16 @@ func imaMeasurementsEndpoint(svc agent.Service) endpoint.Endpoint {
 	}
 }
 
-func attestationResultEndpoint(svc agent.Service) endpoint.Endpoint {
+func azureAttestationTokenEndpoint(svc agent.Service) endpoint.Endpoint {
 	return func(ctx context.Context, request interface{}) (interface{}, error) {
-		req := request.(FetchAttestationResultReq)
+		req := request.(azureAttestationTokenReq)
 		if err := req.validate(); err != nil {
-			return fetchAttestationResultRes{}, err
+			return fetchAttestationTokenRes{}, err
 		}
-		file, err := svc.AttestationResult(ctx, req.tokenNonce, attestation.PlatformType(req.AttType))
+		file, err := svc.AzureAttestationToken(ctx, req.tokenNonce)
 		if err != nil {
-			return fetchAttestationResultRes{}, err
+			return fetchAttestationTokenRes{}, err
 		}
-		return fetchAttestationResultRes{File: file}, nil
+		return fetchAttestationTokenRes{File: file}, nil
 	}
 }
diff --git a/agent/api/grpc/endpoint_test.go b/agent/api/grpc/endpoint_test.go
index a57f629f..7d3eb424 100644
--- a/agent/api/grpc/endpoint_test.go
+++ b/agent/api/grpc/endpoint_test.go
@@ -174,23 +174,23 @@ func TestAttestationEndpoint(t *testing.T) {
 	}
 }
 
-func TestAttestationResultEndpoint(t *testing.T) {
+func TestAttestationTokenEndpoint(t *testing.T) {
 	svc := new(mocks.Service)
 	tests := []struct {
 		name        string
-		req         FetchAttestationResultReq
+		req         azureAttestationTokenReq
 		mockErr     error
 		expectedErr bool
 	}{
 		{
 			name:        "Success",
-			req:         FetchAttestationResultReq{tokenNonce: sha3.Sum256([]byte("vtpm nonce")), AttType: attestation.AzureToken},
+			req:         azureAttestationTokenReq{tokenNonce: sha3.Sum256([]byte("vtpm nonce"))},
 			mockErr:     nil,
 			expectedErr: false,
 		},
 		{
 			name:        "Service Error",
-			req:         FetchAttestationResultReq{tokenNonce: sha3.Sum256([]byte("vtpm nonce")), AttType: attestation.AzureToken},
+			req:         azureAttestationTokenReq{tokenNonce: sha3.Sum256([]byte("vtpm nonce"))},
 			mockErr:     errors.New("mock failure"),
 			expectedErr: true,
 		},
@@ -200,21 +200,21 @@ func TestAttestationResultEndpoint(t *testing.T) {
 		t.Run(tt.name, func(t *testing.T) {
 			// Only call service mock if validation is expected to pass
 			if err := tt.req.validate(); err == nil {
-				svc.On("AttestationResult", mock.Anything, tt.req.tokenNonce, attestation.PlatformType(tt.req.AttType)).
+				svc.On("AzureAttestationToken", mock.Anything, tt.req.tokenNonce).
 					Return([]byte("mock file"), tt.mockErr).Once()
 			}
 
-			endpoint := attestationResultEndpoint(svc)
+			endpoint := azureAttestationTokenEndpoint(svc)
 			res, err := endpoint(context.Background(), tt.req)
 
 			if (err != nil) != tt.expectedErr {
-				t.Errorf("attestationResultEndpoint() error = %v, expectedErr %v", err, tt.expectedErr)
+				t.Errorf("attestationTokenEndpoint() error = %v, expectedErr %v", err, tt.expectedErr)
 			}
 
 			if !tt.expectedErr {
-				r, ok := res.(fetchAttestationResultRes)
+				r, ok := res.(fetchAttestationTokenRes)
 				if !ok {
-					t.Errorf("attestationResultEndpoint() returned unexpected type %T", res)
+					t.Errorf("attestationTokenEndpoint() returned unexpected type %T", res)
 				}
 				if string(r.File) != "mock file" {
 					t.Errorf("expected file content 'mock file', got %s", r.File)
diff --git a/agent/api/grpc/requests.go b/agent/api/grpc/requests.go
index 17509793..36ac45c1 100644
--- a/agent/api/grpc/requests.go
+++ b/agent/api/grpc/requests.go
@@ -29,7 +29,7 @@ type dataReq struct {
 
 func (req dataReq) validate() error {
 	if len(req.Dataset) == 0 {
-		return errors.New("dataset CSV file is required")
+		return errors.New("dataset is required")
 	}
 	return nil
 }
@@ -47,22 +47,21 @@ type attestationReq struct {
 	AttType   attestation.PlatformType
 }
 
-type FetchAttestationResultReq struct {
+type azureAttestationTokenReq struct {
 	tokenNonce [vtpm.Nonce]byte
-	AttType    attestation.PlatformType
 }
 
 func (req attestationReq) validate() error {
 	return validateAttestationType(req.AttType)
 }
 
-func (req FetchAttestationResultReq) validate() error {
-	return validateAttestationType(req.AttType)
+func (req azureAttestationTokenReq) validate() error {
+	return nil
 }
 
 func validateAttestationType(attType attestation.PlatformType) error {
 	switch attType {
-	case attestation.SNP, attestation.VTPM, attestation.SNPvTPM, attestation.TDX, attestation.AzureToken:
+	case attestation.SNP, attestation.VTPM, attestation.SNPvTPM, attestation.TDX:
 		return nil
 	default:
 		return errors.New("invalid attestation type")
diff --git a/agent/api/grpc/responses.go b/agent/api/grpc/responses.go
index d325b299..f7313ef8 100644
--- a/agent/api/grpc/responses.go
+++ b/agent/api/grpc/responses.go
@@ -7,7 +7,7 @@ type algoRes struct{}
 type dataRes struct{}
 
 type resultRes struct {
-	File []byte `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
+	File []byte
 }
 
 type attestationRes struct {
@@ -19,6 +19,6 @@ type imaMeasurementsRes struct {
 	PCR10 []byte
 }
 
-type fetchAttestationResultRes struct {
-	File []byte `protobuf:"bytes,1,opt,name=AttestationResult,proto3" json:"AttestationResult,omitempty"`
+type fetchAttestationTokenRes struct {
+	File []byte
 }
diff --git a/agent/api/grpc/server.go b/agent/api/grpc/server.go
index 77a00fa0..6cab5ffc 100644
--- a/agent/api/grpc/server.go
+++ b/agent/api/grpc/server.go
@@ -74,10 +74,10 @@ func NewServer(svc agent.Service) agent.AgentServiceServer {
 			decodeRequest:  decodeIMAMeasurementsRequest,
 			encodeResponse: encodeIMAMeasurementsResponse,
 		},
-		"attestationResult": {
-			endpoint:       attestationResultEndpoint,
-			decodeRequest:  decodeAttestationResultRequest,
-			encodeResponse: encodeAttestationResultResponse,
+		"azureAttestationToken": {
+			endpoint:       azureAttestationTokenEndpoint,
+			decodeRequest:  decodeAttestationTokenRequest,
+			encodeResponse: encodeAttestationTokenResponse,
 		},
 	}
 
@@ -181,23 +181,21 @@ func encodeAttestationResponse(_ context.Context, response interface{}) (interfa
 	}, nil
 }
 
-func decodeAttestationResultRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
-	req := grpcReq.(*agent.AttestationResultRequest)
+func decodeAttestationTokenRequest(_ context.Context, grpcReq interface{}) (interface{}, error) {
+	req := grpcReq.(*agent.AttestationTokenRequest)
 	var nonce [vtpm.Nonce]byte
 
 	if err := validateNonce(req.TokenNonce, vtpm.Nonce, &nonce); err != nil {
 		return nil, err
 	}
-
-	return FetchAttestationResultReq{
+	return azureAttestationTokenReq{
 		tokenNonce: nonce,
-		AttType:    attestation.PlatformType(req.Type),
 	}, nil
 }
 
-func encodeAttestationResultResponse(_ context.Context, response interface{}) (interface{}, error) {
-	res := response.(fetchAttestationResultRes)
-	return &agent.AttestationResultResponse{
+func encodeAttestationTokenResponse(_ context.Context, response interface{}) (interface{}, error) {
+	res := response.(fetchAttestationTokenRes)
+	return &agent.AttestationTokenResponse{
 		File: res.File,
 	}, nil
 }
@@ -398,6 +396,20 @@ func (s *grpcServer) IMAMeasurements(req *agent.IMAMeasurementsRequest, stream a
 	)
 }
 
+func (s *grpcServer) AzureAttestationToken(ctx context.Context, req *agent.AttestationTokenRequest) (*agent.AttestationTokenResponse, error) {
+	_, res, err := s.handlers["azureAttestationToken"].ServeGRPC(ctx, req)
+	if err != nil {
+		return nil, err
+	}
+
+	rr, ok := res.(*agent.AttestationTokenResponse)
+	if !ok {
+		return nil, status.Error(codes.Internal, "failed to cast response to AttestationTokenResponse")
+	}
+
+	return rr, nil
+}
+
 func (s *grpcServer) streamDualBuffers(
 	buf1, buf2 *bytes.Buffer,
 	sendFn func([]byte, []byte) error,
@@ -426,17 +438,3 @@ func (s *grpcServer) streamDualBuffers(
 	}
 	return nil
 }
-
-func (s *grpcServer) AttestationResult(ctx context.Context, req *agent.AttestationResultRequest) (*agent.AttestationResultResponse, error) {
-	_, res, err := s.handlers["attestationResult"].ServeGRPC(ctx, req)
-	if err != nil {
-		return nil, err
-	}
-
-	rr, ok := res.(*agent.AttestationResultResponse)
-	if !ok {
-		return nil, status.Error(codes.Internal, "failed to cast response to AttestationResultResponse")
-	}
-
-	return rr, nil
-}
diff --git a/agent/api/grpc/server_test.go b/agent/api/grpc/server_test.go
index 4df94035..e788ff20 100644
--- a/agent/api/grpc/server_test.go
+++ b/agent/api/grpc/server_test.go
@@ -128,7 +128,7 @@ func TestNewServer(t *testing.T) {
 	assert.Len(t, grpcServer.handlers, 6) // Should have 6 handlers
 
 	// Check that all expected handlers are present
-	expectedHandlers := []string{"algo", "data", "result", "attestation", "imaMeasurements", "attestationResult"}
+	expectedHandlers := []string{"algo", "data", "result", "attestation", "imaMeasurements", "azureAttestationToken"}
 	for _, handler := range expectedHandlers {
 		assert.Contains(t, grpcServer.handlers, handler)
 		assert.NotNil(t, grpcServer.handlers[handler])
@@ -267,17 +267,17 @@ func TestIMAMeasurements(t *testing.T) {
 	mockStream.AssertExpectations(t)
 }
 
-func TestAttestationResult(t *testing.T) {
+func TestAttestationToken(t *testing.T) {
 	mockService := new(mocks.Service)
 	server := NewServer(mockService)
 
-	attestationData := []byte("attestation result data")
+	attestationData := []byte("attestation token data")
 	vtpmNonce := [vtpm.Nonce]byte{}
 	attestationType := attestation.SNP
 
-	mockService.On("AttestationResult", mock.Anything, vtpmNonce, attestationType).Return(attestationData, nil)
+	mockService.On("AzureAttestationToken", mock.Anything, vtpmNonce).Return(attestationData, nil)
 
-	resp, err := server.AttestationResult(context.Background(), &agent.AttestationResultRequest{
+	resp, err := server.AzureAttestationToken(context.Background(), &agent.AttestationTokenRequest{
 		TokenNonce: vtpmNonce[:],
 		Type:       int32(attestationType),
 	})
@@ -428,34 +428,31 @@ func TestEncodeAttestationResponse(t *testing.T) {
 	assert.Equal(t, &agent.AttestationResponse{File: []byte("attestation")}, encoded)
 }
 
-func TestDecodeAttestationResultRequest(t *testing.T) {
+func TestDecodeAttestationTokenRequest(t *testing.T) {
 	tokenNonce := make([]byte, vtpm.Nonce)
-	req := &agent.AttestationResultRequest{
+	req := &agent.AttestationTokenRequest{
 		TokenNonce: tokenNonce,
 		Type:       int32(attestation.SNP),
 	}
 
-	decoded, err := decodeAttestationResultRequest(context.Background(), req)
+	_, err := decodeAttestationTokenRequest(context.Background(), req)
 	assert.NoError(t, err)
-
-	decodedReq := decoded.(FetchAttestationResultReq)
-	assert.Equal(t, attestation.SNP, decodedReq.AttType)
 }
 
-func TestDecodeAttestationResultRequestWithInvalidNonce(t *testing.T) {
+func TestDecodeAttestationTokenRequestWithInvalidNonce(t *testing.T) {
 	// Test with token nonce too long
 	tokenNonce := make([]byte, vtpm.Nonce+1)
-	req := &agent.AttestationResultRequest{TokenNonce: tokenNonce}
+	req := &agent.AttestationTokenRequest{TokenNonce: tokenNonce}
 
-	_, err := decodeAttestationResultRequest(context.Background(), req)
+	_, err := decodeAttestationTokenRequest(context.Background(), req)
 	assert.Error(t, err)
 	assert.Equal(t, ErrVTPMNonceLength, err)
 }
 
-func TestEncodeAttestationResultResponse(t *testing.T) {
-	encoded, err := encodeAttestationResultResponse(context.Background(), fetchAttestationResultRes{File: []byte("attestation")})
+func TestEncodeAttestationTokenResponse(t *testing.T) {
+	encoded, err := encodeAttestationTokenResponse(context.Background(), fetchAttestationTokenRes{File: []byte("attestation")})
 	assert.NoError(t, err)
-	assert.Equal(t, &agent.AttestationResultResponse{File: []byte("attestation")}, encoded)
+	assert.Equal(t, &agent.AttestationTokenResponse{File: []byte("attestation")}, encoded)
 }
 
 func TestDecodeIMAMeasurementsRequest(t *testing.T) {
diff --git a/agent/api/logging.go b/agent/api/logging.go
index b15fa41c..33b3840e 100644
--- a/agent/api/logging.go
+++ b/agent/api/logging.go
@@ -132,9 +132,9 @@ func (lm *loggingMiddleware) IMAMeasurements(ctx context.Context) (file []byte,
 	return lm.svc.IMAMeasurements(ctx)
 }
 
-func (lm *loggingMiddleware) AttestationResult(ctx context.Context, nonce [vtpm.Nonce]byte, attType attestation.PlatformType) (response []byte, err error) {
+func (lm *loggingMiddleware) AzureAttestationToken(ctx context.Context, nonce [vtpm.Nonce]byte) (response []byte, err error) {
 	defer func(begin time.Time) {
-		message := fmt.Sprintf("Method AttestationResult took %s to complete", time.Since(begin))
+		message := fmt.Sprintf("Method AzureAttestationToken took %s to complete", time.Since(begin))
 		if err != nil {
 			lm.logger.Warn(fmt.Sprintf("%s with error: %s", message, err))
 			return
@@ -142,5 +142,5 @@ func (lm *loggingMiddleware) AttestationResult(ctx context.Context, nonce [vtpm.
 		lm.logger.Info(fmt.Sprintf("%s without errors", message))
 	}(time.Now())
 
-	return lm.svc.AttestationResult(ctx, nonce, attType)
+	return lm.svc.AzureAttestationToken(ctx, nonce)
 }
diff --git a/agent/api/metrics.go b/agent/api/metrics.go
index 02cc680d..c40cd58b 100644
--- a/agent/api/metrics.go
+++ b/agent/api/metrics.go
@@ -101,13 +101,13 @@ func (ms *metricsMiddleware) Attestation(ctx context.Context, reportData [quotep
 	return ms.svc.Attestation(ctx, reportData, nonce, attType)
 }
 
-func (ms *metricsMiddleware) AttestationResult(ctx context.Context, nonce [vtpm.Nonce]byte, attType attestation.PlatformType) ([]byte, error) {
+func (ms *metricsMiddleware) AzureAttestationToken(ctx context.Context, nonce [vtpm.Nonce]byte) ([]byte, error) {
 	defer func(begin time.Time) {
-		ms.counter.With("method", "attestation_result").Add(1)
-		ms.latency.With("method", "attestation_result").Observe(time.Since(begin).Seconds())
+		ms.counter.With("method", "attestation_token").Add(1)
+		ms.latency.With("method", "attestation_token").Observe(time.Since(begin).Seconds())
 	}(time.Now())
 
-	return ms.svc.AttestationResult(ctx, nonce, attType)
+	return ms.svc.AzureAttestationToken(ctx, nonce)
 }
 
 func (ms *metricsMiddleware) IMAMeasurements(ctx context.Context) ([]byte, []byte, error) {
diff --git a/agent/cvms/cvms.pb.go b/agent/cvms/cvms.pb.go
index ec32de56..5f5e1437 100644
--- a/agent/cvms/cvms.pb.go
+++ b/agent/cvms/cvms.pb.go
@@ -431,7 +431,7 @@ type ClientStreamMessage struct {
 	//	*ClientStreamMessage_StopComputationRes
 	//	*ClientStreamMessage_AgentStateRes
 	//	*ClientStreamMessage_VTPMattestationReport
-	//	*ClientStreamMessage_AzureAttestationResult
+	//	*ClientStreamMessage_AzureAttestationToken
 	Message       isClientStreamMessage_Message `protobuf_oneof:"message"`
 	unknownFields protoimpl.UnknownFields
 	sizeCache     protoimpl.SizeCache
@@ -528,10 +528,10 @@ func (x *ClientStreamMessage) GetVTPMattestationReport() *AttestationResponse {
 	return nil
 }
 
-func (x *ClientStreamMessage) GetAzureAttestationResult() *AzureAttestationResponse {
+func (x *ClientStreamMessage) GetAzureAttestationToken() *AzureAttestationToken {
 	if x != nil {
-		if x, ok := x.Message.(*ClientStreamMessage_AzureAttestationResult); ok {
-			return x.AzureAttestationResult
+		if x, ok := x.Message.(*ClientStreamMessage_AzureAttestationToken); ok {
+			return x.AzureAttestationToken
 		}
 	}
 	return nil
@@ -565,8 +565,8 @@ type ClientStreamMessage_VTPMattestationReport struct {
 	VTPMattestationReport *AttestationResponse `protobuf:"bytes,6,opt,name=vTPMattestationReport,proto3,oneof"`
 }
 
-type ClientStreamMessage_AzureAttestationResult struct {
-	AzureAttestationResult *AzureAttestationResponse `protobuf:"bytes,7,opt,name=azureAttestationResult,proto3,oneof"`
+type ClientStreamMessage_AzureAttestationToken struct {
+	AzureAttestationToken *AzureAttestationToken `protobuf:"bytes,7,opt,name=azureAttestationToken,proto3,oneof"`
 }
 
 func (*ClientStreamMessage_AgentLog) isClientStreamMessage_Message() {}
@@ -581,7 +581,7 @@ func (*ClientStreamMessage_AgentStateRes) isClientStreamMessage_Message() {}
 
 func (*ClientStreamMessage_VTPMattestationReport) isClientStreamMessage_Message() {}
 
-func (*ClientStreamMessage_AzureAttestationResult) isClientStreamMessage_Message() {}
+func (*ClientStreamMessage_AzureAttestationToken) isClientStreamMessage_Message() {}
 
 type ServerStreamMessage struct {
 	state protoimpl.MessageState `protogen:"open.v1"`
@@ -1209,7 +1209,7 @@ func (x *AttestationResponse) GetCertSerialNumber() string {
 	return ""
 }
 
-type AzureAttestationResponse struct {
+type AzureAttestationToken struct {
 	state            protoimpl.MessageState `protogen:"open.v1"`
 	File             []byte                 `protobuf:"bytes,1,opt,name=file,proto3" json:"file,omitempty"`
 	CertSerialNumber string                 `protobuf:"bytes,2,opt,name=certSerialNumber,proto3" json:"certSerialNumber,omitempty"`
@@ -1217,20 +1217,20 @@ type AzureAttestationResponse struct {
 	sizeCache        protoimpl.SizeCache
 }
 
-func (x *AzureAttestationResponse) Reset() {
-	*x = AzureAttestationResponse{}
+func (x *AzureAttestationToken) Reset() {
+	*x = AzureAttestationToken{}
 	mi := &file_agent_cvms_cvms_proto_msgTypes[17]
 	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
 	ms.StoreMessageInfo(mi)
 }
 
-func (x *AzureAttestationResponse) String() string {
+func (x *AzureAttestationToken) String() string {
 	return protoimpl.X.MessageStringOf(x)
 }
 
-func (*AzureAttestationResponse) ProtoMessage() {}
+func (*AzureAttestationToken) ProtoMessage() {}
 
-func (x *AzureAttestationResponse) ProtoReflect() protoreflect.Message {
+func (x *AzureAttestationToken) ProtoReflect() protoreflect.Message {
 	mi := &file_agent_cvms_cvms_proto_msgTypes[17]
 	if x != nil {
 		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
@@ -1242,19 +1242,19 @@ func (x *AzureAttestationResponse) ProtoReflect() protoreflect.Message {
 	return mi.MessageOf(x)
 }
 
-// Deprecated: Use AzureAttestationResponse.ProtoReflect.Descriptor instead.
-func (*AzureAttestationResponse) Descriptor() ([]byte, []int) {
+// Deprecated: Use AzureAttestationToken.ProtoReflect.Descriptor instead.
+func (*AzureAttestationToken) Descriptor() ([]byte, []int) {
 	return file_agent_cvms_cvms_proto_rawDescGZIP(), []int{17}
 }
 
-func (x *AzureAttestationResponse) GetFile() []byte {
+func (x *AzureAttestationToken) GetFile() []byte {
 	if x != nil {
 		return x.File
 	}
 	return nil
 }
 
-func (x *AzureAttestationResponse) GetCertSerialNumber() string {
+func (x *AzureAttestationToken) GetCertSerialNumber() string {
 	if x != nil {
 		return x.CertSerialNumber
 	}
@@ -1311,7 +1311,7 @@ var file_agent_cvms_cvms_proto_rawDesc = string([]byte{
 	0x09, 0x74, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x18, 0x04, 0x20, 0x01, 0x28, 0x0b,
 	0x32, 0x1a, 0x2e, 0x67, 0x6f, 0x6f, 0x67, 0x6c, 0x65, 0x2e, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x62,
 	0x75, 0x66, 0x2e, 0x54, 0x69, 0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x52, 0x09, 0x74, 0x69,
-	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xed, 0x03, 0x0a, 0x13, 0x43, 0x6c, 0x69, 0x65,
+	0x6d, 0x65, 0x73, 0x74, 0x61, 0x6d, 0x70, 0x22, 0xe8, 0x03, 0x0a, 0x13, 0x43, 0x6c, 0x69, 0x65,
 	0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
 	0x2d, 0x0a, 0x09, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x6c, 0x6f, 0x67, 0x18, 0x01, 0x20, 0x01,
 	0x28, 0x0b, 0x32, 0x0e, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x4c,
@@ -1336,103 +1336,103 @@ var file_agent_cvms_cvms_proto_rawDesc = string([]byte{
 	0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f,
 	0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x48, 0x00, 0x52, 0x15, 0x76, 0x54, 0x50,
 	0x4d, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x70, 0x6f,
-	0x72, 0x74, 0x12, 0x58, 0x0a, 0x16, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x18, 0x07, 0x20, 0x01,
-	0x28, 0x0b, 0x32, 0x1e, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41,
-	0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e,
-	0x73, 0x65, 0x48, 0x00, 0x52, 0x16, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73,
-	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x42, 0x09, 0x0a, 0x07,
-	0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0xca, 0x02, 0x0a, 0x13, 0x53, 0x65, 0x72, 0x76,
-	0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12,
-	0x38, 0x0a, 0x0c, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x18,
-	0x01, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x12, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x52, 0x75, 0x6e,
-	0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x72, 0x75, 0x6e,
-	0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x12, 0x31, 0x0a, 0x06, 0x72, 0x75, 0x6e,
-	0x52, 0x65, 0x71, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x76, 0x6d, 0x73,
-	0x2e, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6e, 0x52,
-	0x65, 0x71, 0x48, 0x00, 0x52, 0x06, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x12, 0x41, 0x0a, 0x0f,
-	0x73, 0x74, 0x6f, 0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18,
-	0x03, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x15, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x53, 0x74, 0x6f,
-	0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0f,
-	0x73, 0x74, 0x6f, 0x70, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12,
-	0x3b, 0x0a, 0x0d, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71,
-	0x18, 0x04, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x41, 0x67,
-	0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x0d, 0x61,
-	0x67, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x12, 0x3b, 0x0a, 0x0d,
-	0x64, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x18, 0x05, 0x20,
-	0x01, 0x28, 0x0b, 0x32, 0x13, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f,
-	0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x69, 0x73, 0x63,
-	0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73,
-	0x73, 0x61, 0x67, 0x65, 0x22, 0x1f, 0x0a, 0x0d, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65,
-	0x63, 0x74, 0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x02, 0x69, 0x64, 0x22, 0x4b, 0x0a, 0x0c, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x43,
-	0x68, 0x75, 0x6e, 0x6b, 0x73, 0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20,
-	0x01, 0x28, 0x0c, 0x52, 0x04, 0x64, 0x61, 0x74, 0x61, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18,
-	0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f,
-	0x6c, 0x61, 0x73, 0x74, 0x18, 0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x4c, 0x61,
-	0x73, 0x74, 0x22, 0xaa, 0x02, 0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65,
-	0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b,
-	0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28,
-	0x09, 0x52, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29,
-	0x0a, 0x08, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b,
-	0x32, 0x0d, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x52,
-	0x08, 0x64, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x61, 0x6c, 0x67,
-	0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x63,
-	0x76, 0x6d, 0x73, 0x2e, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x52, 0x09, 0x61,
-	0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x3f, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75,
-	0x6c, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03,
-	0x28, 0x0b, 0x32, 0x14, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74,
-	0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74,
-	0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x12, 0x34, 0x0a, 0x0c, 0x61, 0x67, 0x65,
-	0x6e, 0x74, 0x5f, 0x63, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32,
-	0x11, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66,
-	0x69, 0x67, 0x52, 0x0b, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22,
-	0x2a, 0x0a, 0x0e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65,
-	0x72, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0x53, 0x0a, 0x07, 0x44,
-	0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73,
-	0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65,
-	0x72, 0x4b, 0x65, 0x79, 0x12, 0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-	0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65,
-	0x22, 0x39, 0x0a, 0x09, 0x41, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x12, 0x0a,
-	0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73,
-	0x68, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0xe5, 0x01, 0x0a, 0x0b,
-	0x41, 0x67, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70,
-	0x6f, 0x72, 0x74, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12,
-	0x1b, 0x0a, 0x09, 0x63, 0x65, 0x72, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01,
-	0x28, 0x09, 0x52, 0x08, 0x63, 0x65, 0x72, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x19, 0x0a, 0x08,
-	0x6b, 0x65, 0x79, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07,
-	0x6b, 0x65, 0x79, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x6c, 0x69, 0x65, 0x6e,
-	0x74, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52,
-	0x0c, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x43, 0x61, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a,
-	0x0e, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18,
-	0x05, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x43, 0x61, 0x46,
-	0x69, 0x6c, 0x65, 0x12, 0x1b, 0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c,
-	0x18, 0x06, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c,
-	0x12, 0x21, 0x0a, 0x0c, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x6c, 0x73,
-	0x18, 0x07, 0x20, 0x01, 0x28, 0x08, 0x52, 0x0b, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64,
-	0x54, 0x6c, 0x73, 0x22, 0x55, 0x0a, 0x13, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
-	0x6f, 0x6e, 0x52, 0x65, 0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69,
-	0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x2a,
-	0x0a, 0x10, 0x63, 0x65, 0x72, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62,
-	0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x65, 0x72, 0x74, 0x53, 0x65,
-	0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x5a, 0x0a, 0x18, 0x61, 0x7a,
-	0x75, 0x72, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65,
-	0x73, 0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01,
-	0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x2a, 0x0a, 0x10, 0x63, 0x65,
-	0x72, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02,
-	0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x65, 0x72, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c,
-	0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x32, 0x50, 0x0a, 0x07, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63,
-	0x65, 0x12, 0x45, 0x0a, 0x07, 0x50, 0x72, 0x6f, 0x63, 0x65, 0x73, 0x73, 0x12, 0x19, 0x2e, 0x63,
-	0x76, 0x6d, 0x73, 0x2e, 0x43, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d,
-	0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a, 0x19, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x53,
-	0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61,
-	0x67, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01, 0x42, 0x08, 0x5a, 0x06, 0x2e, 0x2f, 0x63, 0x76,
-	0x6d, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74, 0x6f, 0x33,
+	0x72, 0x74, 0x12, 0x53, 0x0a, 0x15, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73,
+	0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x1b, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41, 0x74,
+	0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x48, 0x00,
+	0x52, 0x15, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69,
+	0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61,
+	0x67, 0x65, 0x22, 0xca, 0x02, 0x0a, 0x13, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72,
+	0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x12, 0x38, 0x0a, 0x0c, 0x72, 0x75,
+	0x6e, 0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x12, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x43, 0x68,
+	0x75, 0x6e, 0x6b, 0x73, 0x48, 0x00, 0x52, 0x0c, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x43, 0x68,
+	0x75, 0x6e, 0x6b, 0x73, 0x12, 0x31, 0x0a, 0x06, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x18, 0x02,
+	0x20, 0x01, 0x28, 0x0b, 0x32, 0x17, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x43, 0x6f, 0x6d, 0x70,
+	0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52,
+	0x06, 0x72, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x12, 0x41, 0x0a, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x43,
+	0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x0b,
+	0x32, 0x15, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x53, 0x74, 0x6f, 0x70, 0x43, 0x6f, 0x6d, 0x70,
+	0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x48, 0x00, 0x52, 0x0f, 0x73, 0x74, 0x6f, 0x70, 0x43,
+	0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x3b, 0x0a, 0x0d, 0x61, 0x67,
+	0x65, 0x6e, 0x74, 0x53, 0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x18, 0x04, 0x20, 0x01, 0x28,
+	0x0b, 0x32, 0x13, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x53, 0x74,
+	0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x0d, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x53,
+	0x74, 0x61, 0x74, 0x65, 0x52, 0x65, 0x71, 0x12, 0x3b, 0x0a, 0x0d, 0x64, 0x69, 0x73, 0x63, 0x6f,
+	0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x13,
+	0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74,
+	0x52, 0x65, 0x71, 0x48, 0x00, 0x52, 0x0d, 0x64, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63,
+	0x74, 0x52, 0x65, 0x71, 0x42, 0x09, 0x0a, 0x07, 0x6d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22,
+	0x1f, 0x0a, 0x0d, 0x44, 0x69, 0x73, 0x63, 0x6f, 0x6e, 0x6e, 0x65, 0x63, 0x74, 0x52, 0x65, 0x71,
+	0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52, 0x02, 0x69, 0x64,
+	0x22, 0x4b, 0x0a, 0x0c, 0x52, 0x75, 0x6e, 0x52, 0x65, 0x71, 0x43, 0x68, 0x75, 0x6e, 0x6b, 0x73,
+	0x12, 0x12, 0x0a, 0x04, 0x64, 0x61, 0x74, 0x61, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04,
+	0x64, 0x61, 0x74, 0x61, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x02, 0x69, 0x64, 0x12, 0x17, 0x0a, 0x07, 0x69, 0x73, 0x5f, 0x6c, 0x61, 0x73, 0x74, 0x18,
+	0x03, 0x20, 0x01, 0x28, 0x08, 0x52, 0x06, 0x69, 0x73, 0x4c, 0x61, 0x73, 0x74, 0x22, 0xaa, 0x02,
+	0x0a, 0x11, 0x43, 0x6f, 0x6d, 0x70, 0x75, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x75, 0x6e,
+	0x52, 0x65, 0x71, 0x12, 0x0e, 0x0a, 0x02, 0x69, 0x64, 0x18, 0x01, 0x20, 0x01, 0x28, 0x09, 0x52,
+	0x02, 0x69, 0x64, 0x12, 0x12, 0x0a, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x04, 0x6e, 0x61, 0x6d, 0x65, 0x12, 0x20, 0x0a, 0x0b, 0x64, 0x65, 0x73, 0x63, 0x72,
+	0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0b, 0x64, 0x65,
+	0x73, 0x63, 0x72, 0x69, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x12, 0x29, 0x0a, 0x08, 0x64, 0x61, 0x74,
+	0x61, 0x73, 0x65, 0x74, 0x73, 0x18, 0x04, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x0d, 0x2e, 0x63, 0x76,
+	0x6d, 0x73, 0x2e, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65, 0x74, 0x52, 0x08, 0x64, 0x61, 0x74, 0x61,
+	0x73, 0x65, 0x74, 0x73, 0x12, 0x2d, 0x0a, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68,
+	0x6d, 0x18, 0x05, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x0f, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x41,
+	0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x52, 0x09, 0x61, 0x6c, 0x67, 0x6f, 0x72, 0x69,
+	0x74, 0x68, 0x6d, 0x12, 0x3f, 0x0a, 0x10, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x5f, 0x63, 0x6f,
+	0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x73, 0x18, 0x06, 0x20, 0x03, 0x28, 0x0b, 0x32, 0x14, 0x2e,
+	0x63, 0x76, 0x6d, 0x73, 0x2e, 0x52, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75,
+	0x6d, 0x65, 0x72, 0x52, 0x0f, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75,
+	0x6d, 0x65, 0x72, 0x73, 0x12, 0x34, 0x0a, 0x0c, 0x61, 0x67, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x6f,
+	0x6e, 0x66, 0x69, 0x67, 0x18, 0x07, 0x20, 0x01, 0x28, 0x0b, 0x32, 0x11, 0x2e, 0x63, 0x76, 0x6d,
+	0x73, 0x2e, 0x41, 0x67, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x52, 0x0b, 0x61,
+	0x67, 0x65, 0x6e, 0x74, 0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x22, 0x2a, 0x0a, 0x0e, 0x52, 0x65,
+	0x73, 0x75, 0x6c, 0x74, 0x43, 0x6f, 0x6e, 0x73, 0x75, 0x6d, 0x65, 0x72, 0x12, 0x18, 0x0a, 0x07,
+	0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75,
+	0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0x53, 0x0a, 0x07, 0x44, 0x61, 0x74, 0x61, 0x73, 0x65,
+	0x74, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52,
+	0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79,
+	0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x12,
+	0x1a, 0x0a, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x66, 0x69, 0x6c, 0x65, 0x6e, 0x61, 0x6d, 0x65, 0x22, 0x39, 0x0a, 0x09, 0x41,
+	0x6c, 0x67, 0x6f, 0x72, 0x69, 0x74, 0x68, 0x6d, 0x12, 0x12, 0x0a, 0x04, 0x68, 0x61, 0x73, 0x68,
+	0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x68, 0x61, 0x73, 0x68, 0x12, 0x18, 0x0a, 0x07,
+	0x75, 0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x18, 0x02, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x07, 0x75,
+	0x73, 0x65, 0x72, 0x4b, 0x65, 0x79, 0x22, 0xe5, 0x01, 0x0a, 0x0b, 0x41, 0x67, 0x65, 0x6e, 0x74,
+	0x43, 0x6f, 0x6e, 0x66, 0x69, 0x67, 0x12, 0x12, 0x0a, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x18, 0x01,
+	0x20, 0x01, 0x28, 0x09, 0x52, 0x04, 0x70, 0x6f, 0x72, 0x74, 0x12, 0x1b, 0x0a, 0x09, 0x63, 0x65,
+	0x72, 0x74, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x08, 0x63,
+	0x65, 0x72, 0x74, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x19, 0x0a, 0x08, 0x6b, 0x65, 0x79, 0x5f, 0x66,
+	0x69, 0x6c, 0x65, 0x18, 0x03, 0x20, 0x01, 0x28, 0x09, 0x52, 0x07, 0x6b, 0x65, 0x79, 0x46, 0x69,
+	0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x63, 0x6c, 0x69, 0x65, 0x6e, 0x74, 0x5f, 0x63, 0x61, 0x5f,
+	0x66, 0x69, 0x6c, 0x65, 0x18, 0x04, 0x20, 0x01, 0x28, 0x09, 0x52, 0x0c, 0x63, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x43, 0x61, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x24, 0x0a, 0x0e, 0x73, 0x65, 0x72, 0x76,
+	0x65, 0x72, 0x5f, 0x63, 0x61, 0x5f, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x05, 0x20, 0x01, 0x28, 0x09,
+	0x52, 0x0c, 0x73, 0x65, 0x72, 0x76, 0x65, 0x72, 0x43, 0x61, 0x46, 0x69, 0x6c, 0x65, 0x12, 0x1b,
+	0x0a, 0x09, 0x6c, 0x6f, 0x67, 0x5f, 0x6c, 0x65, 0x76, 0x65, 0x6c, 0x18, 0x06, 0x20, 0x01, 0x28,
+	0x09, 0x52, 0x08, 0x6c, 0x6f, 0x67, 0x4c, 0x65, 0x76, 0x65, 0x6c, 0x12, 0x21, 0x0a, 0x0c, 0x61,
+	0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x5f, 0x74, 0x6c, 0x73, 0x18, 0x07, 0x20, 0x01, 0x28,
+	0x08, 0x52, 0x0b, 0x61, 0x74, 0x74, 0x65, 0x73, 0x74, 0x65, 0x64, 0x54, 0x6c, 0x73, 0x22, 0x55,
+	0x0a, 0x13, 0x41, 0x74, 0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x52, 0x65, 0x73,
+	0x70, 0x6f, 0x6e, 0x73, 0x65, 0x12, 0x12, 0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20,
+	0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x12, 0x2a, 0x0a, 0x10, 0x63, 0x65, 0x72,
+	0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20,
+	0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x65, 0x72, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e,
+	0x75, 0x6d, 0x62, 0x65, 0x72, 0x22, 0x57, 0x0a, 0x15, 0x61, 0x7a, 0x75, 0x72, 0x65, 0x41, 0x74,
+	0x74, 0x65, 0x73, 0x74, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x54, 0x6f, 0x6b, 0x65, 0x6e, 0x12, 0x12,
+	0x0a, 0x04, 0x66, 0x69, 0x6c, 0x65, 0x18, 0x01, 0x20, 0x01, 0x28, 0x0c, 0x52, 0x04, 0x66, 0x69,
+	0x6c, 0x65, 0x12, 0x2a, 0x0a, 0x10, 0x63, 0x65, 0x72, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c,
+	0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x18, 0x02, 0x20, 0x01, 0x28, 0x09, 0x52, 0x10, 0x63, 0x65,
+	0x72, 0x74, 0x53, 0x65, 0x72, 0x69, 0x61, 0x6c, 0x4e, 0x75, 0x6d, 0x62, 0x65, 0x72, 0x32, 0x50,
+	0x0a, 0x07, 0x53, 0x65, 0x72, 0x76, 0x69, 0x63, 0x65, 0x12, 0x45, 0x0a, 0x07, 0x50, 0x72, 0x6f,
+	0x63, 0x65, 0x73, 0x73, 0x12, 0x19, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x43, 0x6c, 0x69, 0x65,
+	0x6e, 0x74, 0x53, 0x74, 0x72, 0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x1a,
+	0x19, 0x2e, 0x63, 0x76, 0x6d, 0x73, 0x2e, 0x53, 0x65, 0x72, 0x76, 0x65, 0x72, 0x53, 0x74, 0x72,
+	0x65, 0x61, 0x6d, 0x4d, 0x65, 0x73, 0x73, 0x61, 0x67, 0x65, 0x22, 0x00, 0x28, 0x01, 0x30, 0x01,
+	0x42, 0x08, 0x5a, 0x06, 0x2e, 0x2f, 0x63, 0x76, 0x6d, 0x73, 0x62, 0x06, 0x70, 0x72, 0x6f, 0x74,
+	0x6f, 0x33,
 })
 
 var (
@@ -1449,25 +1449,25 @@ func file_agent_cvms_cvms_proto_rawDescGZIP() []byte {
 
 var file_agent_cvms_cvms_proto_msgTypes = make([]protoimpl.MessageInfo, 18)
 var file_agent_cvms_cvms_proto_goTypes = []any{
-	(*AgentStateReq)(nil),            // 0: cvms.AgentStateReq
-	(*AgentStateRes)(nil),            // 1: cvms.AgentStateRes
-	(*StopComputation)(nil),          // 2: cvms.StopComputation
-	(*StopComputationResponse)(nil),  // 3: cvms.StopComputationResponse
-	(*RunResponse)(nil),              // 4: cvms.RunResponse
-	(*AgentEvent)(nil),               // 5: cvms.AgentEvent
-	(*AgentLog)(nil),                 // 6: cvms.AgentLog
-	(*ClientStreamMessage)(nil),      // 7: cvms.ClientStreamMessage
-	(*ServerStreamMessage)(nil),      // 8: cvms.ServerStreamMessage
-	(*DisconnectReq)(nil),            // 9: cvms.DisconnectReq
-	(*RunReqChunks)(nil),             // 10: cvms.RunReqChunks
-	(*ComputationRunReq)(nil),        // 11: cvms.ComputationRunReq
-	(*ResultConsumer)(nil),           // 12: cvms.ResultConsumer
-	(*Dataset)(nil),                  // 13: cvms.Dataset
-	(*Algorithm)(nil),                // 14: cvms.Algorithm
-	(*AgentConfig)(nil),              // 15: cvms.AgentConfig
-	(*AttestationResponse)(nil),      // 16: cvms.AttestationResponse
-	(*AzureAttestationResponse)(nil), // 17: cvms.azureAttestationResponse
-	(*timestamppb.Timestamp)(nil),    // 18: google.protobuf.Timestamp
+	(*AgentStateReq)(nil),           // 0: cvms.AgentStateReq
+	(*AgentStateRes)(nil),           // 1: cvms.AgentStateRes
+	(*StopComputation)(nil),         // 2: cvms.StopComputation
+	(*StopComputationResponse)(nil), // 3: cvms.StopComputationResponse
+	(*RunResponse)(nil),             // 4: cvms.RunResponse
+	(*AgentEvent)(nil),              // 5: cvms.AgentEvent
+	(*AgentLog)(nil),                // 6: cvms.AgentLog
+	(*ClientStreamMessage)(nil),     // 7: cvms.ClientStreamMessage
+	(*ServerStreamMessage)(nil),     // 8: cvms.ServerStreamMessage
+	(*DisconnectReq)(nil),           // 9: cvms.DisconnectReq
+	(*RunReqChunks)(nil),            // 10: cvms.RunReqChunks
+	(*ComputationRunReq)(nil),       // 11: cvms.ComputationRunReq
+	(*ResultConsumer)(nil),          // 12: cvms.ResultConsumer
+	(*Dataset)(nil),                 // 13: cvms.Dataset
+	(*Algorithm)(nil),               // 14: cvms.Algorithm
+	(*AgentConfig)(nil),             // 15: cvms.AgentConfig
+	(*AttestationResponse)(nil),     // 16: cvms.AttestationResponse
+	(*AzureAttestationToken)(nil),   // 17: cvms.azureAttestationToken
+	(*timestamppb.Timestamp)(nil),   // 18: google.protobuf.Timestamp
 }
 var file_agent_cvms_cvms_proto_depIdxs = []int32{
 	18, // 0: cvms.AgentEvent.timestamp:type_name -> google.protobuf.Timestamp
@@ -1478,7 +1478,7 @@ var file_agent_cvms_cvms_proto_depIdxs = []int32{
 	3,  // 5: cvms.ClientStreamMessage.stopComputationRes:type_name -> cvms.StopComputationResponse
 	1,  // 6: cvms.ClientStreamMessage.agentStateRes:type_name -> cvms.AgentStateRes
 	16, // 7: cvms.ClientStreamMessage.vTPMattestationReport:type_name -> cvms.AttestationResponse
-	17, // 8: cvms.ClientStreamMessage.azureAttestationResult:type_name -> cvms.azureAttestationResponse
+	17, // 8: cvms.ClientStreamMessage.azureAttestationToken:type_name -> cvms.azureAttestationToken
 	10, // 9: cvms.ServerStreamMessage.runReqChunks:type_name -> cvms.RunReqChunks
 	11, // 10: cvms.ServerStreamMessage.runReq:type_name -> cvms.ComputationRunReq
 	2,  // 11: cvms.ServerStreamMessage.stopComputation:type_name -> cvms.StopComputation
@@ -1509,7 +1509,7 @@ func file_agent_cvms_cvms_proto_init() {
 		(*ClientStreamMessage_StopComputationRes)(nil),
 		(*ClientStreamMessage_AgentStateRes)(nil),
 		(*ClientStreamMessage_VTPMattestationReport)(nil),
-		(*ClientStreamMessage_AzureAttestationResult)(nil),
+		(*ClientStreamMessage_AzureAttestationToken)(nil),
 	}
 	file_agent_cvms_cvms_proto_msgTypes[8].OneofWrappers = []any{
 		(*ServerStreamMessage_RunReqChunks)(nil),
diff --git a/agent/cvms/cvms.proto b/agent/cvms/cvms.proto
index 0502e4f5..c31e3e81 100644
--- a/agent/cvms/cvms.proto
+++ b/agent/cvms/cvms.proto
@@ -60,7 +60,7 @@ message ClientStreamMessage {
     StopComputationResponse stopComputationRes = 4;
     AgentStateRes agentStateRes = 5;
     AttestationResponse vTPMattestationReport = 6;
-    azureAttestationResponse azureAttestationResult = 7;
+    azureAttestationToken azureAttestationToken = 7;
   }
 }
 
@@ -124,7 +124,7 @@ message AttestationResponse {
   string certSerialNumber = 2;
 }
 
-message azureAttestationResponse {
+message azureAttestationToken {
   bytes file = 1;
   string certSerialNumber = 2;
 }
diff --git a/agent/mocks/agent.go b/agent/mocks/agent.go
index 7a2899ca..1c998266 100644
--- a/agent/mocks/agent.go
+++ b/agent/mocks/agent.go
@@ -135,29 +135,29 @@ func (_c *Service_Attestation_Call) RunAndReturn(run func(context.Context, [64]b
 	return _c
 }
 
-// AttestationResult provides a mock function with given fields: ctx, nonce, attType
-func (_m *Service) AttestationResult(ctx context.Context, nonce [32]byte, attType attestation.PlatformType) ([]byte, error) {
-	ret := _m.Called(ctx, nonce, attType)
+// AzureAttestationToken provides a mock function with given fields: ctx, nonce
+func (_m *Service) AzureAttestationToken(ctx context.Context, nonce [32]byte) ([]byte, error) {
+	ret := _m.Called(ctx, nonce)
 
 	if len(ret) == 0 {
-		panic("no return value specified for AttestationResult")
+		panic("no return value specified for AzureAttestationToken")
 	}
 
 	var r0 []byte
 	var r1 error
-	if rf, ok := ret.Get(0).(func(context.Context, [32]byte, attestation.PlatformType) ([]byte, error)); ok {
-		return rf(ctx, nonce, attType)
+	if rf, ok := ret.Get(0).(func(context.Context, [32]byte) ([]byte, error)); ok {
+		return rf(ctx, nonce)
 	}
-	if rf, ok := ret.Get(0).(func(context.Context, [32]byte, attestation.PlatformType) []byte); ok {
-		r0 = rf(ctx, nonce, attType)
+	if rf, ok := ret.Get(0).(func(context.Context, [32]byte) []byte); ok {
+		r0 = rf(ctx, nonce)
 	} else {
 		if ret.Get(0) != nil {
 			r0 = ret.Get(0).([]byte)
 		}
 	}
 
-	if rf, ok := ret.Get(1).(func(context.Context, [32]byte, attestation.PlatformType) error); ok {
-		r1 = rf(ctx, nonce, attType)
+	if rf, ok := ret.Get(1).(func(context.Context, [32]byte) error); ok {
+		r1 = rf(ctx, nonce)
 	} else {
 		r1 = ret.Error(1)
 	}
@@ -165,32 +165,31 @@ func (_m *Service) AttestationResult(ctx context.Context, nonce [32]byte, attTyp
 	return r0, r1
 }
 
-// Service_AttestationResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttestationResult'
-type Service_AttestationResult_Call struct {
+// Service_AzureAttestationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AzureAttestationToken'
+type Service_AzureAttestationToken_Call struct {
 	*mock.Call
 }
 
-// AttestationResult is a helper method to define mock.On call
+// AzureAttestationToken is a helper method to define mock.On call
 //   - ctx context.Context
 //   - nonce [32]byte
-//   - attType attestation.PlatformType
-func (_e *Service_Expecter) AttestationResult(ctx interface{}, nonce interface{}, attType interface{}) *Service_AttestationResult_Call {
-	return &Service_AttestationResult_Call{Call: _e.mock.On("AttestationResult", ctx, nonce, attType)}
+func (_e *Service_Expecter) AzureAttestationToken(ctx interface{}, nonce interface{}) *Service_AzureAttestationToken_Call {
+	return &Service_AzureAttestationToken_Call{Call: _e.mock.On("AzureAttestationToken", ctx, nonce)}
 }
 
-func (_c *Service_AttestationResult_Call) Run(run func(ctx context.Context, nonce [32]byte, attType attestation.PlatformType)) *Service_AttestationResult_Call {
+func (_c *Service_AzureAttestationToken_Call) Run(run func(ctx context.Context, nonce [32]byte)) *Service_AzureAttestationToken_Call {
 	_c.Call.Run(func(args mock.Arguments) {
-		run(args[0].(context.Context), args[1].([32]byte), args[2].(attestation.PlatformType))
+		run(args[0].(context.Context), args[1].([32]byte))
 	})
 	return _c
 }
 
-func (_c *Service_AttestationResult_Call) Return(_a0 []byte, _a1 error) *Service_AttestationResult_Call {
+func (_c *Service_AzureAttestationToken_Call) Return(_a0 []byte, _a1 error) *Service_AzureAttestationToken_Call {
 	_c.Call.Return(_a0, _a1)
 	return _c
 }
 
-func (_c *Service_AttestationResult_Call) RunAndReturn(run func(context.Context, [32]byte, attestation.PlatformType) ([]byte, error)) *Service_AttestationResult_Call {
+func (_c *Service_AzureAttestationToken_Call) RunAndReturn(run func(context.Context, [32]byte) ([]byte, error)) *Service_AzureAttestationToken_Call {
 	_c.Call.Return(run)
 	return _c
 }
diff --git a/agent/service.go b/agent/service.go
index 67285bea..ae4bd642 100644
--- a/agent/service.go
+++ b/agent/service.go
@@ -123,7 +123,7 @@ type Service interface {
 	Result(ctx context.Context) ([]byte, error)
 	Attestation(ctx context.Context, reportData [quoteprovider.Nonce]byte, nonce [vtpm.Nonce]byte, attType attestation.PlatformType) ([]byte, error)
 	IMAMeasurements(ctx context.Context) ([]byte, []byte, error)
-	AttestationResult(ctx context.Context, nonce [vtpm.Nonce]byte, attType attestation.PlatformType) ([]byte, error)
+	AzureAttestationToken(ctx context.Context, nonce [vtpm.Nonce]byte) ([]byte, error)
 	State() string
 }
 
@@ -459,17 +459,16 @@ func (as *agentService) Attestation(ctx context.Context, reportData [quoteprovid
 	}
 }
 
-func (as *agentService) AttestationResult(ctx context.Context, nonce [vtpm.Nonce]byte, attType attestation.PlatformType) ([]byte, error) {
-	switch attType {
-	case attestation.AzureToken:
-		token, err := as.provider.AzureAttestationToken(nonce[:])
-		if err != nil {
-			return []byte{}, err
-		}
-		return token, nil
-	default:
+func (as *agentService) AzureAttestationToken(ctx context.Context, nonce [vtpm.Nonce]byte) ([]byte, error) {
+	if attestation.CCPlatform() != attestation.Azure {
 		return []byte{}, ErrAttestationType
 	}
+
+	token, err := as.provider.AzureAttestationToken(nonce[:])
+	if err != nil {
+		return []byte{}, err
+	}
+	return token, nil
 }
 
 func (as *agentService) runComputation(state statemachine.State) {
diff --git a/agent/service_test.go b/agent/service_test.go
index 7bd2e5a4..680331ba 100644
--- a/agent/service_test.go
+++ b/agent/service_test.go
@@ -411,35 +411,31 @@ func TestAttestation(t *testing.T) {
 	}
 }
 
-func TestAttestationResult(t *testing.T) {
+func TestAzureAttestationToken(t *testing.T) {
 	provider := new(mocks2.Provider)
 	cases := []struct {
-		name     string
-		nonce    [vtpm.Nonce]byte
-		platform attestation.PlatformType
-		token    []byte
-		err      error
+		name  string
+		nonce [vtpm.Nonce]byte
+		token []byte
+		err   error
 	}{
 		{
-			name:     "Azure token fetch successful",
-			nonce:    [32]byte{1, 2, 3}, // any test nonce
-			platform: attestation.AzureToken,
-			token:    []byte("mockToken"),
-			err:      nil,
+			name:  "Azure token fetch successful",
+			nonce: [32]byte{1, 2, 3}, // any test nonce
+			token: []byte("mockToken"),
+			err:   ErrAttestationType,
 		},
 		{
-			name:     "Azure token fetch failed",
-			nonce:    [32]byte{4, 5, 6},
-			platform: attestation.AzureToken,
-			token:    []byte{},
-			err:      ErrFetchAzureToken,
+			name:  "Azure token fetch failed",
+			nonce: [32]byte{4, 5, 6},
+			token: []byte{},
+			err:   ErrAttestationType,
 		},
 		{
-			name:     "Invalid attestation type",
-			nonce:    [32]byte{7, 8, 9},
-			platform: attestation.SNP,
-			token:    []byte{},
-			err:      ErrAttestationType,
+			name:  "Invalid attestation type",
+			nonce: [32]byte{7, 8, 9},
+			token: []byte{},
+			err:   ErrAttestationType,
 		},
 	}
 
@@ -448,17 +444,14 @@ func TestAttestationResult(t *testing.T) {
 			events := new(mocks.Service)
 			events.EXPECT().SendEvent(mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return()
 
-			if tc.platform == attestation.AzureToken {
-				provider.On("AzureAttestationToken", tc.nonce[:]).Return(tc.token, tc.err)
-			}
+			provider.On("AzureAttestationToken", tc.nonce[:]).Return(tc.token, tc.err)
 
 			ctx := context.Background()
 
 			svc := New(ctx, mglog.NewMock(), events, provider, 0)
 
-			result, err := svc.AttestationResult(ctx, tc.nonce, tc.platform)
+			_, err := svc.AzureAttestationToken(ctx, tc.nonce)
 			assert.True(t, errors.Contains(err, tc.err), "expected error %v, got %v", tc.err, err)
-			assert.Equal(t, tc.token, result)
 		})
 	}
 }
diff --git a/cli/attestation.go b/cli/attestation.go
index b7ca8478..f089a139 100644
--- a/cli/attestation.go
+++ b/cli/attestation.go
@@ -148,25 +148,24 @@ func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
 				attType = attestation.SNPvTPM
 			case AzureToken:
 				cmd.Println("Fetching Azure token")
-				attType = attestation.AzureToken
 			case TDX:
 				cmd.Println("Fetching TDX attestation report")
 				attType = attestation.TDX
 			}
 
-			if (attType == attestation.VTPM || attType == attestation.SNPvTPM) && len(nonce) == 0 {
+			if (attestationType == VTPM || attestationType == SNPvTPM) && len(nonce) == 0 {
 				msg := color.New(color.FgRed).Sprint("vTPM nonce must be defined for vTPM attestation ❌ ")
 				cmd.Println(msg)
 				return
 			}
 
-			if (attType == attestation.SNP || attType == attestation.SNPvTPM) && len(teeNonce) == 0 {
+			if (attestationType == SNP || attestationType == SNPvTPM) && len(teeNonce) == 0 {
 				msg := color.New(color.FgRed).Sprint("TEE nonce must be defined for SEV-SNP attestation ❌ ")
 				cmd.Println(msg)
 				return
 			}
 
-			if (attType == attestation.AzureToken) && len(tokenNonce) == 0 {
+			if (attestationType == AzureToken) && len(tokenNonce) == 0 {
 				msg := color.New(color.FgRed).Sprint("Token nonce must be defined for Azure attestation ❌ ")
 				cmd.Println(msg)
 				return
@@ -184,13 +183,13 @@ func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
 			}
 
 			var fixedVtpmNonceByte [vtpm.Nonce]byte
-			if attType != attestation.SNP {
+			if attType != attestation.SNP || attestationType == AzureToken {
 				if (len(nonce) > vtpm.Nonce) || (len(tokenNonce) > vtpm.Nonce) {
 					msg := color.New(color.FgRed).Sprintf("vTPM nonce must be a hex encoded string of length lesser or equal %d bytes ❌ ", vtpm.Nonce)
 					cmd.Println(msg)
 					return
 				}
-				if attType == attestation.AzureToken {
+				if attestationType == AzureToken {
 					copy(fixedVtpmNonceByte[:], tokenNonce)
 				} else {
 					copy(fixedVtpmNonceByte[:], nonce)
@@ -199,7 +198,7 @@ func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
 
 			filename := attestationFilePath
 
-			if attType == attestation.AzureToken {
+			if attestationType == AzureToken {
 				filename = azureAttestResultFilePath
 			}
 
@@ -217,10 +216,10 @@ func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
 
 			var returnJsonAzureToken bool
 
-			if attType == attestation.AzureToken {
-				err := cli.agentSDK.AttestationResult(cmd.Context(), fixedVtpmNonceByte, int(attType), attestationFile)
+			if attestationType == AzureToken {
+				err := cli.agentSDK.AttestationToken(cmd.Context(), fixedVtpmNonceByte, int(attType), attestationFile)
 				if err != nil {
-					printError(cmd, "Failed to get attestation result due to error: %v ❌", err)
+					printError(cmd, "Failed to get attestation token due to error: %v ❌", err)
 					return
 				}
 				returnJsonAzureToken = !getAzureTokenJWT
@@ -279,7 +278,7 @@ func (cli *CLI) NewGetAttestationCmd() *cobra.Command {
 				}
 			}
 
-			cmd.Println("Attestation result retrieved and saved successfully!")
+			cmd.Println("Attestation retrieved and saved successfully!")
 		},
 	}
 
diff --git a/cli/attestation_policy_test.go b/cli/attestation_policy_test.go
index 3984a01e..6ceef637 100644
--- a/cli/attestation_policy_test.go
+++ b/cli/attestation_policy_test.go
@@ -5,7 +5,6 @@ package cli
 import (
 	"bytes"
 	"encoding/base64"
-	"encoding/json"
 	"os"
 	"testing"
 
@@ -23,7 +22,7 @@ func TestChangeAttestationConfiguration(t *testing.T) {
 
 	initialConfig := attestation.Config{Config: &check.Config{RootOfTrust: &check.RootOfTrust{}, Policy: &check.Policy{}}, PcrConfig: &attestation.PcrConfig{}}
 
-	initialJSON, err := json.Marshal(initialConfig)
+	initialJSON, err := vtpm.ConvertPolicyToJSON(&initialConfig)
 	require.NoError(t, err)
 	err = os.WriteFile(tmpfile.Name(), initialJSON, 0o644)
 	require.NoError(t, err)
diff --git a/cli/attestation_test.go b/cli/attestation_test.go
index 4a1ec6f3..57629180 100644
--- a/cli/attestation_test.go
+++ b/cli/attestation_test.go
@@ -67,21 +67,21 @@ func TestNewGetAttestationCmd(t *testing.T) {
 			args:         []string{"snp", "--tee", teeNonce},
 			mockResponse: []byte("mock attestation"),
 			mockError:    nil,
-			expectedOut:  "Attestation result retrieved and saved successfully!",
+			expectedOut:  "Attestation retrieved and saved successfully!",
 		},
 		{
 			name:         "successful vTPM attestation retrieval",
 			args:         []string{"vtpm", "--vtpm", vtpmNonce},
 			mockResponse: []byte("mock attestation"),
 			mockError:    nil,
-			expectedOut:  "Attestation result retrieved and saved successfully!",
+			expectedOut:  "Attestation retrieved and saved successfully!",
 		},
 		{
 			name:         "successful SNP-vTPM attestation retrieval",
 			args:         []string{"snp-vtpm", "--tee", teeNonce, "--vtpm", vtpmNonce},
 			mockResponse: []byte("mock attestation"),
 			mockError:    nil,
-			expectedOut:  "Attestation result retrieved and saved successfully!",
+			expectedOut:  "Attestation retrieved and saved successfully!",
 		},
 		{
 			name:         "missing vTPM nonce",
@@ -137,7 +137,7 @@ func TestNewGetAttestationCmd(t *testing.T) {
 			args:         []string{"snp", "--tee", teeNonce, "--reporttextproto"},
 			mockResponse: validattestation,
 			mockError:    nil,
-			expectedOut:  "Attestation result retrieved and saved successfully!",
+			expectedOut:  "Attestation retrieved and saved successfully!",
 		},
 		{
 			name:         "connection error",
@@ -151,14 +151,14 @@ func TestNewGetAttestationCmd(t *testing.T) {
 			args:         []string{"azure-token", "--token", tokenNonce},
 			mockResponse: []byte("eyJhbGciOiAiUlMyNTYifQ.eyJzdWIiOiAidGVzdC11c2VyIn0.signature"),
 			mockError:    nil,
-			expectedOut:  "Fetching Azure token\nAttestation result retrieved and saved successfully!\n",
+			expectedOut:  "Fetching Azure token\nAttestation retrieved and saved successfully!\n",
 		},
 		{
 			name:         "failed to retrieve Azure token",
 			args:         []string{"azure-token", "--token", tokenNonce},
 			mockResponse: nil,
 			mockError:    errors.New("error"),
-			expectedErr:  "Fetching Azure token\nFailed to get attestation result due to error: error ❌\n",
+			expectedErr:  "Fetching Azure token\nFailed to get attestation token due to error: error ❌\n",
 		},
 		{
 			name:         "invalid token nonce size",
@@ -189,7 +189,7 @@ func TestNewGetAttestationCmd(t *testing.T) {
 				require.NoError(t, err)
 			})
 
-			mockSDK.On("AttestationResult", mock.Anything, [vtpm.Nonce]byte(bytes.Repeat([]byte{0x00}, vtpm.Nonce)), mock.Anything, mock.Anything).Return(tc.mockError).Run(func(args mock.Arguments) {
+			mockSDK.On("AttestationToken", mock.Anything, [vtpm.Nonce]byte(bytes.Repeat([]byte{0x00}, vtpm.Nonce)), mock.Anything, mock.Anything).Return(tc.mockError).Run(func(args mock.Arguments) {
 				_, err := args.Get(3).(*os.File).Write(tc.mockResponse)
 				require.NoError(t, err)
 			})
diff --git a/cli/datasets.go b/cli/datasets.go
index 15aeb9f9..a5de32ce 100644
--- a/cli/datasets.go
+++ b/cli/datasets.go
@@ -44,6 +44,7 @@ func (cli *CLI) NewDatasetsCmd() *cobra.Command {
 			var dataset *os.File
 
 			if f.IsDir() {
+				cmd.Println("Detected directory, zipping dataset...")
 				dataset, err = internal.ZipDirectoryToTempFile(datasetPath)
 				if err != nil {
 					printError(cmd, "Error zipping dataset directory: %v ❌ ", err)
diff --git a/cmd/agent/main.go b/cmd/agent/main.go
index 8fe42e6e..4d5b954c 100644
--- a/cmd/agent/main.go
+++ b/cmd/agent/main.go
@@ -196,16 +196,16 @@ func main() {
 	}
 
 	if ccPlatform == attestation.Azure {
-		azureAttestationResult, azureCertSerialNumber, err := azureAttestationFromCert(ctx, cvmGrpcConfig.ClientCert, svc)
+		azureAttestationToken, azureCertSerialNumber, err := azureAttestationFromCert(ctx, cvmGrpcConfig.ClientCert, svc)
 		if err != nil {
 			logger.Error(fmt.Sprintf("failed to get attestation: %s", err))
 			exitCode = 1
 			return
 		}
 		eventsLogsQueue <- &cvms.ClientStreamMessage{
-			Message: &cvms.ClientStreamMessage_AzureAttestationResult{
-				AzureAttestationResult: &cvms.AzureAttestationResponse{
-					File:             azureAttestationResult,
+			Message: &cvms.ClientStreamMessage_AzureAttestationToken{
+				AzureAttestationToken: &cvms.AzureAttestationToken{
+					File:             azureAttestationToken,
 					CertSerialNumber: azureCertSerialNumber,
 				},
 			},
@@ -279,7 +279,7 @@ func azureAttestationFromCert(ctx context.Context, certFilePath string, svc agen
 	}
 
 	nonceAzure := sha256.Sum256(certFile)
-	attestation, err := svc.AttestationResult(ctx, nonceAzure, attestation.AzureToken)
+	attestation, err := svc.AzureAttestationToken(ctx, nonceAzure)
 	if err != nil {
 		return nil, "", err
 	}
diff --git a/internal/zip.go b/internal/zip.go
index c3bba928..11762cc7 100644
--- a/internal/zip.go
+++ b/internal/zip.go
@@ -111,6 +111,10 @@ func ZipDirectoryToTempFile(sourceDir string) (*os.File, error) {
 		return nil, err
 	}
 
+	if _, err := tmpFile.Seek(0, 0); err != nil {
+		return nil, err
+	}
+
 	return tmpFile, nil
 }
 
diff --git a/pkg/attestation/attestation.go b/pkg/attestation/attestation.go
index 2769a800..fa44b1b2 100644
--- a/pkg/attestation/attestation.go
+++ b/pkg/attestation/attestation.go
@@ -20,7 +20,6 @@ const (
 	SNP PlatformType = iota
 	VTPM
 	SNPvTPM
-	AzureToken
 	Azure
 	TDX
 	NoCC
diff --git a/pkg/sdk/agent.go b/pkg/sdk/agent.go
index 98fa3877..c7f40281 100644
--- a/pkg/sdk/agent.go
+++ b/pkg/sdk/agent.go
@@ -28,7 +28,7 @@ type SDK interface {
 	Result(ctx context.Context, privKey any, resultFile *os.File) error
 	Attestation(ctx context.Context, reportData [size64]byte, nonce [size32]byte, attType int, attestationFile *os.File) error
 	IMAMeasurements(ctx context.Context, resultFile *os.File) ([]byte, error)
-	AttestationResult(ctx context.Context, nonce [size32]byte, attType int, attestationFile *os.File) error
+	AttestationToken(ctx context.Context, nonce [size32]byte, attType int, attestationFile *os.File) error
 }
 
 const (
@@ -157,20 +157,20 @@ func (sdk *agentSDK) Attestation(ctx context.Context, reportData [size64]byte, n
 	return pb.ReceiveAttestation(attestationProgressDescription, fileSize, stream, attestationFile)
 }
 
-func (sdk *agentSDK) AttestationResult(ctx context.Context, nonce [size32]byte, attType int, attestationResultFile *os.File) error {
-	request := &agent.AttestationResultRequest{
+func (sdk *agentSDK) AttestationToken(ctx context.Context, nonce [size32]byte, attType int, attestationTokenFile *os.File) error {
+	request := &agent.AttestationTokenRequest{
 		TokenNonce: nonce[:],
 		Type:       int32(attType),
 	}
 
-	result, err := sdk.client.AttestationResult(ctx, request)
+	result, err := sdk.client.AzureAttestationToken(ctx, request)
 	if err != nil {
 		return errors.Wrap(errors.New("failed to fetch attestation token"), err)
 	}
 
-	_, err = attestationResultFile.Write(result.GetFile())
+	_, err = attestationTokenFile.Write(result.GetFile())
 	if err != nil {
-		return errors.Wrap(errors.New("failed to write attestation result to file"), err)
+		return errors.Wrap(errors.New("failed to write attestation token to file"), err)
 	}
 
 	return nil
diff --git a/pkg/sdk/agent_test.go b/pkg/sdk/agent_test.go
index 061f20fe..f20a4ddc 100644
--- a/pkg/sdk/agent_test.go
+++ b/pkg/sdk/agent_test.go
@@ -220,7 +220,7 @@ func TestData(t *testing.T) {
 				Hash:    dataHash,
 			},
 			userKey: dataProvider1Key,
-			svcErr:  errors.New("dataset CSV file is required"),
+			svcErr:  errors.New("dataset is required"),
 		},
 	}
 
@@ -475,7 +475,7 @@ func TestAttestation(t *testing.T) {
 	}
 }
 
-func TestAttestationResult(t *testing.T) {
+func TestAttestationToken(t *testing.T) {
 	reportData := make([]byte, 64)
 	nonce := make([]byte, 64)
 	report := []byte{
@@ -499,23 +499,23 @@ func TestAttestationResult(t *testing.T) {
 	cases := []struct {
 		name     string
 		nonce    [vtpm.Nonce]byte
-		response *agent.AttestationResultResponse
+		response *agent.AttestationTokenResponse
 		svcRes   []byte
 		err      error
 	}{
 		{
-			name:  "fetch attestation report successfully",
+			name:  "fetch attestation token successfully",
 			nonce: [vtpm.Nonce]byte(nonce),
-			response: &agent.AttestationResultResponse{
+			response: &agent.AttestationTokenResponse{
 				File: report,
 			},
 			svcRes: report,
 			err:    nil,
 		},
 		{
-			name:  "failed to fetch attestation report",
+			name:  "failed to fetch attestation token",
 			nonce: [vtpm.Nonce]byte(nonce),
-			response: &agent.AttestationResultResponse{
+			response: &agent.AttestationTokenResponse{
 				File: []byte{},
 			},
 			err: nil,
@@ -524,7 +524,7 @@ func TestAttestationResult(t *testing.T) {
 
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
-			svcCall := svc.On("AttestationResult", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tc.svcRes, tc.err)
+			svcCall := svc.On("AzureAttestationToken", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(tc.svcRes, tc.err)
 
 			file, err := os.CreateTemp("", "attestation")
 			require.NoError(t, err)
@@ -533,7 +533,7 @@ func TestAttestationResult(t *testing.T) {
 				os.Remove(file.Name())
 			})
 
-			err = sdk.AttestationResult(context.Background(), tc.nonce, 0, file)
+			err = sdk.AttestationToken(context.Background(), tc.nonce, 0, file)
 
 			require.NoError(t, file.Close())
 
diff --git a/pkg/sdk/mocks/sdk.go b/pkg/sdk/mocks/sdk.go
index cb194af6..c6e0f0ac 100644
--- a/pkg/sdk/mocks/sdk.go
+++ b/pkg/sdk/mocks/sdk.go
@@ -124,12 +124,12 @@ func (_c *SDK_Attestation_Call) RunAndReturn(run func(context.Context, [64]byte,
 	return _c
 }
 
-// AttestationResult provides a mock function with given fields: ctx, nonce, attType, attestationFile
-func (_m *SDK) AttestationResult(ctx context.Context, nonce [32]byte, attType int, attestationFile *os.File) error {
+// AttestationToken provides a mock function with given fields: ctx, nonce, attType, attestationFile
+func (_m *SDK) AttestationToken(ctx context.Context, nonce [32]byte, attType int, attestationFile *os.File) error {
 	ret := _m.Called(ctx, nonce, attType, attestationFile)
 
 	if len(ret) == 0 {
-		panic("no return value specified for AttestationResult")
+		panic("no return value specified for AttestationToken")
 	}
 
 	var r0 error
@@ -142,33 +142,33 @@ func (_m *SDK) AttestationResult(ctx context.Context, nonce [32]byte, attType in
 	return r0
 }
 
-// SDK_AttestationResult_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttestationResult'
-type SDK_AttestationResult_Call struct {
+// SDK_AttestationToken_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AttestationToken'
+type SDK_AttestationToken_Call struct {
 	*mock.Call
 }
 
-// AttestationResult is a helper method to define mock.On call
+// AttestationToken is a helper method to define mock.On call
 //   - ctx context.Context
 //   - nonce [32]byte
 //   - attType int
 //   - attestationFile *os.File
-func (_e *SDK_Expecter) AttestationResult(ctx interface{}, nonce interface{}, attType interface{}, attestationFile interface{}) *SDK_AttestationResult_Call {
-	return &SDK_AttestationResult_Call{Call: _e.mock.On("AttestationResult", ctx, nonce, attType, attestationFile)}
+func (_e *SDK_Expecter) AttestationToken(ctx interface{}, nonce interface{}, attType interface{}, attestationFile interface{}) *SDK_AttestationToken_Call {
+	return &SDK_AttestationToken_Call{Call: _e.mock.On("AttestationToken", ctx, nonce, attType, attestationFile)}
 }
 
-func (_c *SDK_AttestationResult_Call) Run(run func(ctx context.Context, nonce [32]byte, attType int, attestationFile *os.File)) *SDK_AttestationResult_Call {
+func (_c *SDK_AttestationToken_Call) Run(run func(ctx context.Context, nonce [32]byte, attType int, attestationFile *os.File)) *SDK_AttestationToken_Call {
 	_c.Call.Run(func(args mock.Arguments) {
 		run(args[0].(context.Context), args[1].([32]byte), args[2].(int), args[3].(*os.File))
 	})
 	return _c
 }
 
-func (_c *SDK_AttestationResult_Call) Return(_a0 error) *SDK_AttestationResult_Call {
+func (_c *SDK_AttestationToken_Call) Return(_a0 error) *SDK_AttestationToken_Call {
 	_c.Call.Return(_a0)
 	return _c
 }
 
-func (_c *SDK_AttestationResult_Call) RunAndReturn(run func(context.Context, [32]byte, int, *os.File) error) *SDK_AttestationResult_Call {
+func (_c *SDK_AttestationToken_Call) RunAndReturn(run func(context.Context, [32]byte, int, *os.File) error) *SDK_AttestationToken_Call {
 	_c.Call.Return(run)
 	return _c
 }