diff --git a/demo/index.js b/demo/index.js
index c2dead9..9a39728 100644
--- a/demo/index.js
+++ b/demo/index.js
@@ -84,7 +84,7 @@ $(function() {
           refreshCallList();
         });
       });
-      $('.modal').modal('hide');
+      $loadingModal.modal('hide');
     }
     if (rcCallControl.ready) {
       onInitializedEvent();
diff --git a/demo/redirect.html b/demo/redirect.html
index 88bffa8..09dc626 100644
--- a/demo/redirect.html
+++ b/demo/redirect.html
@@ -13,7 +13,6 @@
 <body>
 <p>Loading</p>
 <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/es6-promise/3.2.2/es6-promise.js"></script>
-<script type="text/javascript" src="https://cdn.pubnub.com/sdk/javascript/pubnub.4.20.1.js"></script>
 <script type="text/javascript" src="https://cdnjs.cloudflare.com/ajax/libs/fetch/0.11.1/fetch.js"></script>
 <script type="text/javascript" src="https://unpkg.com/@ringcentral/sdk@latest/dist/ringcentral.js"></script>
 <script>
diff --git a/package.json b/package.json
index 5319f3d..f0b9cd0 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "ringcentral-call-control",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "main": "lib/index.js",
   "license": "MIT",
   "repository": {
diff --git a/src/Session.ts b/src/Session.ts
index 6338522..2c9443c 100644
--- a/src/Session.ts
+++ b/src/Session.ts
@@ -68,7 +68,6 @@ export interface SessionData {
   sessionId: string;
   creationTime: string;
   voiceCallToken?: string;
-  sequence?: number;
   origin: Origin;
 }
 
@@ -202,36 +201,16 @@ function diffParties(oldParties: Party[], updatedParties: Party[]) {
 
 export class Session extends EventEmitter {
   private _data: any;
-  private _eventPartySequences: any;
   private _sdk: RingCentralSDK;
   private _accountLevel: boolean;
   private _userAgent: string;
 
   constructor(rawData: SessionData, sdk: RingCentralSDK, accountLevel: boolean, userAgent?: string) {
     super();
-    const { sequence, ...data } = rawData;
-    this._data = data;
-    this._eventPartySequences = {};
+    this._data = { ...rawData };
     this._sdk = sdk;
     this._accountLevel = !!accountLevel;
     this._userAgent = userAgent;
-
-    this._updatePartiesSequence(this._data.parties, sequence);
-
-    this.on('status', ({ party }) => {
-      this._onPartyUpdated(party);
-    });
-  }
-
-  _updatePartiesSequence(parties: Party[] = [], sequence?: Number) {
-    if (!sequence) {
-      return;
-    }
-    parties.forEach((party) => {
-      if (!this._eventPartySequences[party.id] || this._eventPartySequences[party.id] < sequence) {
-        this._eventPartySequences[party.id] = sequence;
-      }
-    });
   }
 
   public onUpdated(data: SessionData) {
@@ -242,10 +221,6 @@ export class Session extends EventEmitter {
         this.emit('status', { party: diff.party });
         return;
       }
-      const lastSequence = this._eventPartySequences[diff.party.id]
-      if (lastSequence && data.sequence < lastSequence) {
-        return;
-      }
       if (diff.type === 'update') {
         const oldPartyIndex = this.parties.findIndex(p => p.id === diff.party.id);
         const parties = this.parties.slice(0);
@@ -260,16 +235,6 @@ export class Session extends EventEmitter {
         return;
       }
     });
-    this._updatePartiesSequence(data.parties, data.sequence);
-  }
-
-  _onPartyUpdated(party) {
-    if (
-      party.status.code === PartyStatusCode.disconnected &&
-      party.status.reason === 'Pickup'
-    ) {
-      this._data.parties = this.parties.filter(p => p.id !== party.id);
-    }
   }
 
   public restore(data: SessionData) {
@@ -369,11 +334,28 @@ export class Session extends EventEmitter {
   }
 
   async drop() {
-    await this._sdk.platform().delete(
-      `/restapi/v1.0/account/~/telephony/sessions/${this._data.id}`,
-      null,
-      this.requestOptions
-    );
+    try {
+      await this._sdk.platform().delete(
+        `/restapi/v1.0/account/~/telephony/sessions/${this._data.id}`,
+        null,
+        this.requestOptions
+      );
+    } catch (e) {
+      if (e && e.response && e.response.status === 404) {
+        // Force drop session at client side
+        const disconnectedParty = {
+          ...this.party,
+          status: {
+            ...this.party.status,
+            code: PartyStatusCode.disconnected,
+          },
+        };
+        this.saveNewPartyData(disconnectedParty);
+        this.emit('status', { party: this.party });
+        return;
+      }
+      throw e;
+    }
   }
 
   private saveNewPartyData(rawParty) {
diff --git a/src/index.ts b/src/index.ts
index 8b2c070..a6e47f7 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -35,6 +35,16 @@ export interface Device {
   lastLocationReportTime: string;
 }
 
+export interface EventSequenceData {
+  sequence: number;
+  updatedAt: number;
+  telephonySessionId: string;
+}
+
+export interface EventSequenceMap {
+  [key: string]: EventSequenceData;
+}
+
 export interface Account {
   id: string;
 }
@@ -78,6 +88,7 @@ export class RingCentralCallControl extends EventEmitter {
   private _preloadSessions: boolean;
   private _preloadDevices: boolean;
   private _userAgent: string;
+  private _eventSequenceMap: EventSequenceMap = {};
 
   constructor({
     sdk,
@@ -141,6 +152,10 @@ export class RingCentralCallControl extends EventEmitter {
     if (!telephonySessionId) {
       return;
     }
+    const validatedSequence = this.checkSequence(message.body);
+    if (!validatedSequence) {
+      return;
+    }
     const existedSession = this._sessionsMap.get(telephonySessionId);
     newData.id = telephonySessionId;
     newData.extensionId = this.extensionId;
@@ -179,6 +194,33 @@ export class RingCentralCallControl extends EventEmitter {
     }
   }
 
+  private checkSequence({ sequence, telephonySessionId, parties }) {
+    let result = true;
+    const partyId = parties[0] && parties[0].id;
+    const eventSequenceData = this._eventSequenceMap[partyId];
+    if (eventSequenceData && eventSequenceData.sequence > sequence) {
+      result = false;
+    } else {
+      this._eventSequenceMap[partyId] = {
+        sequence,
+        telephonySessionId,
+        updatedAt: Date.now(),
+      };
+    }
+    this.cleanExpiredSequenceData();
+    return result;
+  }
+
+  private cleanExpiredSequenceData() {
+    Object.keys(this._eventSequenceMap).forEach((partyId) => {
+      const eventSequenceData = this._eventSequenceMap[partyId];
+      const existedSession = this._sessionsMap.get(eventSequenceData.telephonySessionId);
+      if (!existedSession && eventSequenceData.updatedAt + 60000 < Date.now()) {
+        delete this._eventSequenceMap[partyId];
+      }
+    });
+  }
+
   get sessions(): Session[] {
     return Array.from(this._sessionsMap.values());
   }
@@ -193,7 +235,7 @@ export class RingCentralCallControl extends EventEmitter {
         await this._sdk.platform().get('/restapi/v1.0/account/~/extension/~', null, this.requestOptions);
       this._currentExtension = await response.json();
     } catch (e) {
-      console.error('Fetch presence error', e);
+      console.error('Fetch extension info error', e);
     }
   }
 
@@ -376,4 +418,8 @@ export class RingCentralCallControl extends EventEmitter {
       userAgent: this._userAgent ? `${this._userAgent} ${USER_AGENT}` : USER_AGENT,
     };
   }
+
+  get eventSequenceMap() {
+    return this._eventSequenceMap;
+  }
 }
diff --git a/test/index.test.ts b/test/index.test.ts
index b69062e..8802150 100644
--- a/test/index.test.ts
+++ b/test/index.test.ts
@@ -10,6 +10,43 @@ import * as telephonySessionOutboundData from './mock/data/telephonySessionOutbo
 let sdk;
 let rcCallControl;
 
+function getMockEventMessage({
+  template,
+  telephonySessionId,
+  sequence,
+  code,
+  reason,
+  party,
+  partyId,
+}: {
+  template: any;
+  telephonySessionId?: string;
+  sequence?: number;
+  code?: string;
+  reason?: string;
+  partyId?: string;
+  party?: any;
+}) {
+  let partyData = party || template.body.parties[0];
+  return {
+    ...template,
+    body: {
+      ...template.body,
+      telephonySessionId: telephonySessionId || template.body.telephonySessionId,
+      sequence: sequence || template.body.sequence,
+      parties: [{
+        ...partyData,
+        id: partyId || partyData.id,
+        status: {
+          ...partyData.status,
+          code: code || partyData.status.code,
+          reason: reason || partyData.status.reason,
+        },
+      }]
+    },
+  };
+}
+
 describe('RingCentral Call Control :: Index', () => {
   beforeAll(async () => {
     mock.mockAuthentication();
@@ -20,7 +57,7 @@ describe('RingCentral Call Control :: Index', () => {
   describe('Initialize', () => {
     beforeAll(async () => {
       mock.mockDevice();
-      mock.mockExtensionInfo()
+      mock.mockExtensionInfo();
       mock.mockPresence();
       mock.mockTelephoneSession();
       rcCallControl = new RingCentralCallControl({ sdk });
@@ -75,7 +112,7 @@ describe('RingCentral Call Control :: Index', () => {
         sdk,
         preloadDevices: false,
         preloadSessions: false,
-        extensionInfo,
+        extensionInfo: extensionInfo as any,
       });
       await rcCallControl.initialize();
     });
@@ -117,7 +154,7 @@ describe('RingCentral Call Control :: Index', () => {
         sdk,
         preloadDevices: false,
         preloadSessions: false,
-        extensionInfo,
+        extensionInfo: extensionInfo as any,
       });
       await callControl.initialize();
       expect(callControl.sessions.length).toEqual(0);
@@ -137,7 +174,7 @@ describe('RingCentral Call Control :: Index', () => {
       const callControl = new RingCentralCallControl({
         sdk,
         preloadDevices: false,
-        extensionInfo,
+        extensionInfo: extensionInfo as any,
       });
       await callControl.initialize();
       expect(callControl.sessions.length).toEqual(1);
@@ -186,77 +223,127 @@ describe('RingCentral Call Control :: Index', () => {
       rcCallControl.once('new', () => {
         newEventTriggered = true;
       });
-      rcCallControl.onNotificationEvent(telephonySessionOutboundDisconnectedMessage);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundDisconnectedMessage,
+        telephonySessionId: '12345',
+        partyId: '12345-1',
+      }));
       expect(rcCallControl.sessions.length).toEqual(0);
       expect(newEventTriggered).toEqual(false);
     });
 
-    it('should create new sessions and new event when get telephony session event', () => {
+    it('should create new session and new event when get telephony session event', () => {
       let newEventTriggered = false;
       rcCallControl.once('new', () => {
         newEventTriggered = true;
       });
-      rcCallControl.onNotificationEvent(telephonySessionOutboundSetupMessage);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundSetupMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-1',
+      }));
       expect(rcCallControl.sessions.length).toEqual(1);
       expect(rcCallControl.sessions[0].parties.length).toEqual(1);
       expect(newEventTriggered).toEqual(true);
     });
 
     it('should update session when get telephony session updated event', () => {
-      rcCallControl.onNotificationEvent(telephonySessionInboundProceedingMessage);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionInboundProceedingMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-2',
+      }));
       expect(rcCallControl.sessions.length).toEqual(1);
       expect(rcCallControl.sessions[0].parties.length).toEqual(2);
     });
 
+    it('should not update current party when get telephony session with outdated sequence', () => {
+      const oldStatus = rcCallControl.sessions[0].parties[0].status;
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundSetupMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-1',
+        sequence: telephonySessionOutboundSetupMessage.body.sequence - 1,
+        code: 'Disconnected',
+      }));
+      expect(rcCallControl.sessions.length).toEqual(1);
+      expect(rcCallControl.sessions[0].parties[0].status.code).toEqual(oldStatus.code);
+    });
+
     it('should not update session when get telephony session with outdated sequence', () => {
-      const oldStatus = rcCallControl.sessions[0].party.status;
-      rcCallControl.onNotificationEvent({
-        ...telephonySessionInboundProceedingMessage,
-        body: {
-          ...telephonySessionInboundProceedingMessage.body,
-          sequence: telephonySessionInboundProceedingMessage.body.sequence - 1,
-          parties: [{
-            ...telephonySessionInboundProceedingMessage.body.parties[0],
-            status: {
-              code: 'Disconnected',
-            }
-          }]
-        }
-      });
+      const oldStatus = rcCallControl.sessions[0].parties[1].status;
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionInboundProceedingMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-2',
+        sequence: telephonySessionInboundProceedingMessage.body.sequence - 1,
+        code: 'Disconnected',
+      }));
       expect(rcCallControl.sessions.length).toEqual(1);
-      expect(rcCallControl.sessions[0].party.status.code).toEqual(oldStatus.code);
+      expect(rcCallControl.sessions[0].parties[1].status.code).toEqual(oldStatus.code);
     });
 
     it('should not update session when get telephony session no updated event', () => {
       const oldStatus = rcCallControl.sessions[0].party.status;
-      rcCallControl.onNotificationEvent(telephonySessionInboundProceedingMessage);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionInboundProceedingMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-2',
+      }));
       expect(rcCallControl.sessions.length).toEqual(1);
       expect(rcCallControl.sessions[0].party.status.code).toEqual(oldStatus.code);
     });
 
