agent-messenger 2.23.2 → 2.23.3

package/src/platforms/webex/id-normalizer.test.ts

@@ -16,9 +16,13 @@ import {
   normalizeMembership,
   normalizeMessage,
   normalizeRoomActivity,
+  normalizeSdkMembership,
+  normalizeSdkMessage,
+  normalizeSdkPerson,
   toRestId,
   toRef,
 } from './id-normalizer'
+import type { WebexMembership, WebexMessage, WebexPerson } from './types'
 
 const RAW: MercuryActivity = {
   id: 'activity-uuid',
@@ -122,6 +126,23 @@ describe('normalizeMessage', () => {
     expect(result.mentionedPeople).toEqual([toRestId('mention-uuid-1', 'PEOPLE'), toRestId('mention-uuid-2', 'PEOPLE')])
   })
 
+  it('adds a raw uuid ref alongside every id', () => {
+    const result = normalizeMessage(message)
+
+    expect(result.ref).toBe('msg-uuid')
+    expect(result.parentRef).toBe('parent-uuid')
+    expect(result.roomRef).toBe('room-uuid')
+    expect(result.personRef).toBe('person-uuid')
+    expect(result.mentionedPeopleRefs).toEqual(['mention-uuid-1', 'mention-uuid-2'])
+  })
+
+  it('omits parentRef when parentId is absent', () => {
+    const { parentId: _omit, ...withoutParent } = message
+    const result = normalizeMessage(withoutParent)
+
+    expect(result.parentRef).toBeUndefined()
+  })
+
   it('leaves non-id fields and raw untouched', () => {
     const result = normalizeMessage(message)
 
@@ -157,8 +178,11 @@ describe('normalizeDeletedMessage', () => {
 
     expect(normalizeDeletedMessage(deleted)).toEqual({
       messageId: toRestId('msg-uuid', 'MESSAGE'),
+      messageRef: 'msg-uuid',
       roomId: toRestId('room-uuid', 'ROOM'),
+      roomRef: 'room-uuid',
       personId: toRestId('person-uuid', 'PEOPLE'),
+      personRef: 'person-uuid',
     })
   })
 })
@@ -183,6 +207,25 @@ describe('normalizeMembership', () => {
     expect(result.roomId).toBe(toRestId('room-uuid', 'ROOM'))
     expect(result.raw).toBe(RAW)
   })
+
+  it('sets ref to the raw activity id and adds refs for the rest', () => {
+    const membership: MembershipActivity = {
+      id: 'activity-uuid',
+      actorId: 'actor-uuid',
+      personId: 'member-uuid',
+      roomId: 'room-uuid',
+      action: 'add',
+      created: '2024-01-01T00:00:00Z',
+      raw: RAW,
+    }
+
+    const result = normalizeMembership(membership)
+
+    expect(result.ref).toBe('activity-uuid')
+    expect(result.actorRef).toBe('actor-uuid')
+    expect(result.personRef).toBe('member-uuid')
+    expect(result.roomRef).toBe('room-uuid')
+  })
 })
 
 describe('normalizeAttachmentAction', () => {
@@ -207,7 +250,27 @@ describe('normalizeAttachmentAction', () => {
     expect(result.inputs).toEqual({ choice: 'yes' })
   })
 
-  it('preserves an empty messageId', () => {
+  it('adds a raw uuid ref alongside every id', () => {
+    const action: AttachmentAction = {
+      id: 'action-uuid',
+      messageId: 'msg-uuid',
+      personId: 'person-uuid',
+      personEmail: 'user@example.com',
+      roomId: 'room-uuid',
+      inputs: { choice: 'yes' },
+      created: '2024-01-01T00:00:00Z',
+      raw: RAW,
+    }
+
+    const result = normalizeAttachmentAction(action)
+
+    expect(result.ref).toBe('action-uuid')
+    expect(result.messageRef).toBe('msg-uuid')
+    expect(result.personRef).toBe('person-uuid')
+    expect(result.roomRef).toBe('room-uuid')
+  })
+
+  it('preserves an empty messageId and its ref', () => {
     const action: AttachmentAction = {
       id: 'action-uuid',
       messageId: '',
@@ -219,7 +282,9 @@ describe('normalizeAttachmentAction', () => {
       raw: RAW,
     }
 
-    expect(normalizeAttachmentAction(action).messageId).toBe('')
+    const result = normalizeAttachmentAction(action)
+    expect(result.messageId).toBe('')
+    expect(result.messageRef).toBe('')
   })
 })
 
@@ -241,4 +306,182 @@ describe('normalizeRoomActivity', () => {
     expect(result.actorId).toBe(toRestId('actor-uuid', 'PEOPLE'))
     expect(result.raw).toBe(RAW)
   })
+
+  it('sets ref to the raw activity id and adds refs for the rest', () => {
+    const room: RoomActivity = {
+      id: 'activity-uuid',
+      roomId: 'room-uuid',
+      actorId: 'actor-uuid',
+      action: 'created',
+      created: '2024-01-01T00:00:00Z',
+      raw: RAW,
+    }
+
+    const result = normalizeRoomActivity(room)
+
+    expect(result.ref).toBe('activity-uuid')
+    expect(result.roomRef).toBe('room-uuid')
+    expect(result.actorRef).toBe('actor-uuid')
+  })
+})
+
+describe('normalizeSdkPerson', () => {
+  const person: WebexPerson = {
+    id: restId('PEOPLE', 'person-uuid'),
+    ref: '',
+    emails: ['user@example.com'],
+    displayName: 'User',
+    orgId: restId('ORGANIZATION', 'org-uuid'),
+    orgRef: '',
+    type: 'person',
+    created: '2024-01-01T00:00:00Z',
+  }
+
+  it('decodes the bot identity id and orgId into raw uuid refs', () => {
+    const result = normalizeSdkPerson(person)
+
+    expect(result.ref).toBe('person-uuid')
+    expect(result.orgRef).toBe('org-uuid')
+  })
+
+  it('does not re-encode the already-REST ids', () => {
+    const result = normalizeSdkPerson(person)
+
+    expect(result.id).toBe(restId('PEOPLE', 'person-uuid'))
+    expect(result.orgId).toBe(restId('ORGANIZATION', 'org-uuid'))
+  })
+
+  it('leaves empty ids and refs empty', () => {
+    const result = normalizeSdkPerson({ ...person, id: '', orgId: '' })
+
+    expect(result.ref).toBe('')
+    expect(result.orgRef).toBe('')
+  })
+
+  it('returns a new object without mutating the input', () => {
+    const result = normalizeSdkPerson(person)
+
+    expect(result).not.toBe(person)
+    expect(person.ref).toBe('')
+  })
+})
+
+describe('normalizeSdkMessage', () => {
+  const message: WebexMessage = {
+    id: restId('MESSAGE', 'msg-uuid'),
+    ref: '',
+    roomId: restId('ROOM', 'room-uuid'),
+    roomRef: '',
+    roomType: 'group',
+    text: 'hello',
+    personId: restId('PEOPLE', 'person-uuid'),
+    personRef: '',
+    personEmail: 'user@example.com',
+    created: '2024-01-01T00:00:00Z',
+    parentId: restId('MESSAGE', 'parent-uuid'),
+    mentionedPeople: [restId('PEOPLE', 'mention-1'), restId('PEOPLE', 'mention-2')],
+  }
+
+  it('decodes id, roomId, personId and parentId into raw uuid refs', () => {
+    const result = normalizeSdkMessage(message)
+
+    expect(result.ref).toBe('msg-uuid')
+    expect(result.roomRef).toBe('room-uuid')
+    expect(result.personRef).toBe('person-uuid')
+    expect(result.parentRef).toBe('parent-uuid')
+  })
+
+  it('adds a mentionedPeopleRefs array of raw uuids', () => {
+    const result = normalizeSdkMessage(message)
+
+    expect(result.mentionedPeopleRefs).toEqual(['mention-1', 'mention-2'])
+  })
+
+  it('omits parentRef when parentId is absent', () => {
+    const { parentId: _omit, ...withoutParent } = message
+    const result = normalizeSdkMessage(withoutParent)
+
+    expect(result.parentRef).toBeUndefined()
+  })
+
+  it('omits mentionedPeopleRefs when mentionedPeople is absent', () => {
+    const { mentionedPeople: _omit, ...withoutMentions } = message
+    const result = normalizeSdkMessage(withoutMentions)
+
+    expect(result.mentionedPeopleRefs).toBeUndefined()
+  })
+
+  it('does not re-encode the already-REST ids', () => {
+    const result = normalizeSdkMessage(message)
+
+    expect(result.id).toBe(restId('MESSAGE', 'msg-uuid'))
+    expect(result.roomId).toBe(restId('ROOM', 'room-uuid'))
+  })
+})
+
+describe('normalizeSdkMembership', () => {
+  const membership: WebexMembership = {
+    id: restId('MEMBERSHIP', 'membership-uuid'),
+    ref: '',
+    roomId: restId('ROOM', 'room-uuid'),
+    roomRef: '',
+    personId: restId('PEOPLE', 'person-uuid'),
+    personRef: '',
+    personEmail: 'user@example.com',
+    personDisplayName: 'User',
+    isModerator: false,
+    created: '2024-01-01T00:00:00Z',
+  }
+
+  it('decodes id, roomId and personId into raw uuid refs', () => {
+    const result = normalizeSdkMembership(membership)
+
+    expect(result.ref).toBe('membership-uuid')
+    expect(result.roomRef).toBe('room-uuid')
+    expect(result.personRef).toBe('person-uuid')
+  })
+
+  it('does not re-encode the already-REST ids', () => {
+    const result = normalizeSdkMembership(membership)
+
+    expect(result.id).toBe(restId('MEMBERSHIP', 'membership-uuid'))
+    expect(result.personId).toBe(restId('PEOPLE', 'person-uuid'))
+  })
+})
+
+describe('SDK and event refs agree for the same person', () => {
+  it('matches the bot identity ref against an event mention ref so self/mention detection holds', () => {
+    const personUuid = 'bot-person-uuid'
+
+    // given: the bot identity from a REST response (testAuth path)
+    const bot = normalizeSdkPerson({
+      id: restId('PEOPLE', personUuid),
+      ref: '',
+      emails: ['bot@webex.bot'],
+      displayName: 'Bot',
+      orgId: restId('ORGANIZATION', 'org-uuid'),
+      orgRef: '',
+      type: 'bot',
+      created: '2024-01-01T00:00:00Z',
+    })
+
+    // when: an event carries the same person as a raw Mercury uuid
+    const event = normalizeMessage({
+      id: 'msg-uuid',
+      roomId: 'room-uuid',
+      personId: personUuid,
+      personEmail: 'bot@webex.bot',
+      text: 'hi',
+      created: '2024-01-01T00:00:00Z',
+      mentionedPeople: [personUuid],
+      mentionedGroups: [],
+      files: [],
+      raw: RAW,
+    })
+
+    // then: both paths decode to the same raw uuid ref
+    expect(bot.ref).toBe(personUuid)
+    expect(event.personRef).toBe(personUuid)
+    expect(event.mentionedPeopleRefs.includes(bot.ref)).toBe(true)
+  })
 })

package/src/platforms/webex/id-normalizer.ts

@@ -7,6 +7,8 @@ import type {
   RoomActivity,
 } from 'webex-message-handler'
 
+import type { WebexMembership, WebexMessage, WebexPerson } from './types'
+
 export { fromRestId }
 
 // Superset of webex-message-handler's toRestId union, which omits ATTACHMENT_ACTION
@@ -20,7 +22,9 @@ export interface DecodedWebexId {
 }
 
 export function toRef(id: string): string {
-  if (!id) return id
+  // fromRestId throws on values that are not base64-encoded ciscospark ids; fail
+  // open so a non-REST id (legacy/sentinel) yields the id itself instead of crashing.
+  if (!id || !decodeWebexId(id)) return id
   return fromRestId(id)
 }
 
@@ -48,50 +52,117 @@ export function toRestId(uuid: string, type: WebexRestIdType): string {
 }
 
 export function normalizeMessage(message: DecryptedMessage): DecryptedMessage {
+  const id = toRestId(message.id, 'MESSAGE')
+  const parentId = message.parentId ? toRestId(message.parentId, 'MESSAGE') : message.parentId
+  const roomId = toRestId(message.roomId, 'ROOM')
+  const personId = toRestId(message.personId, 'PEOPLE')
+  const mentionedPeople = message.mentionedPeople.map((person) => toRestId(person, 'PEOPLE'))
   return {
     ...message,
-    id: toRestId(message.id, 'MESSAGE'),
-    parentId: message.parentId ? toRestId(message.parentId, 'MESSAGE') : message.parentId,
-    roomId: toRestId(message.roomId, 'ROOM'),
-    personId: toRestId(message.personId, 'PEOPLE'),
-    mentionedPeople: message.mentionedPeople.map((id) => toRestId(id, 'PEOPLE')),
+    id,
+    ref: toRef(id),
+    parentId,
+    parentRef: parentId ? toRef(parentId) : parentId,
+    roomId,
+    roomRef: toRef(roomId),
+    personId,
+    personRef: toRef(personId),
+    mentionedPeople,
+    mentionedPeopleRefs: mentionedPeople.map(toRef),
   }
 }
 
 export function normalizeDeletedMessage(message: DeletedMessage): DeletedMessage {
+  const messageId = toRestId(message.messageId, 'MESSAGE')
+  const roomId = toRestId(message.roomId, 'ROOM')
+  const personId = toRestId(message.personId, 'PEOPLE')
   return {
-    messageId: toRestId(message.messageId, 'MESSAGE'),
-    roomId: toRestId(message.roomId, 'ROOM'),
-    personId: toRestId(message.personId, 'PEOPLE'),
+    messageId,
+    messageRef: toRef(messageId),
+    roomId,
+    roomRef: toRef(roomId),
+    personId,
+    personRef: toRef(personId),
   }
 }
 
 export function normalizeMembership(activity: MembershipActivity): MembershipActivity {
-  // `id` stays raw: it is a Mercury activity UUID, not a REST membership ID.
+  // `id` stays raw: it is a Mercury activity UUID, not a REST membership ID, so
+  // its ref is the id itself rather than a decoded REST id.
+  const actorId = toRestId(activity.actorId, 'PEOPLE')
+  const personId = toRestId(activity.personId, 'PEOPLE')
+  const roomId = toRestId(activity.roomId, 'ROOM')
   return {
     ...activity,
-    actorId: toRestId(activity.actorId, 'PEOPLE'),
-    personId: toRestId(activity.personId, 'PEOPLE'),
-    roomId: toRestId(activity.roomId, 'ROOM'),
+    ref: activity.id,
+    actorId,
+    actorRef: toRef(actorId),
+    personId,
+    personRef: toRef(personId),
+    roomId,
+    roomRef: toRef(roomId),
   }
 }
 
 export function normalizeAttachmentAction(action: AttachmentAction): AttachmentAction {
+  const id = toRestId(action.id, 'ATTACHMENT_ACTION')
+  const messageId = action.messageId ? toRestId(action.messageId, 'MESSAGE') : action.messageId
+  const personId = toRestId(action.personId, 'PEOPLE')
+  const roomId = toRestId(action.roomId, 'ROOM')
   return {
     ...action,
-    id: toRestId(action.id, 'ATTACHMENT_ACTION'),
-    messageId: action.messageId ? toRestId(action.messageId, 'MESSAGE') : action.messageId,
-    personId: toRestId(action.personId, 'PEOPLE'),
-    roomId: toRestId(action.roomId, 'ROOM'),
+    id,
+    ref: toRef(id),
+    messageId,
+    messageRef: toRef(messageId),
+    personId,
+    personRef: toRef(personId),
+    roomId,
+    roomRef: toRef(roomId),
   }
 }
 
 export function normalizeRoomActivity(activity: RoomActivity): RoomActivity {
-  // `id` stays raw: the Mercury conversation activity UUID has no
-  // consumer-facing REST resource (the comparable REST ID is `roomId`).
+  // `id` stays raw: the Mercury conversation activity UUID has no consumer-facing
+  // REST resource, so its ref is the id itself (the comparable REST id is `roomId`).
+  const roomId = toRestId(activity.roomId, 'ROOM')
+  const actorId = toRestId(activity.actorId, 'PEOPLE')
   return {
     ...activity,
-    roomId: toRestId(activity.roomId, 'ROOM'),
-    actorId: toRestId(activity.actorId, 'PEOPLE'),
+    ref: activity.id,
+    roomId,
+    roomRef: toRef(roomId),
+    actorId,
+    actorRef: toRef(actorId),
+  }
+}
+
+// SDK REST responses (people/messages/memberships) already carry REST-encoded ids,
+// so unlike the event normalizers above we only attach raw uuid refs — no re-encoding.
+export function normalizeSdkPerson(person: WebexPerson): WebexPerson {
+  return {
+    ...person,
+    ref: toRef(person.id),
+    orgRef: toRef(person.orgId),
+  }
+}
+
+export function normalizeSdkMessage(message: WebexMessage): WebexMessage {
+  return {
+    ...message,
+    ref: toRef(message.id),
+    roomRef: toRef(message.roomId),
+    personRef: toRef(message.personId),
+    parentRef: message.parentId ? toRef(message.parentId) : message.parentId,
+    mentionedPeopleRefs: message.mentionedPeople?.map(toRef),
+  }
+}
+
+export function normalizeSdkMembership(membership: WebexMembership): WebexMembership {
+  return {
+    ...membership,
+    ref: toRef(membership.id),
+    roomRef: toRef(membership.roomId),
+    personRef: toRef(membership.personId),
   }
 }

package/src/platforms/webex/listener.test.ts

@@ -81,8 +81,11 @@ describe('WebexListener', () => {
 
     const expected = expect.objectContaining({
       id: toRestId('message-123', 'MESSAGE'),
+      ref: 'message-123',
       roomId: toRestId('room-123', 'ROOM'),
+      roomRef: 'room-123',
       personId: toRestId('person-123', 'PEOPLE'),
+      personRef: 'person-123',
       personEmail: 'user@example.com',
       text: 'hello',
       raw: RAW_ACTIVITY,

package/src/platforms/webex/types.test.ts

@@ -73,10 +73,13 @@ it('WebexSpaceSchema rejects invalid type', () => {
 it('WebexMessageSchema validates valid message', () => {
   const result = WebexMessageSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL01FU1NBR0UvbXNn',
+    ref: 'msg',
     roomId: 'Y2lzY29zcGFyazovL3VzL1JPT00vYWJj',
+    roomRef: 'abc',
     roomType: 'group',
     text: 'Hello world',
     personId: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9hYmM',
+    personRef: 'abc',
     personEmail: 'user@example.com',
     created: '2024-01-15T10:30:00.000Z',
   })
@@ -86,17 +89,22 @@ it('WebexMessageSchema validates valid message', () => {
 it('WebexMessageSchema validates message with optional fields', () => {
   const result = WebexMessageSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL01FU1NBR0UvbXNn',
+    ref: 'msg',
     roomId: 'Y2lzY29zcGFyazovL3VzL1JPT00vYWJj',
+    roomRef: 'abc',
     roomType: 'group',
     text: 'Hello world',
     markdown: '**Hello world**',
     html: '<strong>Hello world</strong>',
     files: ['https://webexapis.com/v1/contents/file1'],
     personId: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9hYmM',
+    personRef: 'abc',
     personEmail: 'user@example.com',
     created: '2024-01-15T10:30:00.000Z',
     parentId: 'Y2lzY29zcGFyazovL3VzL01FU1NBR0UvcGFyZW50',
+    parentRef: 'parent',
     mentionedPeople: ['Y2lzY29zcGFyazovL3VzL1BFT1BMRS9tZW50aW9u'],
+    mentionedPeopleRefs: ['mention'],
   })
   expect(result.success).toBe(true)
 })
@@ -125,9 +133,11 @@ it('WebexMessageSchema rejects invalid roomType', () => {
 it('WebexPersonSchema validates valid person', () => {
   const result = WebexPersonSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9hYmM',
+    ref: 'abc',
     emails: ['user@example.com'],
     displayName: 'Test User',
     orgId: 'Y2lzY29zcGFyazovL3VzL09SR0FOSVpBVElPTi9vcmc',
+    orgRef: 'org',
     type: 'person',
     created: '2024-01-01T00:00:00.000Z',
   })
@@ -137,6 +147,7 @@ it('WebexPersonSchema validates valid person', () => {
 it('WebexPersonSchema validates person with optional fields', () => {
   const result = WebexPersonSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9hYmM',
+    ref: 'abc',
     emails: ['user@example.com', 'user@work.com'],
     displayName: 'Test User',
     nickName: 'Tester',
@@ -144,6 +155,7 @@ it('WebexPersonSchema validates person with optional fields', () => {
     lastName: 'User',
     avatar: 'https://example.com/avatar.jpg',
     orgId: 'Y2lzY29zcGFyazovL3VzL09SR0FOSVpBVElPTi9vcmc',
+    orgRef: 'org',
     type: 'person',
     created: '2024-01-01T00:00:00.000Z',
   })
@@ -153,9 +165,11 @@ it('WebexPersonSchema validates person with optional fields', () => {
 it('WebexPersonSchema validates bot type', () => {
   const result = WebexPersonSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9ib3Q',
+    ref: 'bot',
     emails: ['bot@webex.bot'],
     displayName: 'My Bot',
     orgId: 'Y2lzY29zcGFyazovL3VzL09SR0FOSVpBVElPTi9vcmc',
+    orgRef: 'org',
     type: 'bot',
     created: '2024-01-01T00:00:00.000Z',
   })
@@ -185,8 +199,11 @@ it('WebexPersonSchema rejects invalid type', () => {
 it('WebexMembershipSchema validates valid membership', () => {
   const result = WebexMembershipSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL01FTUJFUlNISVAvbWVt',
+    ref: 'mem',
     roomId: 'Y2lzY29zcGFyazovL3VzL1JPT00vYWJj',
+    roomRef: 'abc',
     personId: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9hYmM',
+    personRef: 'abc',
     personEmail: 'user@example.com',
     personDisplayName: 'Test User',
     isModerator: false,
@@ -198,8 +215,11 @@ it('WebexMembershipSchema validates valid membership', () => {
 it('WebexMembershipSchema validates moderator membership', () => {
   const result = WebexMembershipSchema.safeParse({
     id: 'Y2lzY29zcGFyazovL3VzL01FTUJFUlNISVAvbWVt',
+    ref: 'mem',
     roomId: 'Y2lzY29zcGFyazovL3VzL1JPT00vYWJj',
+    roomRef: 'abc',
     personId: 'Y2lzY29zcGFyazovL3VzL1BFT1BMRS9hYmM',
+    personRef: 'abc',
     personEmail: 'moderator@example.com',
     personDisplayName: 'Moderator User',
     isModerator: true,

package/src/platforms/webex/types.ts

@@ -13,21 +13,27 @@ export interface WebexSpace {
 
 export interface WebexMessage {
   id: string
+  ref: string
   roomId: string
+  roomRef: string
   roomType: 'group' | 'direct'
   text?: string
   markdown?: string
   html?: string
   files?: string[]
   personId: string
+  personRef: string
   personEmail: string
   created: string
   parentId?: string
+  parentRef?: string
   mentionedPeople?: string[]
+  mentionedPeopleRefs?: string[]
 }
 
 export interface WebexPerson {
   id: string
+  ref: string
   emails: string[]
   displayName: string
   nickName?: string
@@ -35,14 +41,18 @@ export interface WebexPerson {
   lastName?: string
   avatar?: string
   orgId: string
+  orgRef: string
   type: 'person' | 'bot'
   created: string
 }
 
 export interface WebexMembership {
   id: string
+  ref: string
   roomId: string
+  roomRef: string
   personId: string
+  personRef: string
   personEmail: string
   personDisplayName: string
   isModerator: boolean
@@ -84,21 +94,27 @@ export const WebexSpaceSchema = z.object({
 
 export const WebexMessageSchema = z.object({
   id: z.string(),
+  ref: z.string(),
   roomId: z.string(),
+  roomRef: z.string(),
   roomType: z.enum(['group', 'direct']),
   text: z.string().optional(),
   markdown: z.string().optional(),
   html: z.string().optional(),
   files: z.array(z.string()).optional(),
   personId: z.string(),
+  personRef: z.string(),
   personEmail: z.string(),
   created: z.string(),
   parentId: z.string().optional(),
+  parentRef: z.string().optional(),
   mentionedPeople: z.array(z.string()).optional(),
+  mentionedPeopleRefs: z.array(z.string()).optional(),
 })
 
 export const WebexPersonSchema = z.object({
   id: z.string(),
+  ref: z.string(),
   emails: z.array(z.string()),
   displayName: z.string(),
   nickName: z.string().optional(),
@@ -106,14 +122,18 @@ export const WebexPersonSchema = z.object({
   lastName: z.string().optional(),
   avatar: z.string().optional(),
   orgId: z.string(),
+  orgRef: z.string(),
   type: z.enum(['person', 'bot']),
   created: z.string(),
 })
 
 export const WebexMembershipSchema = z.object({
   id: z.string(),
+  ref: z.string(),
   roomId: z.string(),
+  roomRef: z.string(),
   personId: z.string(),
+  personRef: z.string(),
   personEmail: z.string(),
   personDisplayName: z.string(),
   isModerator: z.boolean(),