@juzi/wechaty-puppet-service 1.0.114 → 1.0.115

package/src/client/call-raw-payload-parser.spec.ts

@@ -0,0 +1,131 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test }            from 'tstest'
+import * as PUPPET         from '@juzi/wechaty-puppet'
+import { puppet as grpcPuppet } from '@juzi/wechaty-grpc'
+
+import { PuppetService }   from './puppet-service.js'
+import { timestampFromMilliseconds } from '../pure-functions/timestamp.js'
+
+/**
+ * The parser only reads `rawPayload.*` and a module-level `log` — it never
+ * touches `this`. Invoke it via `prototype.call({}, raw)` to avoid building a
+ * full PuppetService instance for unit-level tests.
+ */
+const callParser = async (raw: grpcPuppet.CallPayloadResponse.AsObject) =>
+  PuppetService.prototype.callRawPayloadParser.call({} as PuppetService, raw)
+
+/**
+ * 1. Full payload with starter, participants, media=VOICE, startTime, endTime
+ *    parses every field, mapping VOICE -> CallMediaType.Audio.
+ */
+test('callRawPayloadParser parses a complete payload', async t => {
+  const startMs = 1_700_000_000_000
+  const endMs   = 1_700_000_030_000
+
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-1')
+  pb.setStarter('alice')
+  pb.setParticipantsList([ 'alice', 'bob' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  pb.setStartTime(timestampFromMilliseconds(startMs))
+  pb.setEndTime(timestampFromMilliseconds(endMs))
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.id, 'call-1', 'id propagated')
+  t.equal(payload.starter, 'alice', 'starter propagated')
+  t.same(payload.participants, [ 'alice', 'bob' ], 'participants propagated')
+  t.equal(payload.media, PUPPET.types.CallMediaType.Audio, 'VOICE maps to Audio')
+  t.equal(payload.startTime, startMs, 'startTime parsed')
+  t.equal(payload.endTime, endMs, 'endTime parsed')
+})
+
+/**
+ * 2. Empty starter string -> parser omits `starter` from the resulting payload.
+ *    (Mirrors the server, which only `setStarter` when the value is truthy.)
+ */
+test('callRawPayloadParser omits starter when starter is an empty string', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-2')
+  pb.setParticipantsList([ 'alice' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VIDEO)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+  // no setStarter -> default proto3 string '' on the wire
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.starter, undefined, 'starter is undefined when empty on the wire')
+  t.equal(payload.media, PUPPET.types.CallMediaType.Video, 'VIDEO maps to Video')
+})
+
+/**
+ * 3. endTime not set (no setEndTime) -> payload.endTime === undefined.
+ */
+test('callRawPayloadParser leaves endTime undefined when endTime is not set', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-3')
+  pb.setStarter('alice')
+  pb.setParticipantsList([ 'alice', 'bob' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+  // no setEndTime
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.endTime, undefined, 'endTime is undefined when not set on the wire')
+})
+
+/**
+ * 4. media = CALL_TYPE_UNKNOWN -> throw, error mentions "media".
+ */
+test('callRawPayloadParser throws when media is CALL_TYPE_UNKNOWN', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-4')
+  pb.setParticipantsList([ 'alice' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_UNKNOWN)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+
+  await t.rejects(
+    callParser(pb.toObject()),
+    /media/,
+    'rejects with a message that mentions media',
+  )
+})
+
+/**
+ * 5. startTime not set -> throw, error mentions "startTime".
+ */
+test('callRawPayloadParser throws when startTime is not set', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-5')
+  pb.setParticipantsList([ 'alice' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  // no setStartTime
+
+  await t.rejects(
+    callParser(pb.toObject()),
+    /startTime/,
+    'rejects with a message that mentions startTime',
+  )
+})
+
+/**
+ * 6. endTime explicitly set to epoch 0 -> payload.endTime === 0.
+ *    proto3 `setEndTime(timestamp(0))` is a legal "ended at epoch-0" value
+ *    (extreme short session / test stub) and must not be swallowed by a
+ *    truthy guard. Presence is what matters, not the numeric value.
+ */
+test('callRawPayloadParser preserves endTime when it is set to epoch zero', async t => {
+  const pb = new grpcPuppet.CallPayloadResponse()
+  pb.setId('call-6')
+  pb.setStarter('alice')
+  pb.setParticipantsList([ 'alice', 'bob' ])
+  pb.setMedia(grpcPuppet.CallType.CALL_TYPE_VOICE)
+  pb.setStartTime(timestampFromMilliseconds(1_700_000_000_000))
+  pb.setEndTime(timestampFromMilliseconds(0))
+
+  const payload = await callParser(pb.toObject())
+
+  t.equal(payload.endTime, 0, 'endTime is 0 when explicitly set to epoch zero on the wire')
+})

package/src/client/puppet-service.ts

@@ -31,7 +31,10 @@ import {
 
 // import type { Subscription }  from 'rxjs'
 
-import { millisecondsFromTimestamp }  from '../pure-functions/timestamp.js'
+import {
+  millisecondsFromTimestamp,
+  millisecondsFromTimestampObject,
+}                                     from '../pure-functions/timestamp.js'
 
 import {
   uuidifyFileBoxGrpc,
@@ -51,6 +54,7 @@ import { packageJson }  from '../package-json.js'
 import { GrpcManager }  from './grpc-manager.js'
 import { PayloadStore } from './payload-store.js'
 import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPbToPayload, channelPayloadToPb, channelPbToPayload, chatHistoryPbToPayload, contactPbToPayload, postPayloadToPb, roomMemberPbToPayload, urlLinkPbToPayload, channelCardPayloadToPb, channelCardPbToPayload, miniProgramPayloadToPb, urlLinkPayloadToPb, locationPayloadToPb } from '../utils/pb-payload-helper.js'
+import { puppetCallMediaTypeToGrpc, grpcCallTypeToPuppetMedia } from '../utils/call-media-mapping.js'
 import type { MessageBroadcastTargets } from '@juzi/wechaty-puppet/dist/esm/src/schemas/message.js'
 import { timeoutPromise } from 'gerror'
 import { BooleanIndicator } from 'state-switch'
@@ -423,6 +427,9 @@ class PuppetService extends PUPPET.Puppet {
       case grpcPuppet.EventType.EVENT_TYPE_VERIFY_SLIDE:
         this.emit('verify-slide', JSON.parse(payload) as PUPPET.payloads.EventVerifySlide)
         break
+      case grpcPuppet.EventType.EVENT_TYPE_CALL:
+        this.emit('call', JSON.parse(payload) as PUPPET.payloads.EventCall)
+        break
 
       default:
         // Huan(202003): in default, the `type` type should be `never`, please check.
@@ -1153,6 +1160,189 @@ class PuppetService extends PUPPET.Puppet {
     return payload
   }
 
+  override async callInvite (
+    contactIds: string[],
+    media: PUPPET.types.CallMediaType,
+  ): Promise<string> {
+    log.verbose('PuppetService', 'callInvite(%s, %s)', contactIds, media)
+
+    const request = new grpcPuppet.CallInviteRequest()
+    request.setContactIdsList(contactIds)
+    request.setMedia(puppetCallMediaTypeToGrpc(media))
+
+    const response = await util.promisify(
+      this.grpcManager.client.callInvite
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const callId = response.getCallId()
+    if (!callId) {
+      throw new Error('callInvite: puppet server returned empty call_id')
+    }
+
+    return callId
+  }
+
+  override async callAdd (
+    callId: string,
+    contactIds: string[],
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callAdd(%s, %s)', callId, contactIds)
+
+    const request = new grpcPuppet.CallAddRequest()
+    request.setCallId(callId)
+    request.setContactIdsList(contactIds)
+
+    await this.grpcUnary(
+      this.grpcManager.client.callAdd,
+      request,
+    )
+  }
+
+  override async callAccept (
+    callId: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callAccept(%s)', callId)
+
+    const request = new grpcPuppet.CallAcceptRequest()
+    request.setCallId(callId)
+
+    await this.grpcUnary(
+      this.grpcManager.client.callAccept,
+      request,
+    )
+  }
+
+  override async callReject (
+    callId: string,
+    reason?: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callReject(%s, %s)', callId, reason)
+
+    const request = new grpcPuppet.CallRejectRequest()
+    request.setCallId(callId)
+    if (reason !== undefined && reason !== '') {
+      request.setReason(reason)
+    }
+
+    await this.grpcUnary(
+      this.grpcManager.client.callReject,
+      request,
+    )
+  }
+
+  override async callCancel (
+    callId: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callCancel(%s)', callId)
+
+    const request = new grpcPuppet.CallCancelRequest()
+    request.setCallId(callId)
+
+    await this.grpcUnary(
+      this.grpcManager.client.callCancel,
+      request,
+    )
+  }
+
+  override async callHangup (
+    callId: string,
+    reason?: string,
+  ): Promise<void> {
+    log.verbose('PuppetService', 'callHangup(%s, %s)', callId, reason)
+
+    const request = new grpcPuppet.CallHangupRequest()
+    request.setCallId(callId)
+    if (reason !== undefined && reason !== '') {
+      request.setReason(reason)
+    }
+
+    await this.grpcUnary(
+      this.grpcManager.client.callHangup,
+      request,
+    )
+  }
+
+  override async callMediaEndpoint (
+    callId: string,
+  ): Promise<PUPPET.payloads.CallMediaEndpoint> {
+    log.verbose('PuppetService', 'callMediaEndpoint(%s)', callId)
+
+    const request = new grpcPuppet.CallMediaEndpointRequest()
+    request.setCallId(callId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.callMediaEndpoint
+        .bind(this.grpcManager.client),
+    )(request)
+
+    const url   = response.getUrl()
+    const token = response.getToken()
+    if (!url || !token) {
+      throw new Error('callMediaEndpoint: puppet server returned empty url or token')
+    }
+
+    const payload: PUPPET.payloads.CallMediaEndpoint = {
+      url,
+      token,
+    }
+
+    if (response.hasExpiresAt()) {
+      payload.expiresAt = millisecondsFromTimestamp(response.getExpiresAt()!)
+    }
+
+    const protocol = response.getProtocol()
+    if (protocol) {
+      payload.protocol = protocol
+    }
+
+    return payload
+  }
+
+  override async callRawPayload (callId: string): Promise<grpcPuppet.CallPayloadResponse.AsObject> {
+    log.verbose('PuppetService', 'callRawPayload(%s)', callId)
+
+    const request = new grpcPuppet.CallPayloadRequest()
+    request.setId(callId)
+
+    const response = await util.promisify(
+      this.grpcManager.client.callPayload
+        .bind(this.grpcManager.client),
+    )(request)
+
+    return response.toObject()
+  }
+
+  override async callRawPayloadParser (rawPayload: grpcPuppet.CallPayloadResponse.AsObject): Promise<PUPPET.payloads.Call> {
+    log.verbose('PuppetService', 'callRawPayloadParser({id:%s})', rawPayload.id)
+
+    const media = grpcCallTypeToPuppetMedia(rawPayload.media)
+    if (media === undefined) {
+      throw new Error('callRawPayloadParser: media is required (got CALL_TYPE_UNKNOWN on the wire)')
+    }
+
+    if (rawPayload.startTime === undefined) {
+      throw new Error('callRawPayloadParser: startTime is required')
+    }
+
+    const payload: PUPPET.payloads.Call = {
+      id           : rawPayload.id,
+      participants : rawPayload.participantsList,
+      media,
+      startTime    : millisecondsFromTimestampObject(rawPayload.startTime),
+    }
+
+    if (rawPayload.starter) {
+      payload.starter = rawPayload.starter
+    }
+
+    if (rawPayload.endTime !== undefined) {
+      payload.endTime = millisecondsFromTimestampObject(rawPayload.endTime)
+    }
+
+    return payload
+  }
+
   override async messageChatHistory (
     messageId: string,
   ): Promise<PUPPET.payloads.ChatHistory[]> {

package/src/package-json.ts

@@ -4,7 +4,7 @@
 import type { PackageJson } from 'type-fest'
 export const packageJson: PackageJson = {
   "name": "@juzi/wechaty-puppet-service",
-  "version": "1.0.114",
+  "version": "1.0.115",
   "description": "Puppet Service for Wechaty",
   "type": "module",
   "exports": {
@@ -55,7 +55,7 @@ export const packageJson: PackageJson = {
     "@chatie/eslint-config": "^1.0.4",
     "@chatie/semver": "^0.4.7",
     "@chatie/tsconfig": "^4.6.3",
-    "@juzi/wechaty-puppet": "^1.0.137",
+    "@juzi/wechaty-puppet": "^1.0.138",
     "@juzi/wechaty-puppet-mock": "^1.0.1",
     "@swc/core": "1.3.39",
     "@types/google-protobuf": "^3.15.5",
@@ -74,10 +74,10 @@ export const packageJson: PackageJson = {
     "why-is-node-running": "^2.2.1"
   },
   "peerDependencies": {
-    "@juzi/wechaty-puppet": "^1.0.137"
+    "@juzi/wechaty-puppet": "^1.0.138"
   },
   "dependencies": {
-    "@juzi/wechaty-grpc": "^1.0.101",
+    "@juzi/wechaty-grpc": "^1.0.102",
     "clone-class": "^1.1.1",
     "ducks": "^1.0.2",
     "file-box": "^1.5.5",

package/src/pure-functions/timestamp.spec.ts

@@ -0,0 +1,56 @@
+#!/usr/bin/env -S node --no-warnings --loader ts-node/esm
+
+import { test } from 'tstest'
+
+import {
+  millisecondsFromTimestamp,
+  millisecondsFromTimestampObject,
+  timestampFromMilliseconds,
+}                             from './timestamp.js'
+
+/**
+ * 1. ms -> Timestamp -> ms round-trips for millisecond-aligned values.
+ */
+test('timestampFromMilliseconds <-> millisecondsFromTimestamp round-trip', async t => {
+  const cases = [
+    0,
+    1_000,
+    1_700_000_000_000,
+    1_700_000_000_123,
+  ]
+
+  for (const ms of cases) {
+    const roundTripped = millisecondsFromTimestamp(timestampFromMilliseconds(ms))
+    t.equal(roundTripped, ms, `round-trip identity for ${ms}ms`)
+  }
+})
+
+/**
+ * 2. The plain-object variant agrees with the instance variant for the same
+ *    Timestamp (this is the `toObject()` shape used by callRawPayloadParser).
+ */
+test('millisecondsFromTimestampObject matches millisecondsFromTimestamp', async t => {
+  const cases = [
+    0,
+    1_000,
+    1_700_000_000_123,
+  ]
+
+  for (const ms of cases) {
+    const timestamp = timestampFromMilliseconds(ms)
+    const fromInstance = millisecondsFromTimestamp(timestamp)
+    const fromObject   = millisecondsFromTimestampObject(timestamp.toObject())
+    t.equal(fromObject, fromInstance, `instance and object conversion agree for ${ms}ms`)
+  }
+})
+
+/**
+ * 3. Sub-millisecond nanos are rounded to the nearest millisecond.
+ */
+test('millisecondsFromTimestampObject rounds nanos to nearest millisecond', async t => {
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 0 }),         1000, 'no nanos')
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 499_999 }),   1000, '0.499ms rounds down')
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 500_000 }),   1001, '0.5ms rounds up')
+  t.equal(millisecondsFromTimestampObject({ seconds: 1, nanos: 999_999 }),   1001, '0.999ms rounds up')
+  t.equal(millisecondsFromTimestampObject({ seconds: 0, nanos: 123_000_000 }), 123, '123ms from nanos')
+})

