@twentyhq/call-recorder 1.0.0

package/src/logic-functions/flows/cancel-call-recording-request.util.ts

@@ -0,0 +1,46 @@
+import { isUndefined } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { CallRecordingRequestStatus } from 'src/logic-functions/constants/call-recording-request-status';
+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';
+import { cancelRecallBot } from 'src/logic-functions/recall-api/cancel-recall-bot.util';
+import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';
+
+// Intent-first: the stale-state cron finishes the Recall half when this call fails.
+export const cancelCallRecordingRequest = async ({
+  client,
+  callRecording,
+}: {
+  client: CoreApiClient;
+  callRecording: CallRecordingRecord;
+}): Promise<void> => {
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: {
+      recordingRequestStatus: CallRecordingRequestStatus.CANCELED,
+    },
+  });
+
+  if (isUndefined(callRecording.externalBotId)) {
+    return;
+  }
+
+  const cancelResult = await cancelRecallBot({
+    externalBotId: callRecording.externalBotId,
+  });
+
+  if (!cancelResult.ok) {
+    console.warn(
+      `[call-recorder] failed to cancel Recall bot for callRecording ${callRecording.id}, leaving it for the stale-state cron: ${cancelResult.errorMessage}`,
+    );
+
+    return;
+  }
+
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: {
+      externalBotId: null,
+    },
+  });
+};

package/src/logic-functions/flows/charge-completed-call-recording.util.ts

@@ -0,0 +1,31 @@
+import { isUndefined } from '@sniptt/guards';
+import { chargeCredits } from 'twenty-sdk/billing';
+
+import { computeCallRecordingCharge } from 'src/logic-functions/domain/compute-call-recording-charge.util';
+
+export const chargeCompletedCallRecording = async ({
+  callRecordingId,
+  startedAt,
+  endedAt,
+}: {
+  callRecordingId: string;
+  startedAt: string | undefined;
+  endedAt: string | undefined;
+}): Promise<void> => {
+  const charge = computeCallRecordingCharge({ startedAt, endedAt });
+
+  if (isUndefined(charge)) {
+    console.warn(
+      `[call-recorder] call recording ${callRecordingId} completed without usable recording timestamps; it will not be billed`,
+    );
+
+    return;
+  }
+
+  await chargeCredits({
+    creditsUsedMicro: charge.creditsUsedMicro,
+    quantity: charge.quantityMinutes,
+    operationType: 'CALL_RECORDING',
+    resourceContext: 'recall',
+  });
+};

package/src/logic-functions/flows/complete-and-charge-call-recording.util.ts

@@ -0,0 +1,29 @@
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { completeCallRecordingIngestion } from 'src/logic-functions/data/complete-call-recording-ingestion.util';
+import { chargeCompletedCallRecording } from 'src/logic-functions/flows/charge-completed-call-recording.util';
+
+export const completeAndChargeCallRecording = async (
+  client: CoreApiClient,
+  {
+    id,
+    startedAt,
+    endedAt,
+  }: {
+    id: string;
+    startedAt: string | undefined;
+    endedAt: string | undefined;
+  },
+): Promise<boolean> => {
+  const claimed = await completeCallRecordingIngestion(client, { id });
+
+  if (claimed) {
+    await chargeCompletedCallRecording({
+      callRecordingId: id,
+      startedAt,
+      endedAt,
+    });
+  }
+
+  return claimed;
+};

package/src/logic-functions/flows/converge-diverged-call-recordings-result.type.ts

@@ -0,0 +1,8 @@
+export type ConvergeDivergedCallRecordingsResult = {
+  candidateCount: number;
+  updatedCallRecordingIds: string[];
+  markedFailedCallRecordingIds: string[];
+  requestedTranscriptCallRecordingIds: string[];
+  unconvergeableCallRecordingIds: string[];
+  skippedNotStartedCallRecordingIds: string[];
+};

package/src/logic-functions/flows/converge-diverged-call-recordings.util.ts

