diff --git a/common/test/pldm_utils_test.cpp b/common/test/pldm_utils_test.cpp
index 11bf027..210e27a 100644
--- a/common/test/pldm_utils_test.cpp
+++ b/common/test/pldm_utils_test.cpp
@@ -104,7 +104,7 @@
     state->state_set_id = 196;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
 
@@ -137,7 +137,7 @@
     state->state_set_id = 196;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
 
@@ -186,7 +186,7 @@
     state->state_set_id = 129;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
@@ -206,7 +206,7 @@
     state_second->state_set_id = 129;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     uint16_t entityID_ = 31;
     uint16_t stateSetId_ = 129;
@@ -243,7 +243,7 @@
     state->state_set_id = 198;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
@@ -263,7 +263,7 @@
     state_second->state_set_id = 169;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
 
@@ -296,7 +296,7 @@
     state->state_set_id = 198;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
@@ -316,7 +316,7 @@
     state_second->state_set_id = 192;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
 
@@ -350,7 +350,7 @@
     state->state_set_id = 198;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
@@ -370,7 +370,7 @@
     state_second->state_set_id = 192;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_third(
         sizeof(struct pldm_state_effecter_pdr) - sizeof(uint8_t) +
@@ -434,7 +434,7 @@
     state->state_set_id = 192;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
 
@@ -479,7 +479,7 @@
     state->state_set_id = 123;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateEffecterPDR(tid, entityID, stateSetId, repo);
 
@@ -512,7 +512,7 @@
     state->state_set_id = 1;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
 
@@ -545,7 +545,7 @@
     state->state_set_id = 1;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
 
@@ -594,7 +594,7 @@
     state->state_set_id = 1;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
@@ -614,7 +614,7 @@
     state_second->state_set_id = 1;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     uint16_t entityID_ = 5;
     uint16_t stateSetId_ = 1;
@@ -651,7 +651,7 @@
     state->state_set_id = 2;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
@@ -671,7 +671,7 @@
     state_second->state_set_id = 3;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
 
@@ -704,7 +704,7 @@
     state->state_set_id = 20;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
@@ -724,7 +724,7 @@
     state_second->state_set_id = 1;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
 
@@ -758,7 +758,7 @@
     state->state_set_id = 9;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_second(
         sizeof(struct pldm_state_sensor_pdr) - sizeof(uint8_t) +
@@ -778,7 +778,7 @@
     state_second->state_set_id = 1;
     state_second->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false);
+    pldm_pdr_add(repo, pdr_second.data(), pdr_second.size(), 0, false, 1);
 
     std::vector<uint8_t> pdr_third(sizeof(struct pldm_state_sensor_pdr) -
                                    sizeof(uint8_t) +
@@ -843,7 +843,7 @@
     state->state_set_id = 1;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
 
@@ -888,7 +888,7 @@
     state->state_set_id = 39;
     state->possible_states_size = 1;
 
-    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false);
+    pldm_pdr_add(repo, pdr.data(), pdr.size(), 0, false, 1);
 
     auto record = findStateSensorPDR(tid, entityID, stateSetId, repo);
 
@@ -955,4 +955,4 @@
     std::string s5 = "aa\\";
     auto results5 = split(s5, "\\");
     EXPECT_EQ(results5[0], "aa");
-}
\ No newline at end of file
+}
diff --git a/host-bmc/host_pdr_handler.cpp b/host-bmc/host_pdr_handler.cpp
index f23407b..f4c86e6 100644
--- a/host-bmc/host_pdr_handler.cpp
+++ b/host-bmc/host_pdr_handler.cpp
@@ -27,6 +27,25 @@
 const Json emptyJson{};
 const std::vector<Json> emptyJsonList{};
 
+template <typename T>
+uint16_t extractTerminusHandle(std::vector<uint8_t>& pdr)
+{
+    T* var = nullptr;
+    if (std::is_same<T, pldm_pdr_fru_record_set>::value)
+    {
+        var = (T*)(pdr.data() + sizeof(pldm_pdr_hdr));
+    }
+    else
+    {
+        var = (T*)(pdr.data());
+    }
+    if (var != nullptr)
+    {
+        return var->terminus_handle;
+    }
+    return TERMINUS_HANDLE;
+}
+
 HostPDRHandler::HostPDRHandler(
     int mctp_fd, uint8_t mctp_eid, sdeventplus::Event& event, pldm_pdr* repo,
     const std::string& eventsJsonsDir, pldm_entity_association_tree* entityTree,
@@ -226,8 +245,8 @@
         }
         else
         {
-            pldm_entity_association_pdr_add_from_node(node, repo, &entities,
-                                                      numEntities, true);
+            pldm_entity_association_pdr_add_from_node(
+                node, repo, &entities, numEntities, true, TERMINUS_HANDLE);
         }
     }
     free(entities);