-    it('should delete session when get telephony session disconnected event with pickup reason', () => {
-      rcCallControl.onNotificationEvent({
-        ...telephonySessionOutboundDisconnectedMessage,
-        body: {
-          ...telephonySessionOutboundDisconnectedMessage.body,
-          parties: [
-            {
-              ...telephonySessionOutboundDisconnectedMessage.body.parties[0],
-              status: {
-                ...telephonySessionOutboundDisconnectedMessage.body.parties[0].status,
-                reason: 'Pickup'
-              }
-            }
-          ]
-        }
-      });
+    it('should not delete session when get telephony session disconnected event with CallSwitch reason', () => {
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundDisconnectedMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-1',
+        reason: 'CallSwitch',
+      }));
       expect(rcCallControl.sessions.length).toEqual(1);
-      expect(rcCallControl.sessions[0].party).toEqual(undefined);
+      expect(rcCallControl.sessions[0].party.status.reason).toEqual('CallSwitch');
     });
 
     it('should delete session when get telephony session disconnected event', () => {
-      rcCallControl.onNotificationEvent(telephonySessionOutboundDisconnectedMessage);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundDisconnectedMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-1',
+      }));
+      expect(rcCallControl.sessions.length).toEqual(0);
+    });
+
+    it('should not add session after get telephony session Setup event with wrong sequence', () => {
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundDisconnectedMessage,
+        telephonySessionId: '1234567',
+        partyId: '1234567-1',
+        sequence: 3,
+      }));
       expect(rcCallControl.sessions.length).toEqual(0);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundSetupMessage,