@@ -0,0 +1,447 @@
+import { isNonEmptyArray, isUndefined } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { CallRecordingRequestStatus } from 'src/logic-functions/constants/call-recording-request-status';
+import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
+import { NON_TERMINAL_CALL_RECORDING_STATUSES } from 'src/logic-functions/constants/non-terminal-call-recording-statuses';
+import { TWENTY_PAGE_SIZE } from 'src/logic-functions/constants/twenty-page-size';
+import { type FilesFieldValue } from 'src/logic-functions/types/files-field-value.type';
+import {
+  extractRecallBotConvergence,
+  type RecallBotConvergence,
+} from 'src/logic-functions/recall-api/extract-recall-bot-convergence.util';
+import {
+  fetchAllNodes,
+  type ConnectionPage,
+} from 'src/logic-functions/data/fetch-all-nodes.util';
+import { getRecallBot } from 'src/logic-functions/recall-api/get-recall-bot.util';
+import { ingestCallRecordingMedia } from 'src/logic-functions/flows/ingest-call-recording-media.util';
+import { isCallRecordingStatusDowngrade } from 'src/logic-functions/domain/is-call-recording-status-downgrade.util';
+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';
+import { parseTranscriptMarker } from 'src/logic-functions/domain/parse-transcript-marker.util';
+import { persistCallRecordingProgress } from 'src/logic-functions/flows/persist-call-recording-progress.util';
+import { reconcileCallRecordingTranscriptArtifact } from 'src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util';
+import { type ConvergeDivergedCallRecordingsResult } from 'src/logic-functions/flows/converge-diverged-call-recordings-result.type';
+import { shouldCompleteCallRecordingIngestion } from 'src/logic-functions/domain/should-complete-call-recording-ingestion.util';
+import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';
+import { type CallRecordingUpdateFields } from 'src/logic-functions/types/call-recording-update-fields.type';
+
+const CONVERGENCE_LOOKBACK_DAYS = 7;
+
+type DivergedCallRecordingCandidate = {
+  id: string;
+  status: string | undefined;
+  startedAt: string | undefined;
+  endedAt: string | undefined;
+  externalBotId: string | undefined;
+  externalRecordingId: string | undefined;
+  transcript: unknown;
+  audio: FilesFieldValue | undefined;
+  video: FilesFieldValue | undefined;
+  createdAt: string | undefined;
+  calendarEventStartsAt: string | undefined;
+  calendarEventEndsAt: string | undefined;
+};
+
+type DivergedCallRecordingNode = {
+  id: string;
+  status?: string | null;
+  startedAt?: string | null;
+  endedAt?: string | null;
+  externalBotId?: string | null;
+  externalRecordingId?: string | null;
+  transcript?: unknown;
+  audio?: FilesFieldValue | null;
+  video?: FilesFieldValue | null;
+  createdAt?: string | null;
+  calendarEvent?: { startsAt?: string | null; endsAt?: string | null } | null;
+};
+
+// Webhook deliveries get lost; this pull pass re-derives state from Recall.
+export const convergeDivergedCallRecordings = async ({
+  client,
+  now,
+}: {
+  client: CoreApiClient;
+  now: Date;
+}): Promise<ConvergeDivergedCallRecordingsResult> => {
+  const candidates = await fetchDivergedCallRecordingCandidates(client);
+  const convergenceLowerBound = new Date(
+    now.getTime() - CONVERGENCE_LOOKBACK_DAYS * 24 * 60 * 60 * 1000,
+  );
+  const result: ConvergeDivergedCallRecordingsResult = {
+    candidateCount: candidates.length,
+    updatedCallRecordingIds: [],
+    markedFailedCallRecordingIds: [],
+    requestedTranscriptCallRecordingIds: [],
+    unconvergeableCallRecordingIds: [],
+    skippedNotStartedCallRecordingIds: [],
+  };
+
+  for (const candidate of candidates) {
+    if (isOutsideConvergenceBound(candidate, convergenceLowerBound)) {
+      console.warn(
+        `[call-recorder] call recording ${candidate.id} diverged but its meeting ended more than ${CONVERGENCE_LOOKBACK_DAYS} days ago; it will not converge automatically`,
+      );
+      result.unconvergeableCallRecordingIds.push(candidate.id);
+      continue;
+    }
+
+    if (isUndefined(candidate.externalBotId)) {
+      console.warn(
+        `[call-recorder] call recording ${candidate.id} diverged but has no Recall bot id; it will not converge automatically`,
+      );
+      result.unconvergeableCallRecordingIds.push(candidate.id);
+      continue;
+    }
+
+    if (isBeforeMeetingStart(candidate, now)) {
+      result.skippedNotStartedCallRecordingIds.push(candidate.id);
+      continue;
+    }
+
+    await convergeCallRecording({
+      client,
+      candidate,
+      externalBotId: candidate.externalBotId,
+      now,
+      result,
+    });
+  }
+
+  return result;
+};
+
+const fetchDivergedCallRecordingCandidates = async (
+  client: CoreApiClient,
+): Promise<DivergedCallRecordingCandidate[]> => {
+  // No createdAt bound: older-than-lookback candidates must surface in logs.
+  const filter: Record<string, unknown> = {
+    or: [
+      {
+        recordingRequestStatus: { eq: CallRecordingRequestStatus.REQUESTED },
+        status: { in: NON_TERMINAL_CALL_RECORDING_STATUSES },
+        externalBotId: { is: 'NOT_NULL' },
+      },
+      {
+        status: { eq: CallRecordingStatus.COMPLETED },
+        or: [{ startedAt: { is: 'NULL' } }, { endedAt: { is: 'NULL' } }],
+      },
+    ],
+  };
+  const candidateNodes = await fetchAllNodes<DivergedCallRecordingNode>(
+    async (afterCursor) => {
+      const queryResult = await client.query({
+        callRecordings: {
+          __args: {
+            filter,
+            first: TWENTY_PAGE_SIZE,
+            ...(isUndefined(afterCursor) ? {} : { after: afterCursor }),
+          },
+          pageInfo: {
+            hasNextPage: true,
+            endCursor: true,
+          },
+          edges: {
+            node: {
+              id: true,
+              status: true,
+              startedAt: true,
+              endedAt: true,
+              externalBotId: true,
+              externalRecordingId: true,
+              transcript: true,
+              audio: { fileId: true },
+              video: { fileId: true },
+              createdAt: true,
+              calendarEvent: {
+                startsAt: true,
+                endsAt: true,
+              },
+            },
+          },
+        },
+      });
+
+      return (queryResult.callRecordings ?? undefined) as
+        | ConnectionPage<DivergedCallRecordingNode>
+        | undefined;
+    },
+  );
+
+  return candidateNodes.map((node) => ({
+    id: node.id,
+    status: node.status ?? undefined,
+    startedAt: node.startedAt ?? undefined,
+    endedAt: node.endedAt ?? undefined,
+    externalBotId: isNonEmptyString(node.externalBotId)
+      ? node.externalBotId
+      : undefined,
+    externalRecordingId: isNonEmptyString(node.externalRecordingId)
+      ? node.externalRecordingId
+      : undefined,
+    transcript: node.transcript ?? undefined,
+    audio: node.audio ?? undefined,
+    video: node.video ?? undefined,
+    createdAt: node.createdAt ?? undefined,
+    calendarEventStartsAt: node.calendarEvent?.startsAt ?? undefined,
+    calendarEventEndsAt: node.calendarEvent?.endsAt ?? undefined,
+  }));
+};
+
+// Anchored to meeting end: createdAt is scheduling time and can predate the meeting by weeks.
+const isOutsideConvergenceBound = (
+  candidate: DivergedCallRecordingCandidate,
+  convergenceLowerBound: Date,
+): boolean => {
+  const meetingEndReference =
+    candidate.calendarEventEndsAt ?? candidate.createdAt;
+
+  return (
+    !isUndefined(meetingEndReference) &&
+    new Date(meetingEndReference).getTime() < convergenceLowerBound.getTime()
+  );
+};
+
+// Until the meeting starts the bot has recorded nothing, so there is nothing to pull yet.
+const isBeforeMeetingStart = (
+  candidate: DivergedCallRecordingCandidate,
+  now: Date,
+): boolean =>
+  !isUndefined(candidate.calendarEventStartsAt) &&
+  new Date(candidate.calendarEventStartsAt).getTime() > now.getTime();
+
+const convergeCallRecording = async ({
+  client,
+  candidate,
+  externalBotId,
+  now,
+  result,
+}: {
+  client: CoreApiClient;
+  candidate: DivergedCallRecordingCandidate;
+  externalBotId: string;
+  now: Date;
+  result: ConvergeDivergedCallRecordingsResult;
+}): Promise<void> => {
+  const botResult = await getRecallBot({ externalBotId });
+
+  if (!botResult.ok) {
+    if (botResult.status === 404) {
+      await markCallRecordingFailedAfterBotLoss({
+        client,
+        candidate,
+        externalBotId,
+        result,
+      });
+
+      return;
+    }
+
+    console.warn(
+      `[call-recorder] failed to fetch Recall bot ${externalBotId} for call recording ${candidate.id}: ${botResult.errorMessage}`,
+    );
+
+    return;
+  }
+
+  const convergence = extractRecallBotConvergence(botResult.bot);
+  const updateData = buildConvergenceFieldUpdates({ candidate, convergence });
+
+  const externalRecordingId =
+    candidate.externalRecordingId ?? convergence.externalRecordingId;
+
+  if (convergence.isRecallRecordingDone && !isUndefined(externalRecordingId)) {
+    const transcriptArtifactResult =
+      await reconcileCallRecordingTranscriptArtifact({
+        callRecordingId: candidate.id,
+        currentStatus: candidate.status,
+        externalRecordingId,
+        requestedAt: now.toISOString(),
+        transcript: candidate.transcript,
+      });
+
+    Object.assign(updateData, transcriptArtifactResult.updateData);
+
+    if (transcriptArtifactResult.requestedTranscript) {
+      result.requestedTranscriptCallRecordingIds.push(candidate.id);
+    }
+
+    Object.assign(
+      updateData,
+      await ingestCallRecordingMedia({
+        callRecordingId: candidate.id,
+        externalRecordingId,
+        hasAudio: isNonEmptyArray(candidate.audio),
+        hasVideo: isNonEmptyArray(candidate.video),
+      }),
+    );
+  }
+
+  const terminalArtifactGateFailureUpdate =
+    buildTerminalArtifactGateFailureUpdate({
+      candidate,
+      convergence,
+      externalRecordingId,
+      updateData,
+    });
+
+  if (!isUndefined(terminalArtifactGateFailureUpdate)) {
+    Object.assign(updateData, terminalArtifactGateFailureUpdate);
+  }
+
+  const completesIngestion = shouldCompleteCallRecordingIngestion({
+    current: candidate,
+    updateData,
+  });
+
+  if (Object.keys(updateData).length === 0 && !completesIngestion) {
+    return;
+  }
+
+  await persistCallRecordingProgress(client, {
+    id: candidate.id,
+    current: candidate,
+    updateData,
+  });
+
+  result.updatedCallRecordingIds.push(candidate.id);
+};
+
+// Pure merge: fill only unset candidate fields and never downgrade status.
+const buildConvergenceFieldUpdates = ({
+  candidate,
+  convergence,
+}: {
+  candidate: DivergedCallRecordingCandidate;
+  convergence: RecallBotConvergence;
+}): CallRecordingUpdateFields => {
+  const updateData: CallRecordingUpdateFields = {};
+
+  if (
+    !isUndefined(convergence.status) &&
+    convergence.status !== candidate.status &&
+    !isCallRecordingStatusDowngrade({
+      fromStatus: candidate.status,
+      toStatus: convergence.status,
+    })
+  ) {
+    updateData.status = convergence.status;
+
+    if (convergence.status === CallRecordingStatus.FAILED) {
+      updateData.callRecorderFailureReason =
+        convergence.failureReason ?? 'recall_bot_failed';
+    }
+  }
+
+  if (isUndefined(candidate.startedAt) && !isUndefined(convergence.startedAt)) {
+    updateData.startedAt = convergence.startedAt;
+  }
+
+  if (isUndefined(candidate.endedAt) && !isUndefined(convergence.endedAt)) {
+    updateData.endedAt = convergence.endedAt;
+  }
+
+  if (
+    isUndefined(candidate.externalRecordingId) &&
+    !isUndefined(convergence.externalRecordingId)
+  ) {
+    updateData.externalRecordingId = convergence.externalRecordingId;
+  }
+
+  return updateData;
+};
+
+type TerminalArtifactGateFailureUpdate = {
+  status: CallRecordingStatus.FAILED;
+  callRecorderFailureReason: string;
+};
+
+const buildTerminalArtifactGateFailureUpdate = ({
+  candidate,
+  convergence,
+  externalRecordingId,
+  updateData,
+}: {
+  candidate: DivergedCallRecordingCandidate;
+  convergence: RecallBotConvergence;
+  externalRecordingId: string | undefined;
+  updateData: CallRecordingUpdateFields;
+}): TerminalArtifactGateFailureUpdate | undefined => {
+  if (
+    candidate.status === CallRecordingStatus.COMPLETED ||
+    updateData.status === CallRecordingStatus.FAILED ||
+    !convergence.isRecallRecordingDone ||
+    !isUndefined(externalRecordingId) ||
+    hasRecordingArtifactPath({ candidate, updateData })
+  ) {
+    return undefined;
+  }
+
+  return {
+    status: CallRecordingStatus.FAILED,
+    callRecorderFailureReason:
+      convergence.failureReason ?? 'recording_artifacts_unavailable',
+  };
+};
+
+const hasRecordingArtifactPath = ({
+  candidate,
+  updateData,
+}: {
+  candidate: DivergedCallRecordingCandidate;
+  updateData: CallRecordingUpdateFields;
+}): boolean => {
+  return (
+    isNonEmptyArray(updateData.audio ?? candidate.audio) ||
+    isNonEmptyArray(updateData.video ?? candidate.video) ||
+    hasReachableTranscript(updateData.transcript ?? candidate.transcript)
+  );
+};
+
+const hasReachableTranscript = (transcript: unknown): boolean => {
+  if (isUndefined(transcript)) {
+    return false;
+  }
+
+  const marker = parseTranscriptMarker(transcript);
+
+  return isUndefined(marker) || marker.status === 'PENDING';
+};
+
+const markCallRecordingFailedAfterBotLoss = async ({
+  client,
+  candidate,
+  externalBotId,
+  result,
+}: {
+  client: CoreApiClient;
+  candidate: DivergedCallRecordingCandidate;
+  externalBotId: string;
+  result: ConvergeDivergedCallRecordingsResult;
+}): Promise<void> => {
+  // externalBotId is kept for audit even though the bot is gone at Recall.
+  console.warn(
+    `[call-recorder] Recall bot ${externalBotId} for call recording ${candidate.id} no longer exists; it will not converge automatically`,
+  );
+
+  if (
+    isCallRecordingStatusDowngrade({
+      fromStatus: candidate.status,
+      toStatus: CallRecordingStatus.FAILED,
+    })
+  ) {
+    result.unconvergeableCallRecordingIds.push(candidate.id);
+
+    return;
+  }
+
+  await updateCallRecording(client, {
+    id: candidate.id,
+    data: {
+      status: CallRecordingStatus.FAILED,
+      callRecorderFailureReason: 'recall_bot_not_found',
+    },
+  });
+  result.markedFailedCallRecordingIds.push(candidate.id);
+};