@@ -370,6 +389,7 @@
     bool tlValid = true;
     uint32_t rh = 0;
     uint16_t terminusHandle = 0;
+    uint16_t pdrTerminusHandle = 0;
     uint8_t tid = 0;
 
     uint8_t completionCode{};
@@ -439,6 +459,8 @@
             {
                 if (pdrHdr->type == PLDM_TERMINUS_LOCATOR_PDR)
                 {
+                    pdrTerminusHandle =
+                        extractTerminusHandle<pldm_terminus_locator_pdr>(pdr);
                     auto tlpdr =
                         reinterpret_cast<const pldm_terminus_locator_pdr*>(
                             pdr.data());
@@ -464,9 +486,26 @@
                 }
                 else if (pdrHdr->type == PLDM_STATE_SENSOR_PDR)
                 {
+                    pdrTerminusHandle =
+                        extractTerminusHandle<pldm_state_sensor_pdr>(pdr);
                     stateSensorPDRs.emplace_back(pdr);
                 }
-
+                else if (pdrHdr->type == PLDM_PDR_FRU_RECORD_SET)
+                {
+                    pdrTerminusHandle =
+                        extractTerminusHandle<pldm_pdr_fru_record_set>(pdr);
+                }
+                else if (pdrHdr->type == PLDM_STATE_EFFECTER_PDR)
+                {
+                    pdrTerminusHandle =
+                        extractTerminusHandle<pldm_state_effecter_pdr>(pdr);
+                }
+                else if (pdrHdr->type == PLDM_NUMERIC_EFFECTER_PDR)
+                {
+                    pdrTerminusHandle =
+                        extractTerminusHandle<pldm_numeric_effecter_value_pdr>(
+                            pdr);
+                }
                 // if the TLPDR is invalid update the repo accordingly
                 if (!tlValid)
                 {
@@ -475,7 +514,8 @@
                 }
                 else
                 {
-                    pldm_pdr_add(repo, pdr.data(), respCount, rh, true);
+                    pldm_pdr_add(repo, pdr.data(), respCount, rh, true,
+                                 pdrTerminusHandle);
                 }
             }
         }
diff --git a/libpldm/pdr.c b/libpldm/pdr.c
index eeb9805..b057e3d 100644
--- a/libpldm/pdr.c
+++ b/libpldm/pdr.c
@@ -10,6 +10,7 @@
 	uint8_t *data;
 	struct pldm_pdr_record *next;
 	bool is_remote;
+	uint16_t terminus_handle;
 } pldm_pdr_record;
 
 typedef struct pldm_pdr {
@@ -60,7 +61,8 @@
 
 static pldm_pdr_record *make_new_record(const pldm_pdr *repo,
 					const uint8_t *data, uint32_t size,
-					uint32_t record_handle, bool is_remote)
+					uint32_t record_handle, bool is_remote,
+					uint16_t terminus_handle)
 {
 	assert(repo != NULL);
 	assert(size != 0);
@@ -71,6 +73,7 @@
 	    record_handle == 0 ? get_new_record_handle(repo) : record_handle;
 	record->size = size;
 	record->is_remote = is_remote;
+	record->terminus_handle = terminus_handle;
 	if (data != NULL) {
 		record->data = malloc(size);
 		assert(record->data != NULL);
@@ -93,13 +96,14 @@
 }
 
 uint32_t pldm_pdr_add(pldm_pdr *repo, const uint8_t *data, uint32_t size,
-		      uint32_t record_handle, bool is_remote)
+		      uint32_t record_handle, bool is_remote,
+		      uint16_t terminus_handle)
 {
 	assert(size != 0);
 	assert(data != NULL);
 
-	pldm_pdr_record *record =
-	    make_new_record(repo, data, size, record_handle, is_remote);
+	pldm_pdr_record *record = make_new_record(
+	    repo, data, size, record_handle, is_remote, terminus_handle);
 	add_record(repo, record);
 
 	return record->record_handle;
@@ -272,7 +276,8 @@
 	fru->entity_instance_num = htole16(entity_instance_num);
 	fru->container_id = htole16(container_id);
 
-	return pldm_pdr_add(repo, data, size, bmc_record_handle, false);
+	return pldm_pdr_add(repo, data, size, bmc_record_handle, false,
+			    terminus_handle);
 }
 
 const pldm_pdr_record *pldm_pdr_fru_record_set_find_by_rsi(
@@ -600,7 +605,8 @@
 					      pldm_pdr *repo, uint16_t size,
 					      uint8_t contained_count,
 					      uint8_t association_type,
-					      bool is_remote)
+					      bool is_remote,
+					      uint16_t terminus_handle)
 {
 	uint8_t pdr[size];
 	uint8_t *start = pdr;
@@ -642,11 +648,12 @@
 		node = node->next_sibling;
 	}
 