package/src/pure-functions/timestamp.ts

@@ -22,7 +22,26 @@ function millisecondsFromTimestamp (timestamp: ReturnType<typeof timestampFromMi
   return seconds * 1000 + nanos / 1000000
 }
 
+/**
+ * Plain `{ seconds, nanos }` shape produced by a protobuf `Message.toObject()`
+ * for a `google.protobuf.Timestamp` field.
+ */
+type TimestampObject = {
+  seconds: number,
+  nanos: number,
+}
+
+/**
+ * Same conversion as `millisecondsFromTimestamp`, but for the plain
+ * `{ seconds, nanos }` shape produced by `Message.toObject()` rather than a
+ * Timestamp class instance. Nanos are rounded to the nearest millisecond.
+ */
+function millisecondsFromTimestampObject (timestamp: TimestampObject): number {
+  return timestamp.seconds * 1000 + Math.round(timestamp.nanos / 1000000)
+}
+
 export {
   millisecondsFromTimestamp,
+  millisecondsFromTimestampObject,
   timestampFromMilliseconds,
 }

package/src/server/event-stream-manager.ts

@@ -322,6 +322,13 @@ class EventStreamManager {
           this.offCallbackList.push(off)
           break
         }
+        case 'call': {
+          const listener = (payload: PUPPET.payloads.EventCall) => this.grpcEmit(grpcPuppet.EventType.EVENT_TYPE_CALL, payload)
+          this.puppet.on('call', listener)
+          const off = () => this.puppet.off('call', listener)
+          this.offCallbackList.push(off)
+          break
+        }
         case 'reset':
           // the `reset` event should be dealed internally, should not send out
           break