package/src/logic-functions/flows/download-transcript.util.ts

@@ -0,0 +1,67 @@
+import { isUndefined } from '@sniptt/guards';
+
+import { retrieveRecallTranscript } from 'src/logic-functions/recall-api/retrieve-recall-transcript.util';
+
+const TRANSCRIPT_DOWNLOAD_TIMEOUT_MS = 20_000;
+
+export type DownloadTranscriptResult =
+  | { outcome: 'filled'; content: unknown }
+  | { outcome: 'failed'; subCode: string | null }
+  | { outcome: 'pending' }
+  | { outcome: 'error'; errorMessage: string };
+
+export const downloadTranscript = async ({
+  transcriptId,
+}: {
+  transcriptId: string;
+}): Promise<DownloadTranscriptResult> => {
+  const retrieveResult = await retrieveRecallTranscript({ transcriptId });
+
+  if (!retrieveResult.ok) {
+    return { outcome: 'error', errorMessage: retrieveResult.errorMessage };
+  }
+
+  const { downloadUrl, statusCode, statusSubCode } = retrieveResult.transcript;
+
+  if (!isUndefined(downloadUrl)) {
+    return downloadTranscriptContent(downloadUrl);
+  }
+
+  if (statusCode === 'error' || statusCode === 'failed') {
+    return { outcome: 'failed', subCode: statusSubCode ?? null };
+  }
+
+  return { outcome: 'pending' };
+};
+
+const downloadTranscriptContent = async (
+  downloadUrl: string,
+): Promise<DownloadTranscriptResult> => {
+  try {
+    const response = await fetch(downloadUrl, {
+      signal: AbortSignal.timeout(TRANSCRIPT_DOWNLOAD_TIMEOUT_MS),
+    });
+
+    if (!response.ok) {
+      console.warn(
+        `[call-recorder] transcript download responded with HTTP ${response.status}`,
+      );
+
+      return {
+        outcome: 'error',
+        errorMessage: 'transcript download failed',
+      };
+    }
+
+    return { outcome: 'filled', content: await response.json() };
+  } catch (error) {
+    console.warn(
+      `[call-recorder] transcript download failed: ${error instanceof Error ? error.message : String(error)}`,
+    );
+
+    return {
+      outcome: 'error',
+      errorMessage: 'transcript download failed',
+    };
+  }
+};