-	pldm_pdr_add(repo, pdr, size, 0, is_remote);
+	pldm_pdr_add(repo, pdr, size, 0, is_remote, terminus_handle);
 }
 
 static void entity_association_pdr_add_entry(pldm_entity_node *curr,
-					     pldm_pdr *repo, bool is_remote)
+					     pldm_pdr *repo, bool is_remote,
+					     uint16_t terminus_handle)
 {
 	uint8_t num_logical_children =
 	    pldm_entity_get_num_children(curr, PLDM_ENTITY_ASSOCIAION_LOGICAL);
@@ -660,7 +667,7 @@
 		    (num_logical_children * sizeof(pldm_entity));
 		_entity_association_pdr_add_entry(
 		    curr, repo, logical_pdr_size, num_logical_children,
-		    PLDM_ENTITY_ASSOCIAION_LOGICAL, is_remote);
+		    PLDM_ENTITY_ASSOCIAION_LOGICAL, is_remote, terminus_handle);
 	}
 
 	if (num_physical_children) {
@@ -670,7 +677,8 @@
 		    (num_physical_children * sizeof(pldm_entity));
 		_entity_association_pdr_add_entry(
 		    curr, repo, physical_pdr_size, num_physical_children,
-		    PLDM_ENTITY_ASSOCIAION_PHYSICAL, is_remote);
+		    PLDM_ENTITY_ASSOCIAION_PHYSICAL, is_remote,
+		    terminus_handle);
 	}
 }
 
@@ -691,7 +699,8 @@
 
 static void entity_association_pdr_add(pldm_entity_node *curr, pldm_pdr *repo,
 				       pldm_entity **entities,
-				       size_t num_entities, bool is_remote)
+				       size_t num_entities, bool is_remote,
+				       uint16_t terminus_handle)
 {
 	if (curr == NULL) {
 		return;
@@ -699,33 +708,34 @@
 	bool to_add = true;
 	to_add = is_present(curr->entity, entities, num_entities);
 	if (to_add) {
-		entity_association_pdr_add_entry(curr, repo, is_remote);
+		entity_association_pdr_add_entry(curr, repo, is_remote,
+						 terminus_handle);
 	}
 	entity_association_pdr_add(curr->next_sibling, repo, entities,
-				   num_entities, is_remote);
+				   num_entities, is_remote, terminus_handle);
 	entity_association_pdr_add(curr->first_child, repo, entities,
-				   num_entities, is_remote);
+				   num_entities, is_remote, terminus_handle);
 }
 
 void pldm_entity_association_pdr_add(pldm_entity_association_tree *tree,
-				     pldm_pdr *repo, bool is_remote)
+				     pldm_pdr *repo, bool is_remote,
+				     uint16_t terminus_handle)
 {
 	assert(tree != NULL);
 	assert(repo != NULL);
 
-	entity_association_pdr_add(tree->root, repo, NULL, 0, is_remote);
+	entity_association_pdr_add(tree->root, repo, NULL, 0, is_remote,
+				   terminus_handle);
 }
 
-void pldm_entity_association_pdr_add_from_node(pldm_entity_node *node,
-					       pldm_pdr *repo,
-					       pldm_entity **entities,
-					       size_t num_entities,
-					       bool is_remote)
+void pldm_entity_association_pdr_add_from_node(
+    pldm_entity_node *node, pldm_pdr *repo, pldm_entity **entities,
+    size_t num_entities, bool is_remote, uint16_t terminus_handle)
 {
 	assert(repo != NULL);
 
 	entity_association_pdr_add(node, repo, entities, num_entities,
-				   is_remote);
+				   is_remote, terminus_handle);
 }
 
 void find_entity_ref_in_tree(pldm_entity_node *tree_node, pldm_entity entity,
@@ -753,6 +763,53 @@
 	find_entity_ref_in_tree(tree->root, entity, node);
 }
 