package/src/server/puppet-implementation.ts

@@ -44,6 +44,7 @@ import { log } from '../config.js'
 import { grpcError }          from './grpc-error.js'
 import { EventStreamManager } from './event-stream-manager.js'
 import { OptionalBooleanUnwrapper, OptionalBooleanWrapper, callRecordPayloadToPb, channelPayloadToPb, chatHistoryPayloadToPb, postPbToPayload, urlLinkPayloadToPb, channelCardPayloadToPb } from '../utils/pb-payload-helper.js'
+import { grpcCallTypeToPuppetMedia, puppetCallMediaTypeToGrpc } from '../utils/call-media-mapping.js'
 import { TextContentType } from '@juzi/wechaty-puppet/types'
 
 type MessageBatchSendResponse = Awaited<ReturnType<PUPPET.impls.PuppetInterface['messageBatchSendText']>>
@@ -2958,6 +2959,180 @@ function puppetImplementation (
 
     },
 
+    callInvite: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callInvite()')
+
+      try {
+        const contactIds = call.request.getContactIdsList()
+        if (contactIds.length === 0) {
+          throw new Error('callInvite: contact_ids is required')
+        }
+        const media = grpcCallTypeToPuppetMedia(call.request.getMedia())
+        if (media === undefined) {
+          throw new Error('callInvite: media is required (got CALL_TYPE_UNKNOWN on the wire)')
+        }
+
+        const callId = await puppet.callInvite(contactIds, media)
+        if (!callId) {
+          throw new Error('callInvite: puppet returned empty callId')
+        }
+
+        const response = new grpcPuppet.CallInviteResponse()
+        response.setCallId(callId)
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('callInvite', e, callback)
+      }
+    },
+
+    callAdd: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callAdd()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callAdd: call_id is required')
+        }
+        const contactIds = call.request.getContactIdsList()
+        if (contactIds.length === 0) {
+          throw new Error('callAdd: contact_ids is required')
+        }
+
+        await puppet.callAdd(callId, contactIds)
+
+        return callback(null, new grpcPuppet.CallAddResponse())
+      } catch (e) {
+        return grpcError('callAdd', e, callback)
+      }
+    },
+
+    callAccept: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callAccept()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callAccept: call_id is required')
+        }
+
+        await puppet.callAccept(callId)
+
+        return callback(null, new grpcPuppet.CallAcceptResponse())
+      } catch (e) {
+        return grpcError('callAccept', e, callback)
+      }
+    },
+
+    callReject: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callReject()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callReject: call_id is required')
+        }
+        const reason = call.request.getReason() || undefined
+
+        await puppet.callReject(callId, reason)
+
+        return callback(null, new grpcPuppet.CallRejectResponse())
+      } catch (e) {
+        return grpcError('callReject', e, callback)
+      }
+    },
+
+    callCancel: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callCancel()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callCancel: call_id is required')
+        }
+
+        await puppet.callCancel(callId)
+
+        return callback(null, new grpcPuppet.CallCancelResponse())
+      } catch (e) {
+        return grpcError('callCancel', e, callback)
+      }
+    },
+
+    callHangup: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callHangup()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callHangup: call_id is required')
+        }
+        const reason = call.request.getReason() || undefined
+
+        await puppet.callHangup(callId, reason)
+
+        return callback(null, new grpcPuppet.CallHangupResponse())
+      } catch (e) {
+        return grpcError('callHangup', e, callback)
+      }
+    },
+
+    callMediaEndpoint: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callMediaEndpoint()')
+
+      try {
+        const callId = call.request.getCallId()
+        if (!callId) {
+          throw new Error('callMediaEndpoint: call_id is required')
+        }
+
+        const payload = await puppet.callMediaEndpoint(callId)
+
+        const response = new grpcPuppet.CallMediaEndpointResponse()
+        response.setUrl(payload.url)
+        response.setToken(payload.token)
+        if (payload.expiresAt !== undefined) {
+          response.setExpiresAt(timestampFromMilliseconds(payload.expiresAt))
+        }
+        if (payload.protocol) {
+          response.setProtocol(payload.protocol)
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('callMediaEndpoint', e, callback)
+      }
+    },
+
+    callPayload: async (call, callback) => {
+      log.verbose('PuppetServiceImpl', 'callPayload()')
+
+      try {
+        const callId = call.request.getId()
+        if (!callId) {
+          throw new Error('callPayload: id is required')
+        }
+
+        const payload = await puppet.callPayload(callId)
+
+        const response = new grpcPuppet.CallPayloadResponse()
+        response.setId(payload.id)
+        if (payload.starter) {
+          response.setStarter(payload.starter)
+        }
+        response.setParticipantsList(payload.participants)
+        response.setMedia(puppetCallMediaTypeToGrpc(payload.media))
+        response.setStartTime(timestampFromMilliseconds(payload.startTime))
+        if (payload.endTime !== undefined) {
+          response.setEndTime(timestampFromMilliseconds(payload.endTime))
+        }
+
+        return callback(null, response)
+      } catch (e) {
+        return grpcError('callPayload', e, callback)
+      }
+    },
+
     upload: async (call, callback) => {
       log.verbose('PuppetServiceImpl', 'upload()')