package/src/logic-functions/flows/ensure-call-recorder.util.ts

@@ -0,0 +1,73 @@
+import { isUndefined } from '@sniptt/guards';
+import { type CoreApiClient } from 'twenty-client-sdk/core';
+
+import { CallRecordingRequestStatus } from 'src/logic-functions/constants/call-recording-request-status';
+import { type MeetingRecording } from 'src/logic-functions/types/meeting-recording.type';
+import { buildRecallRoutingMetadata } from 'src/logic-functions/domain/build-recall-routing-metadata.util';
+import { computeRecallBotJoinAt } from 'src/logic-functions/domain/compute-recall-bot-join-at.util';
+import { findCallRecordingsByIds } from 'src/logic-functions/data/find-call-recordings-by-ids.util';
+import { getCurrentWorkspaceId } from 'src/logic-functions/data/get-current-workspace-id.util';
+import { scheduleRecallBot } from 'src/logic-functions/recall-api/schedule-recall-bot.util';
+import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';
+
+// The sole place a Recall bot is created. Only the deterministic-create winner and the stale-state cron call it, so one writer per meeting POSTs exactly one bot.
+export const ensureCallRecorder = async (
+  client: CoreApiClient,
+  { callRecording, calendarEvent }: MeetingRecording,
+): Promise<boolean> => {
+  const meetingUrl = calendarEvent.conferenceLinkUrl;
+  const meetingStartsAt = calendarEvent.startsAt;
+
+  if (isUndefined(meetingUrl) || isUndefined(meetingStartsAt)) {
+    return false;
+  }
+
+  const joinAt = computeRecallBotJoinAt(meetingStartsAt);
+
+  const freshCallRecording = (
+    await findCallRecordingsByIds(client, [callRecording.id])
+  )[0];
+
+  if (
+    isUndefined(freshCallRecording) ||
+    freshCallRecording.recordingRequestStatus !==
+      CallRecordingRequestStatus.REQUESTED ||
+    !isUndefined(freshCallRecording.externalBotId)
+  ) {
+    return false;
+  }
+
+  const workspaceId = getCurrentWorkspaceId();
+
+  if (isUndefined(workspaceId)) {
+    console.error(
+      `[call-recorder] cannot schedule Recall bot for callRecording ${callRecording.id}: workspace id unavailable, the shared webhook could not be routed back`,
+    );
+
+    return false;
+  }
+
+  const scheduleResult = await scheduleRecallBot({
+    meetingUrl,
+    joinAt,
+    metadata: buildRecallRoutingMetadata({
+      callRecordingId: callRecording.id,
+      workspaceId,
+    }),
+  });
+
+  if (!scheduleResult.ok) {
+    console.warn(
+      `[call-recorder] failed to schedule Recall bot for callRecording ${callRecording.id}: ${scheduleResult.errorMessage}`,
+    );
+
+    return false;
+  }
+
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: { externalBotId: scheduleResult.externalBotId },
+  });
+
+  return true;
+};