+void pldm_pdr_remove_pdrs_by_terminus_handle(pldm_pdr *repo,
+					     uint16_t terminus_handle)
+{
+	assert(repo != NULL);
+	bool removed = false;
+
+	pldm_pdr_record *record = repo->first;
+	pldm_pdr_record *prev = NULL;
+	while (record != NULL) {
+		pldm_pdr_record *next = record->next;
+		if (record->terminus_handle == terminus_handle) {
+			if (repo->first == record) {
+				repo->first = next;
+			} else {
+				prev->next = next;
+			}
+			if (repo->last == record) {
+				repo->last = prev;
+			}
+			if (record->data) {
+				free(record->data);
+			}
+			--repo->record_count;
+			repo->size -= record->size;
+			free(record);
+			removed = true;
+		} else {
+			prev = record;
+		}
+		record = next;
+	}
+
+	if (removed == true) {
+		record = repo->first;
+		uint32_t record_handle = 0;
+		while (record != NULL) {
+			record->record_handle = ++record_handle;
+			if (record->data != NULL) {
+				struct pldm_pdr_hdr *hdr =
+				    (struct pldm_pdr_hdr *)(record->data);
+				hdr->record_handle =
+				    htole32(record->record_handle);
+			}
+			record = record->next;
+		}
+	}
+}
 void pldm_pdr_remove_remote_pdrs(pldm_pdr *repo)
 {
 	assert(repo != NULL);
diff --git a/libpldm/pdr.h b/libpldm/pdr.h
index 9e39da3..671b726 100644
--- a/libpldm/pdr.h
+++ b/libpldm/pdr.h
@@ -65,11 +65,13 @@
  *  @param[in] record_handle - record handle of input PDR record; if this is set
  *  to 0, then a record handle is computed and assigned to this PDR record
  *  @param[in] is_remote - if true, then the PDR is not from this terminus
+ *  @param[in] terminus_handle - terminus handle of the input PDR record
  *
  *  @return uint32_t - record handle assigned to PDR record
  */
 uint32_t pldm_pdr_add(pldm_pdr *repo, const uint8_t *data, uint32_t size,
-		      uint32_t record_handle, bool is_remote);
+		      uint32_t record_handle, bool is_remote,
+		      uint16_t terminus_handle);
 
 /** @brief Get record handle of a PDR record
  *
@@ -144,6 +146,14 @@
  */
 void pldm_pdr_remove_remote_pdrs(pldm_pdr *repo);
 
+/** @brief Remove all remote PDR's that beling to a specific terminus
+ *         handle
+ *  @param[in] repo - opaque pointer acting as a PDR repo handle
+ *  @param[in] terminus_handle - Terminus Handle of the remove PLDM terminus
+ */
+void pldm_pdr_remove_pdrs_by_terminus_handle(pldm_pdr *repo,
+					     uint16_t terminus_handle);
+
 /** @brief Update the validity of TL PDR - the validity is decided based on
  * whether the valid bit is set or not as per the spec DSP0248
  *
@@ -304,20 +314,21 @@
  *  @param[in] tree - opaque pointer to entity association tree
  *  @param[in] repo - PDR repo where entity association records should be added
  *  @param[in] is_remote - if true, then the PDR is not from this terminus
+ *  @param[in] terminus_handle - terminus handle of the terminus
  */
 void pldm_entity_association_pdr_add(pldm_entity_association_tree *tree,
-				     pldm_pdr *repo, bool is_remote);
+				     pldm_pdr *repo, bool is_remote,
+				     uint16_t terminus_handle);
 /** @brief Add entity association pdr from node
  *
  *  @param[in] node - opaque pointer acting as a handle to an entity node
  *  @param[in] repo - PDR repo where entity association records should be added
  *  @param[in] is_remote  - if true, then the PDR is not from this terminus
+ *  @param[in] terminus_handle - terminus handle of the terminus
  */
