agent-messenger 2.23.1 → 2.23.3

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

@@ -16,8 +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',
@@ -28,6 +33,8 @@ const RAW: MercuryActivity = {
   published: '2024-01-01T00:00:00Z',
 }
 
+const restId = (type: string, ref: string) => Buffer.from(`ciscospark://us/${type}/${ref}`).toString('base64url')
+
 describe('toRestId / fromRestId', () => {
   it('encodes a uuid into a ciscospark REST id round-trippable to the uuid', () => {
     const restId = toRestId('abc-123', 'PEOPLE')
@@ -58,6 +65,40 @@ describe('toRestId / fromRestId', () => {
   })
 })
 
+describe('toRef', () => {
+  it('returns a room uuid ref', () => {
+    const uuid = '12345678-1234-1234-1234-1234567890ab'
+
+    expect(toRef(toRestId(uuid, 'ROOM'))).toBe(uuid)
+  })
+
+  it('returns a person uuid ref', () => {
+    const uuid = '22222222-2222-2222-2222-222222222222'
+
+    expect(toRef(toRestId(uuid, 'PEOPLE'))).toBe(uuid)
+  })
+
+  it('returns a legacy person email ref', () => {
+    expect(toRef(toRestId('legacy@example.com', 'PEOPLE'))).toBe('legacy@example.com')
+  })
+
+  it('returns an organization uuid ref', () => {
+    const uuid = '33333333-3333-3333-3333-333333333333'
+
+    expect(toRef(restId('ORGANIZATION', uuid))).toBe(uuid)
+  })
+
+  it('returns a membership person-room pair ref', () => {
+    const membershipRef = '44444444-4444-4444-4444-444444444444:55555555-5555-5555-5555-555555555555'
+
+    expect(toRef(restId('MEMBERSHIP', membershipRef))).toBe(membershipRef)
+  })
+
+  it('returns empty input unchanged', () => {
+    expect(toRef('')).toBe('')
+  })
+})
+
 describe('normalizeMessage', () => {
   const message: DecryptedMessage = {
     id: 'msg-uuid',
@@ -85,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)
 
@@ -120,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',
     })
   })
 })
@@ -146,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', () => {
@@ -170,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: '',
@@ -182,7 +282,9 @@ describe('normalizeAttachmentAction', () => {
       raw: RAW,
     }
 
-    expect(normalizeAttachmentAction(action).messageId).toBe('')
+    const result = normalizeAttachmentAction(action)
+    expect(result.messageId).toBe('')
+    expect(result.messageRef).toBe('')
   })
 })
 
@@ -204,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,12 +7,37 @@ 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
 // (the resource type behind GET /v1/attachment/actions).
 export type WebexRestIdType = 'MESSAGE' | 'PEOPLE' | 'ROOM' | 'ATTACHMENT_ACTION'
 
+export interface DecodedWebexId {
+  cluster: string
+  type: string
+  uuid: string
+}
+
+export function toRef(id: string): string {
+  // 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)
+}
+
+// Webex REST ids are base64(url) of `ciscospark://<cluster>/<TYPE>/<uuid>`; room
+// cluster correction needs all three parts, not just the trailing ref value.
+export function decodeWebexId(restId: string): DecodedWebexId | null {
+  if (!restId) return null
+  const decoded = Buffer.from(restId, 'base64').toString('utf-8')
+  const match = decoded.match(/^ciscospark:\/\/([^/]+)\/([^/]+)\/(.+)$/)
+  if (!match) return null
+  return { cluster: match[1], type: match[2], uuid: match[3] }
+}
+
 /**
  * Encode a raw Mercury UUID as a Webex REST ID. Empty input is returned unchanged
  * so an absent ID never becomes a bogus `ciscospark://us/{TYPE}/` value.
@@ -27,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/index.ts

@@ -1,7 +1,7 @@
 export { WebexClient } from './client'
 export { WebexCredentialManager } from './credential-manager'
-export { fromRestId, toRestId } from './id-normalizer'
-export type { WebexRestIdType } from './id-normalizer'
+export { decodeWebexId, fromRestId, toRef, toRestId } from './id-normalizer'
+export type { DecodedWebexId, WebexRestIdType } from './id-normalizer'
 export { WebexListener } from './listener'
 export type { WebexListenerClient, WebexListenerEventMap, WebexListenerOptions } from './listener'
 export { loginWithPassword } from './password-login'

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,