+        telephonySessionId: '1234567',
+        partyId: '1234567-1',
+        sequence: 2,
+      }));
+      expect(rcCallControl.sessions.length).toEqual(0);
+    });
+
+    it('should clear expired sequence data when get a new telephony session event', () => {
+      const sequenceDataMap = rcCallControl.eventSequenceMap;
+      sequenceDataMap['old-telephone-session-id-1'] = {
+        sequence: 1,
+        telephoneSessionId: 'old-telephone-session-id',
+        updatedAt: Date.now() - 61000,
+      };
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundDisconnectedMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-1',
+      }));
+      expect(!!sequenceDataMap['old-telephone-session-id-1']).toEqual(false);
     });
 
     it('should emit new event when get telephony session first my party', () => {
@@ -264,24 +351,38 @@ describe('RingCentral Call Control :: Index', () => {
       rcCallControl.once('new', () => {
         newEventTriggered = true;
       });
-      const notPartiesMessage = {
-        ...telephonySessionOutboundSetupMessage,
-        body: {
-          ...telephonySessionOutboundSetupMessage.body,
-          parties: [{
-            ...telephonySessionInboundProceedingMessage.body.parties[0]
-          }],
+      const notPartiesMessage = getMockEventMessage({
+        template: telephonySessionOutboundSetupMessage,
+        telephonySessionId: '12345678',
+        partyId: '12345678-1',
+        party: {
+          ...telephonySessionInboundProceedingMessage.body.parties[0],
         }
-      }
+      });
       rcCallControl.onNotificationEvent(notPartiesMessage);
       expect(rcCallControl.sessions.length).toEqual(1);
       expect(!!rcCallControl.sessions[0].party).toEqual(false);
       expect(rcCallControl.sessions[0].otherParties.length).toEqual(1);
       expect(rcCallControl.sessions[0].parties.length).toEqual(1);
       expect(newEventTriggered).toEqual(false);
-      rcCallControl.onNotificationEvent(telephonySessionOutboundSetupMessage);
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundSetupMessage,
+        telephonySessionId: '12345678',
+        partyId: '12345678-2',
+      }));
       expect(newEventTriggered).toEqual(true);
     });