-void pldm_entity_association_pdr_add_from_node(pldm_entity_node *node,
-					       pldm_pdr *repo,
-					       pldm_entity **entities,
-					       size_t num_entities,
-					       bool is_remote);
+void pldm_entity_association_pdr_add_from_node(
+    pldm_entity_node *node, pldm_pdr *repo, pldm_entity **entities,
+    size_t num_entities, bool is_remote, uint16_t terminus_handle);
 
 /** @brief Find entity reference in tree
  *
diff --git a/libpldm/tests/libpldm_pdr_test.cpp b/libpldm/tests/libpldm_pdr_test.cpp
index d908345..666145a 100644
--- a/libpldm/tests/libpldm_pdr_test.cpp
+++ b/libpldm/tests/libpldm_pdr_test.cpp
@@ -18,17 +18,17 @@
     auto repo = pldm_pdr_init();
 
     std::array<uint8_t, 10> data{};
-    auto handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    auto handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     EXPECT_EQ(handle, 1u);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size());
 
-    handle = pldm_pdr_add(repo, data.data(), data.size(), 0u, false);
+    handle = pldm_pdr_add(repo, data.data(), data.size(), 0u, false, 1);
     EXPECT_EQ(handle, 2u);
-    handle = pldm_pdr_add(repo, data.data(), data.size(), 0u, false);
+    handle = pldm_pdr_add(repo, data.data(), data.size(), 0u, false, 1);
     EXPECT_EQ(handle, 3u);
     handle = pldm_pdr_add(repo, data.data(), data.size(), htole32(0xdeeddeedu),
-                          false);
+                          false, 1);
     EXPECT_EQ(handle, htole32(0xdeeddeed));
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), data.size() * 4u);
@@ -36,6 +36,47 @@
     pldm_pdr_destroy(repo);
 }
 
+TEST(PDRRemoveByTerminus, testRemoveByTerminus)
+{
+    std::array<uint8_t, 10> data{};
+
+    auto repo = pldm_pdr_init();
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_remove_pdrs_by_terminus_handle(repo, 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
+    pldm_pdr_destroy(repo);
+
+    repo = pldm_pdr_init();
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 2);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
+    pldm_pdr_remove_pdrs_by_terminus_handle(repo, 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
+    pldm_pdr_destroy(repo);
+
+    repo = pldm_pdr_init();
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 2);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
+    pldm_pdr_remove_pdrs_by_terminus_handle(repo, 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
+    pldm_pdr_destroy(repo);
+
+    repo = pldm_pdr_init();
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 2);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
+    pldm_pdr_remove_remote_pdrs(repo);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
+    pldm_pdr_remove_pdrs_by_terminus_handle(repo, 1);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
+    pldm_pdr_remove_pdrs_by_terminus_handle(repo, 2);
+    EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
+    pldm_pdr_destroy(repo);
+}
+
 TEST(PDRUpdate, testRemove)
 {
     std::array<uint8_t, 10> data{};
@@ -46,161 +87,161 @@
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 0u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 6u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 5u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 3u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
 
     repo = pldm_pdr_init();
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, false);
-    pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
+    pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     pldm_pdr_remove_remote_pdrs(repo);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 2u);
-    auto handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    auto handle = pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     EXPECT_EQ(handle, 3u);
-    handle = pldm_pdr_add(repo, data.data(), data.size(), 0, true);
+    handle = pldm_pdr_add(repo, data.data(), data.size(), 0, true, 1);
     EXPECT_EQ(handle, 4u);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     pldm_pdr_destroy(repo);
@@ -212,7 +253,7 @@
 
     std::array<uint32_t, 10> in{100, 345, 3, 6, 89, 0, 11, 45, 23434, 123123};
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in.data()), sizeof(in), 1,
-                 false);
+                 false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in));
     uint32_t size{};
@@ -244,11 +285,11 @@
     std::array<uint32_t, 10> in2{1000, 3450, 30,  60,     890,
                                  0,    110,  450, 234034, 123123};
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 2,
-                 false);
+                 false, 1);
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 3,
-                 false);
+                 false, 1);
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 4,
-                 true);
+                 true, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in2) * 4);
     hdl = pldm_pdr_find_record(repo, 0, &outData, &size, &nextRecHdl);
@@ -294,7 +335,7 @@
 
     std::array<uint32_t, 10> in{100, 345, 3, 6, 89, 0, 11, 45, 23434, 123123};
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in.data()), sizeof(in), 1,
-                 false);
+                 false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 1u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in));
     uint32_t size{};
@@ -310,11 +351,11 @@
     std::array<uint32_t, 10> in2{1000, 3450, 30,  60,     890,
                                  0,    110,  450, 234034, 123123};
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 2,
-                 false);
+                 false, 1);
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 3,
-                 false);
+                 false, 1);
     pldm_pdr_add(repo, reinterpret_cast<uint8_t*>(in2.data()), sizeof(in2), 4,
-                 false);
+                 false, 1);
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 4u);
     EXPECT_EQ(pldm_pdr_get_repo_size(repo), sizeof(in2) * 4);
     hdl = pldm_pdr_get_next_record(repo, hdl, &outData, &size, &nextRecHdl);
@@ -346,13 +387,13 @@
     std::array<uint8_t, sizeof(pldm_pdr_hdr)> data{};
     pldm_pdr_hdr* hdr = reinterpret_cast<pldm_pdr_hdr*>(data.data());
     hdr->type = 1;
-    auto first = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    auto first = pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     hdr->type = 2;
-    auto second = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    auto second = pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     hdr->type = 3;
-    auto third = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    auto third = pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
     hdr->type = 4;
-    auto fourth = pldm_pdr_add(repo, data.data(), data.size(), 0, false);
+    auto fourth = pldm_pdr_add(repo, data.data(), data.size(), 0, false, 1);
 
     uint8_t* outData = nullptr;
     uint32_t size{};
@@ -901,7 +942,7 @@
               1);
 
     auto repo = pldm_pdr_init();
-    pldm_entity_association_pdr_add(tree, repo, false);
+    pldm_entity_association_pdr_add(tree, repo, false, 1);
 
     EXPECT_EQ(pldm_pdr_get_record_count(repo), 6u);
 
diff --git a/libpldmresponder/fru.cpp b/libpldmresponder/fru.cpp
index 418c831..afb5637 100644
--- a/libpldmresponder/fru.cpp
+++ b/libpldmresponder/fru.cpp
@@ -109,7 +109,8 @@
         }
     }
 
-    pldm_entity_association_pdr_add(entityTree, pdrRepo, false);
+    pldm_entity_association_pdr_add(entityTree, pdrRepo, false,
+                                    TERMINUS_HANDLE);
     // save a copy of bmc's entity association tree
     pldm_entity_association_tree_copy_root(entityTree, bmcEntityTree);
 
diff --git a/libpldmresponder/pdr_utils.cpp b/libpldmresponder/pdr_utils.cpp
index d097b26..cc999a8 100644
--- a/libpldmresponder/pdr_utils.cpp
+++ b/libpldmresponder/pdr_utils.cpp
@@ -2,6 +2,8 @@
 
 #include "pdr.hpp"
 
+#include <config.h>
+
 #include <climits>
 
 using namespace pldm::pdr;
@@ -23,7 +25,7 @@
 RecordHandle Repo::addRecord(const PdrEntry& pdrEntry)
 {
     return pldm_pdr_add(repo, pdrEntry.data, pdrEntry.size,
-                        pdrEntry.handle.recordHandle, false);
+                        pdrEntry.handle.recordHandle, false, TERMINUS_HANDLE);
 }
 
 const pldm_pdr_record* Repo::getFirstRecord(PdrEntry& pdrEntry)
diff --git a/libpldmresponder/platform.cpp b/libpldmresponder/platform.cpp
index 707c9ff..fe825d7 100644
--- a/libpldmresponder/platform.cpp
+++ b/libpldmresponder/platform.cpp
@@ -471,8 +471,8 @@
 
 int Handler::pldmPDRRepositoryChgEvent(const pldm_msg* request,
                                        size_t payloadLength,
-                                       uint8_t /*formatVersion*/,
-                                       uint8_t /*tid*/, size_t eventDataOffset)
+                                       uint8_t /*formatVersion*/, uint8_t tid,
+                                       size_t eventDataOffset)
 {
     uint8_t eventDataFormat{};
     uint8_t numberOfChangeRecords{};
@@ -544,6 +544,24 @@
     }
     if (hostPDRHandler)
     {
+        // if we get a Repository change event with the eventDataFormat
+        // as REFRESH_ENTIRE_REPOSITORY, then delete all the PDR's that
+        // have the matched Terminus handle
+        if (eventDataFormat == REFRESH_ENTIRE_REPOSITORY)
+        {
+            // We cannot get the Repo change event from the Terminus
+            // that is not already added to the BMC repository
+
+            for (const auto& [terminusHandle, terminusInfo] :
+                 hostPDRHandler->tlPDRInfo)
+            {
+                if (std::get<0>(terminusInfo) == tid)
+                {
+                    pldm_pdr_remove_pdrs_by_terminus_handle(pdrRepo.getPdr(),
+                                                            terminusHandle);
+                }
+            }
+        }
         hostPDRHandler->fetchPDR(std::move(pdrRecordHandles));
     }