+
+    it('should not clear expired sequence data when telephony session is still existed', () => {
+      const sequenceDataMap = rcCallControl.eventSequenceMap;
+      sequenceDataMap['12345678-2'].updatedAt = Date.now() - 61000;
+      rcCallControl.onNotificationEvent(getMockEventMessage({
+        template: telephonySessionOutboundDisconnectedMessage,
+        telephonySessionId: '123456',
+        partyId: '123456-1',
+      }));
+      expect(!!sequenceDataMap['12345678-2']).toEqual(true);
+    });
   });
 
   describe('Create call', () => {
diff --git a/test/mock/sdk.ts b/test/mock/sdk.ts
index 0f6ec1b..0af03e8 100644
--- a/test/mock/sdk.ts
+++ b/test/mock/sdk.ts
@@ -270,12 +270,13 @@ export function mockTelephoneSessionUnholdParty(mockResponse = {}) {
   });
 }
 
-export function mockTelephoneSessionDrop(mockResponse = {}) {
+export function mockTelephoneSessionDrop({ status = 200 } = {}) {
   mockApi({
     url: 'express:/restapi/v1.0/account/~/telephony/sessions/:sessionId',
     method: 'DELETE',
     body: {},
     isOnce: true,
+    status,
   });
 }
 
diff --git a/test/session.test.ts b/test/session.test.ts
index 83beae9..528184c 100644
--- a/test/session.test.ts
+++ b/test/session.test.ts
@@ -112,6 +112,28 @@ describe('RingCentral Call Control :: Session', () => {
       expect(noException).toEqual(true);
     });
 
+    it('should set disconnected event when drop with 404', async () => {
+      mock.mockTelephoneSessionDrop({ status: 404});
+      let disconnectedEvent = false;
+      session.on('status', ({ party }) => {
+        disconnectedEvent = party.status.code == 'Disconnected';
+      })
+      await session.drop();
+      expect(disconnectedEvent).toEqual(true);
+      expect(session.party.status.code).toEqual('Disconnected');
+    });
+
+    it('should throw error when drop with 500', async () => {
+      mock.mockTelephoneSessionDrop({ status: 500});
+      let noException = true;
+      try {
+        await session.drop();
+      } catch (e) {
+        noException = false;
+      }
+      expect(noException).toEqual(false);
+    });
+
     it('should transfer successfully', async () => {
       mock.mockTelephoneSessionTransferParty();
       const party = await session.transfer({ phoneNumber: '+1234567890' });
