The open alternative to Salesforce, designed for AI.
TypeScript crmcrm-systemcustomergood-first-issuegraphqlhacktoberfestjavascriptmarketingmonoreponestjsopen-sourcepostgresqlreactreactjssalestypescriptweb
Reduce call-recorder Recall API load and harden bot scheduling recovery (#23014)
martmull89609c520c0d
diff --git a/packages/twenty-apps/public/call-recorder/src/__tests__/call-recorder-lifecycle.integration-test.ts b/packages/twenty-apps/public/call-recorder/src/__tests__/call-recorder-lifecycle.integration-test.tsnew file mode 100644index 00000000000..d90e31bb8dd--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/__tests__/call-recorder-lifecycle.integration-test.ts@@ -0,0 +1,858 @@+import { randomUUID } from 'crypto';++import { CoreApiClient } from 'twenty-client-sdk/core';+import { afterEach, beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';++import { cancelCallRecordingRequest } from 'src/logic-functions/flows/cancel-call-recording-request.util';+import { reconcileCallRecorderForCalendarEventIds } from 'src/logic-functions/flows/reconcile-call-recorder.util';+import { retryFailedRecallCancellations } from 'src/logic-functions/flows/retry-failed-recall-cancellations.util';+import { scheduleRecallBotsForPendingCallRecordings } from 'src/logic-functions/flows/schedule-recall-bots-for-pending-call-recordings.util';+import { processRecallWebhookHandler } from 'src/logic-functions/process-recall-webhook';++// ---------------------------------------------------------------------------+// Call Recorder end-to-end behavior against a live Twenty server.+//+// The app is installed on the test server by the vitest global setup, and all+// reads and writes go through the real API into the test database. Only the+// externals are mocked:+// - the Recall API (a fetch interceptor that replays the same bot for a+// repeated Idempotency-Key, like the real API),+// - the trigger transports: webhook deliveries invoke the webhook logic+// function handler directly, and cron / database-event triggers invoke+// the flows they dispatch.+//+// Every scenario then asserts the resulting CallRecording rows in the DB.+//+// The suite issues a few hundred API requests; if the test server runs with+// the default API_RATE_LIMITING_LONG_LIMIT of 100 requests per minute,+// raise it (e.g. to 100000) or the runs trip the limiter.+// ---------------------------------------------------------------------------++const WORKSPACE_API_KEY_ENV = 'TWENTY_API_KEY';+const RECALL_BASE_URL = 'https://us-west-2.recall.ai/api/v1';+const FUNCTIONS_URL = 'https://call-recorder-functions.test';+const ARTIFACT_IMPORT_ROUTE = '/call-recorder/import-call-recording-artifacts';+const RESTRICTED_TITLE_PLACEHOLDER =+ 'FIELD_RESTRICTED_ADDITIONAL_PERMISSIONS_REQUIRED';++// The app's generated client only covers the objects the app uses, but test+// seeding also needs calendarChannelEventAssociations (see below); this hits+// the workspace GraphQL API directly with the test API key.+const workspaceGraphql = async (+ query: string,+ variables: Record<string, unknown> = {},+): Promise<any> => {+ const response = await fetch(`${process.env.TWENTY_API_URL}/graphql`, {+ method: 'POST',+ headers: {+ Authorization: `Bearer ${process.env[WORKSPACE_API_KEY_ENV]}`,+ 'Content-Type': 'application/json',+ },+ body: JSON.stringify({ query, variables }),+ });+ const payload = await response.json();++ if (payload.errors !== undefined) {+ throw new Error(+ `Workspace GraphQL request failed: ${JSON.stringify(payload.errors)}`,+ );+ }++ return payload.data;+};++// Calendar events are only readable when a calendar channel with+// SHARE_EVERYTHING visibility claims them, exactly like events coming from a+// real calendar sync. The dev seeds provide such a channel; it is found by+// following a fully visible seeded event to its channel association.+const discoverShareEverythingChannelId = async (): Promise<string> => {+ const eventsData = await workspaceGraphql(+ `query { calendarEvents(first: 30) { edges { node { id title } } } }`,+ );+ const visibleEvent = eventsData.calendarEvents.edges+ .map((edge: any) => edge.node)+ .find(+ (node: any) =>+ node.title !== null && node.title !== RESTRICTED_TITLE_PLACEHOLDER,+ );++ if (visibleEvent === undefined) {+ throw new Error(+ 'No fully visible seeded calendar event found; run the dev seeds before the integration tests',+ );+ }++ const associationsData = await workspaceGraphql(+ `query ($calendarEventId: UUID) {+ calendarChannelEventAssociations(+ filter: { calendarEventId: { eq: $calendarEventId } }+ first: 1+ ) { edges { node { calendarChannelId } } }+ }`,+ { calendarEventId: visibleEvent.id },+ );+ const channelId =+ associationsData.calendarChannelEventAssociations.edges[0]?.node+ ?.calendarChannelId;++ if (channelId === undefined) {+ throw new Error('Seeded visible calendar event has no channel association');+ }++ return channelId;+};++const inOneHour = () => new Date(Date.now() + 60 * 60 * 1000).toISOString();+const inTwoHours = () => new Date(Date.now() + 2 * 60 * 60 * 1000).toISOString();+const hoursAgo = (hours: number) =>+ new Date(Date.now() - hours * 60 * 60 * 1000).toISOString();++// ---------------------------------------------------------------------------+// Recall API fake, installed as a fetch interceptor. Twenty API traffic is+// never intercepted: the shared client is built before the interceptor and+// unknown URLs fall through to the real fetch.+// ---------------------------------------------------------------------------++type FakeRecallBot = {+ id: string;+ metadata: Record<string, string>;+ statusCode: string;+};++class FakeRecallApi {+ bots = new Map<string, FakeRecallBot>();+ botIdByIdempotencyKey = new Map<string, string>();+ deletedBotIds: string[] = [];+ listRequestCount = 0;+ artifactImportRequests: object[] = [];+ failNextDelete = false;++ seedBot(bot: FakeRecallBot): void {+ this.bots.set(bot.id, bot);+ }++ botForCallRecording(callRecordingId: string): FakeRecallBot | undefined {+ return [...this.bots.values()].find(+ (bot) => bot.metadata.twentyCallRecordingId === callRecordingId,+ );+ }++ handle(requestUrl: string, requestInit?: any): Response | undefined {+ const method: string = requestInit?.method ?? 'GET';++ if (requestUrl.startsWith(`${FUNCTIONS_URL}${ARTIFACT_IMPORT_ROUTE}`)) {+ this.artifactImportRequests.push(JSON.parse(requestInit?.body ?? '{}'));++ return jsonResponse(200, {});+ }++ if (!requestUrl.startsWith(RECALL_BASE_URL)) {+ return undefined;+ }++ if (method === 'POST' && requestUrl === `${RECALL_BASE_URL}/bot/`) {+ return this.createBot(requestInit);+ }++ if (method === 'GET' && requestUrl.startsWith(`${RECALL_BASE_URL}/bot/?`)) {+ this.listRequestCount += 1;++ return jsonResponse(200, {+ next: null,+ results: [...this.bots.values()].map((bot) => ({+ id: bot.id,+ metadata: bot.metadata,+ status: { code: bot.statusCode },+ })),+ });+ }++ const botIdMatch = requestUrl.match(/\/bot\/([^/]+)\/$/);++ if (method === 'DELETE' && botIdMatch !== null) {+ if (this.failNextDelete) {+ this.failNextDelete = false;++ return jsonResponse(400, {});+ }++ this.bots.delete(botIdMatch[1]);+ this.deletedBotIds.push(botIdMatch[1]);++ return new Response(null, { status: 204 });+ }++ throw new Error(`Unhandled Recall API request: ${method} ${requestUrl}`);+ }++ private createBot(requestInit: any): Response {+ const idempotencyKey: string | undefined =+ requestInit?.headers?.['Idempotency-Key'];+ const alreadyCreatedBotId =+ idempotencyKey === undefined+ ? undefined+ : this.botIdByIdempotencyKey.get(idempotencyKey);++ if (alreadyCreatedBotId !== undefined) {+ return jsonResponse(200, { id: alreadyCreatedBotId });+ }++ const body = JSON.parse(requestInit?.body ?? '{}');+ const bot: FakeRecallBot = {+ id: `recall-bot-${randomUUID()}`,+ metadata: body.metadata ?? {},+ statusCode: 'ready',+ };++ this.bots.set(bot.id, bot);++ if (idempotencyKey !== undefined) {+ this.botIdByIdempotencyKey.set(idempotencyKey, bot.id);+ }++ return jsonResponse(201, { id: bot.id });+ }+}++const jsonResponse = (status: number, body: object): Response =>+ new Response(JSON.stringify(body), { status });++// ---------------------------------------------------------------------------+// Recall webhook payloads, mirroring the shapes Recall actually delivers.+// ---------------------------------------------------------------------------++const buildBotMetadata = (callRecordingId: string, workspaceId: string) => ({+ twentyWorkspaceId: workspaceId,+ twentyCallRecordingId: callRecordingId,+});++const buildBotStatusChangeWebhook = ({+ botId,+ metadata,+ statusCode,+ statusTimestamp,+}: {+ botId: string;+ metadata: Record<string, string>;+ statusCode: string;+ statusTimestamp?: string;+}) => ({+ event: 'bot.status_change',+ data: {+ bot_id: botId,+ status: {+ code: statusCode,+ created_at: statusTimestamp ?? new Date().toISOString(),+ },+ bot: { id: botId, metadata },+ },+});++const buildRecordingDoneWebhook = ({+ botId,+ metadata,+ startedAt,+ completedAt,+}: {+ botId: string;+ metadata: Record<string, string>;+ startedAt: string;+ completedAt: string;+}) => ({+ event: 'recording.done',+ data: {+ bot: { id: botId, metadata },+ recording: {+ id: 'recall-recording-1',+ started_at: startedAt,+ completed_at: completedAt,+ },+ },+});++const buildTranscriptDoneWebhook = ({+ botId,+ metadata,+}: {+ botId: string;+ metadata: Record<string, string>;+}) => ({+ event: 'transcript.done',+ data: {+ bot: { id: botId, metadata },+ transcript: { id: 'recall-transcript-1' },+ },+});++// ---------------------------------------------------------------------------+// Test workspace helpers: real rows in the test database, destroyed after+// each scenario.+// ---------------------------------------------------------------------------++describe('call recorder app lifecycle (integration)', () => {+ // Built before the fetch interceptor is installed so the shared client's+ // Twenty API traffic always uses the real fetch.+ let client: CoreApiClient;+ let workspaceId: string;+ let shareEverythingChannelId: string;+ let recall: FakeRecallApi;+ const createdCalendarEventIds: string[] = [];+ const createdCallRecordingIds: string[] = [];+ const createdAssociationIds: string[] = [];++ const readWorkspaceIdFromApiKey = (): string => {+ const apiKey = process.env[WORKSPACE_API_KEY_ENV] ?? '';+ const payload = JSON.parse(+ Buffer.from(apiKey.split('.')[1] ?? '', 'base64url').toString('utf8'),+ );++ return payload.workspaceId;+ };++ beforeAll(async () => {+ client = new CoreApiClient();+ workspaceId = readWorkspaceIdFromApiKey();+ shareEverythingChannelId = await discoverShareEverythingChannelId();+ });++ beforeEach(() => {+ recall = new FakeRecallApi();++ const realFetch = globalThis.fetch;++ vi.stubGlobal(+ 'fetch',+ (requestUrl: any, requestInit?: any): Promise<Response> => {+ const intercepted =+ typeof requestUrl === 'string'+ ? recall.handle(requestUrl, requestInit)+ : undefined;++ return intercepted !== undefined+ ? Promise.resolve(intercepted)+ : realFetch(requestUrl, requestInit);+ },+ );+ vi.stubEnv('RECALL_API_KEY', 'recall-api-key');+ vi.stubEnv('RECALL_REGION', 'us-west-2');+ vi.stubEnv('CALL_RECORDER_USE_WORKSPACE_LOGO', 'false');+ vi.stubEnv('TWENTY_FUNCTIONS_URL', FUNCTIONS_URL);+ // Logic functions normally run with an app access token; the workspace+ // API key is a token with the same workspaceId claim.+ vi.stubEnv(+ 'TWENTY_APP_ACCESS_TOKEN',+ process.env[WORKSPACE_API_KEY_ENV] ?? '',+ );+ });++ afterEach(async () => {+ vi.unstubAllGlobals();+ vi.unstubAllEnvs();++ await destroyCreatedRows();+ });++ const destroyCreatedRows = async (): Promise<void> => {+ const callRecordingsForCreatedCalendarEvents =+ createdCalendarEventIds.length === 0+ ? []+ : await findCallRecordings({+ calendarEventId: { in: createdCalendarEventIds },+ });+ const callRecordingIds = [+ ...new Set([+ ...createdCallRecordingIds,+ ...callRecordingsForCreatedCalendarEvents.map(({ id }) => id),+ ]),+ ];++ for (const callRecordingId of callRecordingIds) {+ await client+ .mutation({+ destroyCallRecording: { __args: { id: callRecordingId }, id: true },+ })+ .catch(() => {});+ }++ for (const associationId of createdAssociationIds) {+ await workspaceGraphql(+ `mutation ($id: UUID!) {+ destroyCalendarChannelEventAssociation(id: $id) { id }+ }`,+ { id: associationId },+ ).catch(() => {});+ }++ for (const calendarEventId of createdCalendarEventIds) {+ await client+ .mutation({+ destroyCalendarEvent: { __args: { id: calendarEventId }, id: true },+ })+ .catch(() => {});+ }++ createdCalendarEventIds.length = 0;+ createdCallRecordingIds.length = 0;+ createdAssociationIds.length = 0;+ };++ const createCalendarEvent = async (+ overrides: Record<string, unknown> = {},+ ): Promise<string> => {+ const calendarEventId = randomUUID();++ await client.mutation({+ createCalendarEvent: {+ __args: {+ data: {+ id: calendarEventId,+ title: 'Customer Sync (call recorder integration test)',+ startsAt: inOneHour(),+ endsAt: inTwoHours(),+ iCalUid: `call-recorder-test-${calendarEventId}`,+ conferenceLink: {+ primaryLinkUrl: `https://meet.example.com/${calendarEventId}`,+ },+ callRecorderPreference: 'ON',+ ...overrides,+ },+ },+ id: true,+ },+ });+ createdCalendarEventIds.push(calendarEventId);++ // Without a SHARE_EVERYTHING channel association the event would be+ // invisible to every query, like an event no calendar sync produced.+ const associationData = await workspaceGraphql(+ `mutation ($data: CalendarChannelEventAssociationCreateInput!) {+ createCalendarChannelEventAssociation(data: $data) { id }+ }`,+ {+ data: {+ calendarChannelId: shareEverythingChannelId,+ calendarEventId,+ eventExternalId: `call-recorder-test-${calendarEventId}`,+ },+ },+ );++ createdAssociationIds.push(+ associationData.createCalendarChannelEventAssociation.id,+ );++ return calendarEventId;+ };++ const createPendingCallRecording = async ({+ calendarEventId,+ ...overrides+ }: Record<string, unknown> & { calendarEventId: string }): Promise<string> => {+ const callRecordingId = randomUUID();++ await client.mutation({+ createCallRecording: {+ __args: {+ data: {+ id: callRecordingId,+ title: 'Customer Sync (call recorder integration test)',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ calendarEventId,+ ...overrides,+ },+ },+ id: true,+ },+ });+ createdCallRecordingIds.push(callRecordingId);++ return callRecordingId;+ };++ const findCallRecordings = async (+ filter: Record<string, unknown>,+ ): Promise<Array<Record<string, any>>> => {+ const result = await client.query({+ callRecordings: {+ __args: { filter, first: 50 },+ edges: {+ node: {+ id: true,+ status: true,+ recordingRequestStatus: true,+ calendarEventId: true,+ externalBotId: true,+ externalRecordingId: true,+ botScheduleAttemptedAt: true,+ botScheduleIdempotencyKey: true,+ callRecorderFailureReason: true,+ startedAt: true,+ endedAt: true,+ },+ },+ },+ });++ return (result.callRecordings?.edges ?? []).map(+ (edge: any) => edge.node,+ );+ };++ const fetchCallRecording = async (+ callRecordingId: string,+ ): Promise<Record<string, any>> => {+ const callRecording = (+ await findCallRecordings({ id: { eq: callRecordingId } })+ )[0];++ expect(callRecording).toBeDefined();++ return callRecording;+ };++ // Mocked database-event trigger: runs the reconciliation the+ // calendarEvent.* trigger dispatches, then returns the recording it wrote+ // to the DB together with its live Recall bot.+ const scheduleRecordingThroughCalendarReconciliation = async (): Promise<{+ calendarEventId: string;+ callRecordingId: string;+ botId: string;+ metadata: Record<string, string>;+ }> => {+ const calendarEventId = await createCalendarEvent();++ await reconcileCallRecorderForCalendarEventIds({+ client,+ calendarEventIds: [calendarEventId],+ });++ const callRecording = (+ await findCallRecordings({ calendarEventId: { in: [calendarEventId] } })+ )[0];++ expect(callRecording).toBeDefined();+ expect(callRecording.externalBotId).toBeTruthy();++ return {+ calendarEventId,+ callRecordingId: callRecording.id,+ botId: callRecording.externalBotId,+ metadata: buildBotMetadata(callRecording.id, workspaceId),+ };+ };++ // Mocked webhook trigger: invokes the webhook logic function handler with+ // the payload Recall would have delivered.+ const deliverRecallWebhook = (body: object) =>+ processRecallWebhookHandler(body);++ // Mocked cron trigger: runs the flows the recovery cron dispatches.+ const runPendingRecoveryCron = () =>+ scheduleRecallBotsForPendingCallRecordings({ client, now: new Date() });+ const runCancellationRetryCron = () =>+ retryFailedRecallCancellations({ client, now: new Date() });++ describe('scheduling from calendar changes', () => {+ it('creates a recording and schedules a Recall bot for a meeting with recording enabled', async () => {+ const { callRecordingId, botId } =+ await scheduleRecordingThroughCalendarReconciliation();++ const callRecording = await fetchCallRecording(callRecordingId);++ expect(callRecording.status).toBe('SCHEDULED');+ expect(callRecording.recordingRequestStatus).toBe('REQUESTED');+ expect(callRecording.botScheduleAttemptedAt).toBeTruthy();+ expect(callRecording.botScheduleIdempotencyKey).toBeTruthy();+ expect(recall.bots.get(botId)?.metadata).toEqual(+ buildBotMetadata(callRecordingId, workspaceId),+ );+ });++ it('creates nothing for a meeting without a conference link', async () => {+ const calendarEventId = await createCalendarEvent({+ conferenceLink: { primaryLinkUrl: '' },+ });++ await reconcileCallRecorderForCalendarEventIds({+ client,+ calendarEventIds: [calendarEventId],+ });++ expect(+ await findCallRecordings({ calendarEventId: { in: [calendarEventId] } }),+ ).toEqual([]);+ });+ });++ describe('Recall webhook lifecycle', () => {+ it('moves the recording through joining, recording, and processing', async () => {+ const { callRecordingId, botId, metadata } =+ await scheduleRecordingThroughCalendarReconciliation();++ await deliverRecallWebhook(+ buildBotStatusChangeWebhook({+ botId,+ metadata,+ statusCode: 'joining_call',+ }),+ );+ expect((await fetchCallRecording(callRecordingId)).status).toBe(+ 'JOINING',+ );++ const recordingStartedAt = new Date().toISOString();++ await deliverRecallWebhook(+ buildBotStatusChangeWebhook({+ botId,+ metadata,+ statusCode: 'in_call_recording',+ statusTimestamp: recordingStartedAt,+ }),+ );+ const recordingCallRecording = await fetchCallRecording(callRecordingId);++ expect(recordingCallRecording.status).toBe('RECORDING');+ expect(recordingCallRecording.startedAt).toBeTruthy();++ const recordingEndedAt = new Date().toISOString();++ await deliverRecallWebhook(+ buildRecordingDoneWebhook({+ botId,+ metadata,+ startedAt: recordingStartedAt,+ completedAt: recordingEndedAt,+ }),+ );+ const processedCallRecording = await fetchCallRecording(callRecordingId);++ expect(processedCallRecording.status).toBe('PROCESSING');+ expect(processedCallRecording.externalRecordingId).toBe(+ 'recall-recording-1',+ );+ expect(processedCallRecording.endedAt).toBeTruthy();+ // recording.done hands media and transcript work to the artifact+ // import route.+ expect(recall.artifactImportRequests).toHaveLength(1);+ expect(recall.artifactImportRequests[0]).toMatchObject({+ callRecordingId,+ });+ });++ it('queues another artifact import when the transcript finishes later', async () => {+ const { callRecordingId, botId, metadata } =+ await scheduleRecordingThroughCalendarReconciliation();++ await deliverRecallWebhook(+ buildRecordingDoneWebhook({+ botId,+ metadata,+ startedAt: new Date().toISOString(),+ completedAt: new Date().toISOString(),+ }),+ );+ await deliverRecallWebhook(+ buildTranscriptDoneWebhook({ botId, metadata }),+ );++ expect(recall.artifactImportRequests).toHaveLength(2);+ expect(recall.artifactImportRequests[1]).toMatchObject({+ callRecordingId,+ });+ });++ it('never moves the status backwards on late webhook deliveries', async () => {+ const { callRecordingId, botId, metadata } =+ await scheduleRecordingThroughCalendarReconciliation();++ await deliverRecallWebhook(+ buildRecordingDoneWebhook({+ botId,+ metadata,+ startedAt: new Date().toISOString(),+ completedAt: new Date().toISOString(),+ }),+ );++ const lateJoiningResult = await deliverRecallWebhook(+ buildBotStatusChangeWebhook({+ botId,+ metadata,+ statusCode: 'joining_call',+ }),+ );++ expect(lateJoiningResult.status).toBe('skipped');+ expect((await fetchCallRecording(callRecordingId)).status).toBe(+ 'PROCESSING',+ );+ });++ it('marks the recording failed when the bot dies fatally', async () => {+ const { callRecordingId, botId, metadata } =+ await scheduleRecordingThroughCalendarReconciliation();++ await deliverRecallWebhook(+ buildBotStatusChangeWebhook({ botId, metadata, statusCode: 'fatal' }),+ );++ const callRecording = await fetchCallRecording(callRecordingId);++ expect(callRecording.status).toBe('FAILED');+ expect(callRecording.callRecorderFailureReason).toBe('fatal');+ });++ it('ignores webhooks that match no known recording', async () => {+ const { callRecordingId } =+ await scheduleRecordingThroughCalendarReconciliation();++ const result = await deliverRecallWebhook(+ buildBotStatusChangeWebhook({+ botId: 'recall-bot-from-another-app',+ metadata: buildBotMetadata(randomUUID(), workspaceId),+ statusCode: 'joining_call',+ }),+ );++ expect(result.status).toBe('skipped');+ expect((await fetchCallRecording(callRecordingId)).status).toBe(+ 'SCHEDULED',+ );+ });+ });++ describe('cancellation', () => {+ it('cancels the request and deletes the Recall bot', async () => {+ const { callRecordingId, botId } =+ await scheduleRecordingThroughCalendarReconciliation();++ await cancelCallRecordingRequest({+ client,+ callRecording: { id: callRecordingId, externalBotId: botId },+ });++ const callRecording = await fetchCallRecording(callRecordingId);++ expect(callRecording.recordingRequestStatus).toBe('CANCELED');+ // The API stores a cleared TEXT field as an empty string.+ expect(callRecording.externalBotId).toBeFalsy();+ expect(recall.deletedBotIds).toEqual([botId]);+ });++ it('retries a failed Recall cancellation on the next cron run', async () => {+ const { callRecordingId, botId } =+ await scheduleRecordingThroughCalendarReconciliation();++ recall.failNextDelete = true;+ await cancelCallRecordingRequest({+ client,+ callRecording: { id: callRecordingId, externalBotId: botId },+ });++ // The Recall half failed, so the bot id must survive for the retry.+ expect((await fetchCallRecording(callRecordingId)).externalBotId).toBe(+ botId,+ );++ await runCancellationRetryCron();++ expect(+ (await fetchCallRecording(callRecordingId)).externalBotId,+ ).toBeFalsy();+ expect(recall.deletedBotIds).toContain(botId);+ });+ });++ describe('crash recovery cron', () => {+ it('schedules a bot for a recording created without one, with zero Recall list reads', async () => {+ const calendarEventId = await createCalendarEvent();+ const callRecordingId = await createPendingCallRecording({+ calendarEventId,+ });++ await runPendingRecoveryCron();++ const callRecording = await fetchCallRecording(callRecordingId);++ expect(callRecording.externalBotId).toBeTruthy();+ expect(recall.botForCallRecording(callRecordingId)?.id).toBe(+ callRecording.externalBotId,+ );+ expect(recall.listRequestCount).toBe(0);+ });++ it('re-sends the creation after a lost write-back and lands on the same bot', async () => {+ const calendarEventId = await createCalendarEvent();+ const callRecordingId = await createPendingCallRecording({+ calendarEventId,+ });++ // First recovery run creates the bot and records the attempt.+ await runPendingRecoveryCron();+ const firstBotId = (await fetchCallRecording(callRecordingId))+ .externalBotId;++ // Simulate the id write-back getting lost after the POST reached+ // Recall.+ await client.mutation({+ updateCallRecording: {+ __args: { id: callRecordingId, data: { externalBotId: null } },+ id: true,+ },+ });++ await runPendingRecoveryCron();++ // Recall dedupes the repeated idempotency key: the very same bot is+ // written back, without any list request.+ expect((await fetchCallRecording(callRecordingId)).externalBotId).toBe(+ firstBotId,+ );+ expect(recall.listRequestCount).toBe(0);+ });++ it('attaches an existing bot found by lookup when the recorded attempt drifted', async () => {+ const calendarEventId = await createCalendarEvent();+ const callRecordingId = await createPendingCallRecording({+ calendarEventId,+ botScheduleAttemptedAt: hoursAgo(1),+ botScheduleIdempotencyKey: 'key-from-before-the-meeting-moved',+ });++ recall.seedBot({+ id: 'recall-bot-from-crashed-run',+ metadata: buildBotMetadata(callRecordingId, workspaceId),+ statusCode: 'ready',+ });++ await runPendingRecoveryCron();++ expect((await fetchCallRecording(callRecordingId)).externalBotId).toBe(+ 'recall-bot-from-crashed-run',+ );+ expect(recall.listRequestCount).toBe(1);+ });++ it('fails a recording whose meeting ended before any bot creation was attempted', async () => {+ const calendarEventId = await createCalendarEvent({+ startsAt: hoursAgo(3),+ endsAt: hoursAgo(2),+ });+ const callRecordingId = await createPendingCallRecording({+ calendarEventId,+ });++ await runPendingRecoveryCron();++ const callRecording = await fetchCallRecording(callRecordingId);++ expect(callRecording.status).toBe('FAILED');+ expect(callRecording.callRecorderFailureReason).toBe(+ 'bot_never_scheduled',+ );+ expect(recall.botForCallRecording(callRecordingId)).toBeUndefined();+ });+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/constants/bot-schedule-attempted-at-field-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/bot-schedule-attempted-at-field-universal-identifier.tsnew file mode 100644index 00000000000..0fc768d532c--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/bot-schedule-attempted-at-field-universal-identifier.ts@@ -0,0 +1,2 @@+export const BOT_SCHEDULE_ATTEMPTED_AT_FIELD_UNIVERSAL_IDENTIFIER =+ 'ca1d0179-f611-46bd-ba8a-b503ea9d024e';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/bot-schedule-idempotency-key-field-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/bot-schedule-idempotency-key-field-universal-identifier.tsnew file mode 100644index 00000000000..a1e694e897f--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/bot-schedule-idempotency-key-field-universal-identifier.ts@@ -0,0 +1,2 @@+export const BOT_SCHEDULE_IDEMPOTENCY_KEY_FIELD_UNIVERSAL_IDENTIFIER =+ '6f00ea4d-1c5a-47ac-8c18-baacf5ee7c3f';diff --git a/packages/twenty-apps/public/call-recorder/src/constants/schedule-recall-bot-on-call-recording-update-logic-function-universal-identifier.ts b/packages/twenty-apps/public/call-recorder/src/constants/schedule-recall-bot-on-call-recording-update-logic-function-universal-identifier.tsnew file mode 100644index 00000000000..1ddd4102bd3--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/constants/schedule-recall-bot-on-call-recording-update-logic-function-universal-identifier.ts@@ -0,0 +1,2 @@+export const SCHEDULE_RECALL_BOT_ON_CALL_RECORDING_UPDATE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER =+ 'fad4b1b5-8b6e-48c7-a8c7-3aecae2672c1';diff --git a/packages/twenty-apps/public/call-recorder/src/fields/bot-schedule-attempted-at-on-call-recording.field.ts b/packages/twenty-apps/public/call-recorder/src/fields/bot-schedule-attempted-at-on-call-recording.field.tsnew file mode 100644index 00000000000..4966e968fd7--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/fields/bot-schedule-attempted-at-on-call-recording.field.ts@@ -0,0 +1,21 @@+import {+ defineField,+ FieldType,+ STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS,+} from 'twenty-sdk/define';++import { BOT_SCHEDULE_ATTEMPTED_AT_FIELD_UNIVERSAL_IDENTIFIER } from 'src/constants/bot-schedule-attempted-at-field-universal-identifier';++export default defineField({+ universalIdentifier: BOT_SCHEDULE_ATTEMPTED_AT_FIELD_UNIVERSAL_IDENTIFIER,+ objectUniversalIdentifier:+ STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.callRecording.universalIdentifier,+ type: FieldType.DATE_TIME,+ name: 'botScheduleAttemptedAt',+ label: 'Bot Schedule Attempted At',+ description:+ 'Set right before a Recall bot creation request is sent; recovery uses it to tell rows that never reached Recall from rows whose creation outcome is unknown.',+ icon: 'IconClockPlay',+ isNullable: true,+ isUIEditable: false,+});diff --git a/packages/twenty-apps/public/call-recorder/src/fields/bot-schedule-idempotency-key-on-call-recording.field.ts b/packages/twenty-apps/public/call-recorder/src/fields/bot-schedule-idempotency-key-on-call-recording.field.tsnew file mode 100644index 00000000000..8957d54a48c--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/fields/bot-schedule-idempotency-key-on-call-recording.field.ts@@ -0,0 +1,21 @@+import {+ defineField,+ FieldType,+ STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS,+} from 'twenty-sdk/define';++import { BOT_SCHEDULE_IDEMPOTENCY_KEY_FIELD_UNIVERSAL_IDENTIFIER } from 'src/constants/bot-schedule-idempotency-key-field-universal-identifier';++export default defineField({+ universalIdentifier: BOT_SCHEDULE_IDEMPOTENCY_KEY_FIELD_UNIVERSAL_IDENTIFIER,+ objectUniversalIdentifier:+ STANDARD_OBJECT_UNIVERSAL_IDENTIFIERS.callRecording.universalIdentifier,+ type: FieldType.TEXT,+ name: 'botScheduleIdempotencyKey',+ label: 'Bot Schedule Idempotency Key',+ description:+ 'Idempotency key of the last Recall bot creation attempt; when the scheduling inputs still hash to this key, recovery can safely re-send the creation instead of listing bots.',+ icon: 'IconKey',+ isNullable: true,+ isUIEditable: false,+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/schedule-recall-bot-on-call-recording-update.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/schedule-recall-bot-on-call-recording-update.test.tsnew file mode 100644index 00000000000..d124f075396--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/__tests__/schedule-recall-bot-on-call-recording-update.test.ts@@ -0,0 +1,309 @@+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';++import { scheduleRecallBotOnCallRecordingUpdateHandler } from 'src/logic-functions/schedule-recall-bot-on-call-recording-update';++const queryMock = vi.hoisted(() => vi.fn());+const mutationMock = vi.hoisted(() => vi.fn());++vi.mock('twenty-client-sdk/core', () => ({+ CoreApiClient: class {+ query = queryMock;+ mutation = mutationMock;+ },+}));++const fetchMock = vi.fn();++const NOW = new Date('2026-01-01T12:00:00.000Z');+const WORKSPACE_ID = '123e4567-e89b-12d3-a456-426614174000';+const RECALL_CREATE_BOT_URL = 'https://us-west-2.recall.ai/api/v1/bot/';++const buildAccessToken = (payload: Record<string, unknown>): string =>+ [+ Buffer.from(JSON.stringify({ alg: 'none' })).toString('base64url'),+ Buffer.from(JSON.stringify(payload)).toString('base64url'),+ 'signature',+ ].join('.');++const buildConnection = <Node>(nodes: Node[]) => ({+ pageInfo: { hasNextPage: false, endCursor: undefined },+ edges: nodes.map((node) => ({ node })),+});++type HandlerEvent = Parameters<+ typeof scheduleRecallBotOnCallRecordingUpdateHandler+>[0];++const buildUpdateEvent = (overrides: Partial<HandlerEvent> = {}): HandlerEvent =>+ ({+ name: 'callRecording.updated',+ recordId: 'call-recording-1',+ properties: {+ updatedFields: ['externalBotId'],+ before: {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ externalBotId: 'recall-bot-vanished',+ },+ after: {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ externalBotId: null,+ },+ },+ ...overrides,+ }) as HandlerEvent;++const stubPendingCallRecordingQueries = () => {+ queryMock.mockImplementation(async (query: any) => {+ if (query.callRecordings !== undefined) {+ return {+ callRecordings: buildConnection([+ {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ calendarEventId: 'calendar-event-1',+ externalBotId: null,+ botScheduleAttemptedAt: null,+ },+ ]),+ };+ }++ if (query.calendarEvents !== undefined) {+ return {+ calendarEvents: buildConnection([+ {+ id: 'calendar-event-1',+ startsAt: '2026-01-01T13:00:00.000Z',+ endsAt: '2026-01-01T14:00:00.000Z',+ iCalUid: 'calendar-event-uid',+ conferenceLink: {+ primaryLinkUrl: 'https://meet.example.com/customer-sync',+ },+ },+ ]),+ };+ }++ throw new Error(`Unhandled query: ${JSON.stringify(query)}`);+ });+};++describe('scheduleRecallBotOnCallRecordingUpdateHandler', () => {+ beforeEach(() => {+ vi.useFakeTimers();+ vi.setSystemTime(NOW);+ vi.spyOn(console, 'warn').mockImplementation(() => {});+ vi.stubGlobal('fetch', fetchMock);+ vi.stubEnv('RECALL_API_KEY', 'recall-api-key');+ vi.stubEnv('RECALL_REGION', 'us-west-2');+ vi.stubEnv('CALL_RECORDER_USE_WORKSPACE_LOGO', 'false');+ vi.stubEnv(+ 'TWENTY_APP_ACCESS_TOKEN',+ buildAccessToken({ workspaceId: WORKSPACE_ID }),+ );+ queryMock.mockReset();+ mutationMock.mockReset();+ mutationMock.mockImplementation(async (mutation: any) => ({+ updateCallRecording: { id: mutation.updateCallRecording.__args.id },+ }));+ fetchMock.mockReset();+ fetchMock.mockImplementation(async (requestUrl: string) => {+ if (requestUrl === RECALL_CREATE_BOT_URL) {+ return new Response(JSON.stringify({ id: 'recall-bot-new' }), {+ status: 201,+ });+ }++ throw new Error(`Unhandled fetch in test: ${requestUrl}`);+ });+ });++ afterEach(() => {+ vi.unstubAllGlobals();+ vi.unstubAllEnvs();+ vi.useRealTimers();+ vi.restoreAllMocks();+ });++ it('schedules a bot when an update clears the bot id of a requested recording', async () => {+ stubPendingCallRecordingQueries();++ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent(),+ );++ expect(result).toEqual({+ callRecordingId: 'call-recording-1',+ result: { status: 'scheduled' },+ });+ expect(fetchMock).toHaveBeenCalledTimes(1);+ expect(fetchMock).toHaveBeenCalledWith(+ RECALL_CREATE_BOT_URL,+ expect.objectContaining({ method: 'POST' }),+ );+ });++ it('skips events that are not call recording updates', async () => {+ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent({ name: 'callRecording.created' } as HandlerEvent),+ );++ expect(result).toEqual({+ skipped: true,+ reason: 'not a call recording update',+ });+ expect(queryMock).not.toHaveBeenCalled();+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('skips its own scheduling-progress writes so it cannot re-trigger itself', async () => {+ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent({+ properties: {+ updatedFields: [+ 'botScheduleAttemptedAt',+ 'botScheduleIdempotencyKey',+ ],+ before: {},+ after: {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ externalBotId: null,+ },+ },+ } as unknown as HandlerEvent),+ );++ expect(result).toEqual({+ skipped: true,+ reason: 'no pending-transition field changed',+ });+ expect(queryMock).not.toHaveBeenCalled();+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('skips updates that leave the recording with a bot attached', async () => {+ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent({+ properties: {+ updatedFields: ['externalBotId'],+ before: {},+ after: {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ externalBotId: 'recall-bot-1',+ },+ },+ } as unknown as HandlerEvent),+ );++ expect(result).toEqual({+ skipped: true,+ reason: 'call recording is not pending',+ });+ expect(queryMock).not.toHaveBeenCalled();+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('defers rows with an ambiguous prior attempt to the recovery cron instead of listing bots', async () => {+ queryMock.mockImplementationOnce(async () => ({+ callRecordings: buildConnection([+ {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ calendarEventId: 'calendar-event-1',+ externalBotId: null,+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ botScheduleIdempotencyKey: 'stale-key-from-moved-meeting',+ },+ ]),+ }));+ queryMock.mockImplementationOnce(async () => ({+ calendarEvents: buildConnection([+ {+ id: 'calendar-event-1',+ startsAt: '2026-01-01T13:00:00.000Z',+ endsAt: '2026-01-01T14:00:00.000Z',+ conferenceLink: {+ primaryLinkUrl: 'https://meet.example.com/customer-sync',+ },+ },+ ]),+ }));++ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent(),+ );++ expect(result).toEqual({+ callRecordingId: 'call-recording-1',+ result: {+ status: 'deferred',+ reason: 'ambiguous prior attempt; the recovery cron will reconcile it',+ },+ });+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('skips slim payloads whose diff shows the bot id was written back', async () => {+ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent({+ properties: {+ updatedFields: ['externalBotId'],+ diff: {+ externalBotId: { before: null, after: 'recall-bot-1' },+ },+ },+ } as unknown as HandlerEvent),+ );++ expect(result).toEqual({+ skipped: true,+ reason: 'call recording is not pending',+ });+ expect(queryMock).not.toHaveBeenCalled();+ expect(fetchMock).not.toHaveBeenCalled();+ });++ it('does not schedule anything when the meeting already ended', async () => {+ stubPendingCallRecordingQueries();+ queryMock.mockImplementationOnce(async () => ({+ callRecordings: buildConnection([+ {+ id: 'call-recording-1',+ status: 'SCHEDULED',+ recordingRequestStatus: 'REQUESTED',+ calendarEventId: 'calendar-event-1',+ externalBotId: null,+ },+ ]),+ }));+ queryMock.mockImplementationOnce(async () => ({+ calendarEvents: buildConnection([+ {+ id: 'calendar-event-1',+ startsAt: '2026-01-01T10:00:00.000Z',+ endsAt: '2026-01-01T11:00:00.000Z',+ },+ ]),+ }));++ const result = await scheduleRecallBotOnCallRecordingUpdateHandler(+ buildUpdateEvent(),+ );++ expect(result).toEqual({+ callRecordingId: 'call-recording-1',+ result: { status: 'skipped', reason: 'meeting already ended' },+ });+ expect(fetchMock).not.toHaveBeenCalled();+ });+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/active-recall-bot-statuses.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/active-recall-bot-statuses.tsnew file mode 100644index 00000000000..d0c5c25dd88--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/active-recall-bot-statuses.ts@@ -0,0 +1,9 @@+export const ACTIVE_RECALL_BOT_STATUSES = [+ 'ready',+ 'joining_call',+ 'in_waiting_room',+ 'in_call_not_recording',+ 'recording_permission_allowed',+ 'recording_permission_denied',+ 'in_call_recording',+];diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/pending-call-recording-requests-cron-pattern.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/pending-call-recording-requests-cron-pattern.tsindex 0e6bdcafa79..95018c8c6b8 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/pending-call-recording-requests-cron-pattern.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/constants/pending-call-recording-requests-cron-pattern.ts@@ -1 +1,3 @@-export const PENDING_CALL_RECORDING_REQUESTS_CRON_PATTERN = '*/5 * * * *';+// The callRecording.updated trigger resumes most stuck rows within seconds;+// this cron is the backstop for crashed creations and missed events.+export const PENDING_CALL_RECORDING_REQUESTS_CRON_PATTERN = '*/15 * * * *';diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/find-call-recordings-by-filter.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/find-call-recordings-by-filter.util.tsindex 799b2a75cbd..a44e14c3135 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/data/find-call-recordings-by-filter.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/data/find-call-recordings-by-filter.util.ts@@ -21,6 +21,8 @@ type CallRecordingNode = {endedAt?: string | null;calendarEventId?: string | null;externalBotId?: string | null;+ botScheduleAttemptedAt?: string | null;+ botScheduleIdempotencyKey?: string | null;externalRecordingId?: string | null;callRecorderFailureReason?: string | null;};@@ -54,6 +56,8 @@ export const findCallRecordingsByFilter = async (endedAt: true,calendarEventId: true,externalBotId: true,+ botScheduleAttemptedAt: true,+ botScheduleIdempotencyKey: true,externalRecordingId: true,callRecorderFailureReason: true,},@@ -80,6 +84,12 @@ export const findCallRecordingsByFilter = async (endedAt: callRecording.endedAt ?? undefined,calendarEventId: callRecording.calendarEventId ?? undefined,externalBotId: normalizeOptionalString(callRecording.externalBotId),+ botScheduleAttemptedAt: normalizeOptionalString(+ callRecording.botScheduleAttemptedAt,+ ),+ botScheduleIdempotencyKey: normalizeOptionalString(+ callRecording.botScheduleIdempotencyKey,+ ),externalRecordingId: normalizeOptionalString(callRecording.externalRecordingId,),diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/can-reschedule-call-recording-without-recall-lookup.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/can-reschedule-call-recording-without-recall-lookup.util.tsnew file mode 100644index 00000000000..989fa646687--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/can-reschedule-call-recording-without-recall-lookup.util.ts@@ -0,0 +1,54 @@+import { isUndefined } from '@sniptt/guards';++import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';+import { hasUnchangedBotScheduleIdempotencyKey } from 'src/logic-functions/domain/has-unchanged-bot-schedule-idempotency-key.util';++// Recall does not document how long idempotency keys are retained (24h is+// the industry minimum), so re-sends are only trusted while the recorded+// attempt is clearly fresh; a stale key would create a twin bot instead of+// deduping. Recovery normally runs within minutes of the attempt.+const IDEMPOTENT_RESEND_WINDOW_HOURS = 12;++// Rows without a schedule-attempt marker never reached Recall, so no bot can+// exist for them. Rows whose stored idempotency key still matches the current+// scheduling inputs can re-send the creation and let Recall dedupe it.+export const canRescheduleCallRecordingWithoutRecallLookup = ({+ callRecording,+ calendarEvent,+ workspaceId,+ now,+}: {+ callRecording: CallRecordingRecord;+ calendarEvent: CalendarEventRecord;+ workspaceId: string | undefined;+ now: Date;+}): boolean =>+ isUndefined(callRecording.botScheduleAttemptedAt) ||+ (isWithinIdempotentResendWindow(callRecording.botScheduleAttemptedAt, now) &&+ !isUndefined(workspaceId) &&+ hasUnchangedBotScheduleIdempotencyKey({+ callRecording,+ calendarEvent,+ workspaceId,+ }));++const isWithinIdempotentResendWindow = (+ botScheduleAttemptedAt: string,+ now: Date,+): boolean => {+ const attemptedTime = new Date(botScheduleAttemptedAt).getTime();++ if (Number.isNaN(attemptedTime)) {+ return false;+ }++ const elapsedMilliseconds = now.getTime() - attemptedTime;++ // A future timestamp means clock skew or corrupt data; treat it as+ // untrustworthy rather than fresh.+ return (+ elapsedMilliseconds >= 0 &&+ elapsedMilliseconds < IDEMPOTENT_RESEND_WINDOW_HOURS * 60 * 60 * 1000+ );+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/has-unchanged-bot-schedule-idempotency-key.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/has-unchanged-bot-schedule-idempotency-key.util.tsnew file mode 100644index 00000000000..0314cb973ab--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/domain/has-unchanged-bot-schedule-idempotency-key.util.ts@@ -0,0 +1,45 @@+import { isUndefined } from '@sniptt/guards';++import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.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 { computeRecallBotCreationIdempotencyKey } from 'src/logic-functions/recall-api/schedule-recall-bot.util';++// True when re-sending the bot creation would carry the same idempotency key+// as the recorded attempt, so Recall dedupes it instead of creating a twin.+// A moved meeting, changed conference link, or changed join-early setting+// drifts the key and recovery must fall back to a bot lookup.+export const hasUnchangedBotScheduleIdempotencyKey = ({+ callRecording,+ calendarEvent,+ workspaceId,+}: {+ callRecording: CallRecordingRecord;+ calendarEvent: CalendarEventRecord;+ workspaceId: string;+}): boolean => {+ const storedIdempotencyKey = callRecording.botScheduleIdempotencyKey;+ const meetingUrl = calendarEvent.conferenceLinkUrl;+ const meetingStartsAt = calendarEvent.startsAt;++ if (+ isUndefined(storedIdempotencyKey) ||+ isUndefined(meetingUrl) ||+ isUndefined(meetingStartsAt)+ ) {+ return false;+ }++ return (+ storedIdempotencyKey ===+ computeRecallBotCreationIdempotencyKey({+ meetingUrl,+ joinAt: computeRecallBotJoinAt(meetingStartsAt),+ metadata: buildRecallRoutingMetadata({+ callRecordingId: callRecording.id,+ workspaceId,+ }),+ })+ );+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.tsindex ecdd91004a3..a07a6e848f8 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/reconcile-call-recorder.test.ts@@ -281,6 +281,8 @@ describe('reconcileCallRecorderForCalendarEventIds', () => {recordingRequestStatus: 'REQUESTED',calendarEventId: 'calendar-event-1',externalBotId: 'recall-bot-1',+ botScheduleAttemptedAt: NOW.toISOString(),+ botScheduleIdempotencyKey: expect.any(String),},]);expect(recallBotCreateCalls()).toHaveLength(1);diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/retry-failed-recall-cancellations.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/retry-failed-recall-cancellations.test.tsindex 4eb0ad7edf9..04bf0f26236 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/retry-failed-recall-cancellations.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/retry-failed-recall-cancellations.test.ts@@ -304,8 +304,8 @@ describe('retryFailedRecallCancellations', () => {expect(listRequestParameters.get('metadata__twentyWorkspaceId')).toBe(WORKSPACE_ID,);- expect(listRequestParameters.get('metadata__twentyCallRecordingId')).toBe(- 'call-recording-1',+ expect(listRequestParameters.has('metadata__twentyCallRecordingId')).toBe(+ false,);expect(fetchMock).toHaveBeenCalledWith(`${BASE_URL}/bot/recall-bot-recovered/`,@@ -338,7 +338,15 @@ describe('retryFailedRecallCancellations', () => {...buildJsonResponse(200),json: async () => ({next: null,- results: [{ id: 'recall-bot-recovered' }],+ results: [+ {+ id: 'recall-bot-recovered',+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ },+ ],}),}).mockResolvedValueOnce(buildJsonResponse(400))@@ -422,7 +430,15 @@ describe('retryFailedRecallCancellations', () => {...buildJsonResponse(200),json: async () => ({next: null,- results: [{ id: 'recall-bot-recovered' }],+ results: [+ {+ id: 'recall-bot-recovered',+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ },+ ],}),};}@@ -467,7 +483,15 @@ describe('retryFailedRecallCancellations', () => {...buildJsonResponse(200),json: async () => ({next: null,- results: [{ id: 'recall-bot-recovered' }],+ results: [+ {+ id: 'recall-bot-recovered',+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ },+ ],}),};}@@ -490,6 +514,74 @@ describe('retryFailedRecallCancellations', () => {]);});+ it('does not claim a listed bot for a cancellation whose recovery window elapsed', async () => {+ const client = new FakeCoreApiClient([+ {+ id: 'call-recording-recent',+ recordingRequestStatus: 'CANCELED',+ status: 'SCHEDULED',+ createdAt: '2026-01-02T11:30:00.000Z',+ calendarEventId: null,+ externalBotId: null,+ },+ {+ id: 'call-recording-aged',+ recordingRequestStatus: 'CANCELED',+ status: 'SCHEDULED',+ createdAt: '2026-01-01T11:00:00.000Z',+ calendarEventId: null,+ externalBotId: null,+ },+ ]);+ fetchMock.mockImplementation(+ async (requestUrl: string, requestInit?: { method?: string }) => {+ if (requestInit?.method === 'DELETE') {+ return buildJsonResponse(204);+ }++ if (requestUrl.startsWith(`${BASE_URL}/bot/?`)) {+ return {+ ...buildJsonResponse(200),+ json: async () => ({+ next: null,+ results: [+ {+ id: 'recall-bot-recent',+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-recent',+ },+ },+ {+ id: 'recall-bot-aged',+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-aged',+ },+ },+ ],+ }),+ };+ }++ throw new Error(`Unhandled fetch: ${requestUrl}`);+ },+ );++ const result = await retryFailedRecallCancellations({+ client: client as unknown as CoreApiClient,+ now: new Date('2026-01-02T12:00:00.000Z'),+ });++ expect(result.canceledExternalBotCallRecordingIds).toEqual([+ 'call-recording-recent',+ ]);+ expect(fetchMock).not.toHaveBeenCalledWith(+ `${BASE_URL}/bot/recall-bot-aged/`,+ expect.objectContaining({ method: 'DELETE' }),+ );+ });+it('does not repeatedly look up botless cancellations after their meeting ended', async () => {const client = new FakeCoreApiClient([diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/schedule-recall-bots-for-pending-call-recordings.test.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/schedule-recall-bots-for-pending-call-recordings.test.tsindex a21626bbdb3..86a57da5879 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/schedule-recall-bots-for-pending-call-recordings.test.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/__tests__/schedule-recall-bots-for-pending-call-recordings.test.ts@@ -1,7 +1,9 @@import { type CoreApiClient } from 'twenty-client-sdk/core';import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';+import { computeRecallBotJoinAt } from 'src/logic-functions/domain/compute-recall-bot-join-at.util';import { scheduleRecallBotsForPendingCallRecordings } from 'src/logic-functions/flows/schedule-recall-bots-for-pending-call-recordings.util';+import { computeRecallBotCreationIdempotencyKey } from 'src/logic-functions/recall-api/schedule-recall-bot.util';const NOW = new Date('2026-01-01T12:00:00.000Z');const WORKSPACE_ID = '123e4567-e89b-12d3-a456-426614174000';@@ -28,6 +30,9 @@ type CallRecordingNode = {recordingRequestStatus?: string | null;calendarEventId?: string | null;externalBotId?: string | null;+ botScheduleAttemptedAt?: string | null;+ botScheduleIdempotencyKey?: string | null;+ callRecorderFailureReason?: string | null;};type CalendarEventNode = {@@ -216,6 +221,11 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {expect(result.scheduledCallRecordingIds).toEqual(['call-recording-1']);expect(result.attachedCallRecordingIds).toEqual([]);+ // A row that never attempted a bot creation needs no Recall lookup.+ expect(listBotRequestUrls()).toHaveLength(0);+ expect(client.callRecordings[0].botScheduleAttemptedAt).toBe(+ NOW.toISOString(),+ );expect(createBotCalls()).toHaveLength(1);const [requestUrl, requestInit] = createBotCalls()[0];expect(requestUrl).toBe(RECALL_CREATE_BOT_URL);@@ -246,7 +256,11 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {],});const client = new FakeCoreApiClient({- callRecordings: [buildPendingCallRecording()],+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ }),+ ],calendarEvents: [buildCalendarEvent()],});@@ -262,8 +276,8 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {expect(lookupParameters.get('metadata__twentyWorkspaceId')).toBe(WORKSPACE_ID,);- expect(lookupParameters.get('metadata__twentyCallRecordingId')).toBe(- 'call-recording-1',+ expect(lookupParameters.has('metadata__twentyCallRecordingId')).toBe(+ false,);expect(lookupParameters.has('join_at_after')).toBe(false);expect(lookupParameters.has('join_at_before')).toBe(false);@@ -279,10 +293,54 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {expect(client.callRecordings[0].externalBotId).toBe('recall-bot-existing');});+ it('looks up existing bots once for the whole run instead of per recording', async () => {+ stubRecallApi({+ listedBots: [+ {+ id: 'recall-bot-existing',+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ },+ ],+ });+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ }),+ buildPendingCallRecording({+ id: 'call-recording-2',+ calendarEventId: 'calendar-event-2',+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ }),+ ],+ calendarEvents: [+ buildCalendarEvent(),+ buildCalendarEvent({ id: 'calendar-event-2' }),+ ],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(listBotRequestUrls()).toHaveLength(1);+ expect(result.attachedCallRecordingIds).toEqual(['call-recording-1']);+ expect(result.scheduledCallRecordingIds).toEqual(['call-recording-2']);+ expect(createBotCalls()).toHaveLength(1);+ });+it('defers scheduling when the existing-bot lookup fails so no duplicate bot is created', async () => {stubRecallApi({ listStatus: 400 });const client = new FakeCoreApiClient({- callRecordings: [buildPendingCallRecording()],+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ }),+ ],calendarEvents: [buildCalendarEvent()],});@@ -297,6 +355,121 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {expect(client.callRecordings[0].externalBotId).toBeNull();});+ it('re-sends the creation without any Recall lookup when the stored idempotency key still matches', async () => {+ const unchangedIdempotencyKey = computeRecallBotCreationIdempotencyKey({+ meetingUrl: 'https://meet.example.com/customer-sync',+ joinAt: computeRecallBotJoinAt(UPCOMING_STARTS_AT),+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ });+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ botScheduleIdempotencyKey: unchangedIdempotencyKey,+ }),+ ],+ calendarEvents: [buildCalendarEvent()],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(listBotRequestUrls()).toHaveLength(0);+ expect(result.scheduledCallRecordingIds).toEqual(['call-recording-1']);+ const [, requestInit] = createBotCalls()[0];+ expect(requestInit.headers).toMatchObject({+ 'Idempotency-Key': unchangedIdempotencyKey,+ });+ expect(client.callRecordings[0].externalBotId).toBe('recall-bot-1');+ // The first attempt timestamp survives the re-send so repeated unknown+ // outcomes age out of the resend window.+ expect(client.callRecordings[0].botScheduleAttemptedAt).toBe(+ '2026-01-01T11:55:00.000Z',+ );+ });++ it('falls back to the Recall lookup when the recorded attempt is too old to trust its idempotency key', async () => {+ const unchangedIdempotencyKey = computeRecallBotCreationIdempotencyKey({+ meetingUrl: 'https://meet.example.com/customer-sync',+ joinAt: computeRecallBotJoinAt(UPCOMING_STARTS_AT),+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ });+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2025-12-30T12:00:00.000Z',+ botScheduleIdempotencyKey: unchangedIdempotencyKey,+ }),+ ],+ calendarEvents: [buildCalendarEvent()],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(listBotRequestUrls()).toHaveLength(1);+ expect(result.scheduledCallRecordingIds).toEqual(['call-recording-1']);+ });++ it('falls back to the Recall lookup when the meeting moved since the recorded attempt', async () => {+ const staleIdempotencyKey = computeRecallBotCreationIdempotencyKey({+ meetingUrl: 'https://meet.example.com/customer-sync',+ joinAt: computeRecallBotJoinAt('2026-01-01T09:00:00.000Z'),+ metadata: {+ twentyWorkspaceId: WORKSPACE_ID,+ twentyCallRecordingId: 'call-recording-1',+ },+ });+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ botScheduleIdempotencyKey: staleIdempotencyKey,+ }),+ ],+ calendarEvents: [buildCalendarEvent()],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(listBotRequestUrls()).toHaveLength(1);+ expect(result.scheduledCallRecordingIds).toEqual(['call-recording-1']);+ });++ it('re-schedules an ambiguous recording when the lookup confirms no bot exists', async () => {+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T11:55:00.000Z',+ }),+ ],+ calendarEvents: [buildCalendarEvent()],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(listBotRequestUrls()).toHaveLength(1);+ expect(result.scheduledCallRecordingIds).toEqual(['call-recording-1']);+ expect(createBotCalls()).toHaveLength(1);+ expect(client.callRecordings[0].externalBotId).toBe('recall-bot-1');+ });+it('does not report a recording as scheduled when Recall scheduling fails', async () => {stubRecallApi({ createBotStatus: 500 });const client = new FakeCoreApiClient({@@ -318,7 +491,7 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {expect(client.callRecordings[0].externalBotId).toBeNull();});- it('skips a recording whose meeting has already ended', async () => {+ it('marks a recording failed when its meeting ended before any bot was scheduled', async () => {const client = new FakeCoreApiClient({callRecordings: [buildPendingCallRecording()],calendarEvents: [@@ -335,7 +508,81 @@ describe('scheduleRecallBotsForPendingCallRecordings', () => {});expect(result.scheduledCallRecordingIds).toEqual([]);+ expect(result.markedFailedCallRecordingIds).toEqual(['call-recording-1']);+ expect(fetchMock).not.toHaveBeenCalled();+ expect(client.callRecordings[0].status).toBe('FAILED');+ expect(client.callRecordings[0].callRecorderFailureReason).toBe(+ 'bot_never_scheduled',+ );+ });++ it('keeps an ended recording with an unresolved attempt pending while convergence may still resolve it', async () => {+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2026-01-01T09:55:00.000Z',+ }),+ ],+ calendarEvents: [+ buildCalendarEvent({+ startsAt: PAST_STARTS_AT,+ endsAt: PAST_ENDS_AT,+ }),+ ],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(result.markedFailedCallRecordingIds).toEqual([]);+ expect(fetchMock).not.toHaveBeenCalled();+ expect(client.callRecordings[0].status).toBe('SCHEDULED');+ });++ it('fails an ended recording with an unresolved attempt once the convergence lookback has passed', async () => {+ const client = new FakeCoreApiClient({+ callRecordings: [+ buildPendingCallRecording({+ botScheduleAttemptedAt: '2025-12-20T09:55:00.000Z',+ }),+ ],+ calendarEvents: [+ buildCalendarEvent({+ startsAt: '2025-12-20T10:00:00.000Z',+ endsAt: '2025-12-20T11:00:00.000Z',+ }),+ ],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(result.markedFailedCallRecordingIds).toEqual(['call-recording-1']);+ expect(fetchMock).not.toHaveBeenCalled();+ expect(client.callRecordings[0].status).toBe('FAILED');+ expect(client.callRecordings[0].callRecorderFailureReason).toBe(+ 'bot_schedule_outcome_unknown',+ );+ });++ it('leaves a recording untouched when its calendar event is missing', async () => {+ const client = new FakeCoreApiClient({+ callRecordings: [buildPendingCallRecording()],+ calendarEvents: [],+ });++ const result = await scheduleRecallBotsForPendingCallRecordings({+ client: client as unknown as CoreApiClient,+ now: NOW,+ });++ expect(result.markedFailedCallRecordingIds).toEqual([]);expect(fetchMock).not.toHaveBeenCalled();+ expect(client.callRecordings[0].status).toBe('SCHEDULED');});it('does nothing when every scheduled recording already has a bot', async () => {diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/attach-existing-recall-bot-to-call-recording.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/attach-existing-recall-bot-to-call-recording.util.tsdeleted file mode 100644index 4e628d956ac..00000000000--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/attach-existing-recall-bot-to-call-recording.util.ts+++ /dev/null@@ -1,44 +0,0 @@-import { isUndefined } from '@sniptt/guards';-import { type CoreApiClient } from 'twenty-client-sdk/core';--import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';-import { findScheduledRecallBotIdForCallRecording } from 'src/logic-functions/recall-api/find-scheduled-recall-bot-id-for-call-recording.util';-import { getCurrentWorkspaceId } from 'src/logic-functions/data/get-current-workspace-id.util';-import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';--export type AttachExistingRecallBotToCallRecordingResult =- | { status: 'attached'; externalBotId: string }- | { status: 'no-existing-bot' }- | { status: 'lookup-failed' };--// A run that POSTed a bot but died before the id write-back leaves the bot claimable by metadata; attaching it instead of re-POSTing prevents duplicate bots.-export const attachExistingRecallBotToCallRecording = async (- client: CoreApiClient,- { callRecording }: { callRecording: CallRecordingRecord },-): Promise<AttachExistingRecallBotToCallRecordingResult> => {- const workspaceId = getCurrentWorkspaceId();-- if (isUndefined(workspaceId)) {- return { status: 'no-existing-bot' };- }-- const findResult = await findScheduledRecallBotIdForCallRecording({- callRecordingId: callRecording.id,- workspaceId,- });-- if (!findResult.ok) {- return { status: 'lookup-failed' };- }-- if (isUndefined(findResult.externalBotId)) {- return { status: 'no-existing-bot' };- }-- await updateCallRecording(client, {- id: callRecording.id,- data: { externalBotId: findResult.externalBotId },- });-- return { status: 'attached', externalBotId: findResult.externalBotId };-};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reschedule-call-recording-bot.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reschedule-call-recording-bot.util.tsindex 3ec904cf49f..a8134fed1b2 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reschedule-call-recording-bot.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/reschedule-call-recording-bot.util.ts@@ -53,11 +53,18 @@ export const rescheduleCallRecordingBot = async (return;}- // The bot vanished externally; drop the id so the stale-state cron re-creates it as the single writer.+ // The bot vanished externally; drop the id so recovery re-creates it as the+ // single writer. The recorded attempt state is resolved (its bot is+ // confirmed gone), so clearing it lets recovery schedule directly instead+ // of treating the row as an ambiguous attempt.if (rescheduleResult.status === RECALL_BOT_NOT_FOUND_STATUS) {await updateCallRecording(client, {id: callRecording.id,- data: { externalBotId: null },+ data: {+ externalBotId: null,+ botScheduleAttemptedAt: null,+ botScheduleIdempotencyKey: null,+ },});return;diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/resume-pending-call-recording.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/resume-pending-call-recording.util.tsnew file mode 100644index 00000000000..618db44d3a2--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/resume-pending-call-recording.util.ts@@ -0,0 +1,112 @@+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 { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';+import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';+import { canRescheduleCallRecordingWithoutRecallLookup } from 'src/logic-functions/domain/can-reschedule-call-recording-without-recall-lookup.util';+import { fetchCalendarEventsByIds } from 'src/logic-functions/data/fetch-calendar-events-by-ids.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 { hasMeetingEnded } from 'src/logic-functions/domain/has-meeting-ended.util';+import { scheduleRecallBotForCallRecording } from 'src/logic-functions/flows/schedule-recall-bot-for-call-recording.util';++export type ResumePendingCallRecordingResult =+ | { status: 'scheduled' }+ | { status: 'skipped'; reason: string }+ | { status: 'deferred'; reason: string };++// Single-recording variant of the recovery sweep: finishes bot scheduling for+// one row that transitioned back to pending. Deferred outcomes are retried by+// the queue and ultimately by the recovery cron.+export const resumePendingCallRecording = async ({+ client,+ callRecordingId,+ now,+}: {+ client: CoreApiClient;+ callRecordingId: string;+ now: Date;+}): Promise<ResumePendingCallRecordingResult> => {+ const callRecording = (+ await findCallRecordingsByIds(client, [callRecordingId])+ )[0];++ if (isUndefined(callRecording)) {+ return { status: 'skipped', reason: 'call recording not found' };+ }++ if (+ callRecording.recordingRequestStatus !==+ CallRecordingRequestStatus.REQUESTED ||+ callRecording.status !== CallRecordingStatus.SCHEDULED ||+ !isUndefined(callRecording.externalBotId)+ ) {+ return { status: 'skipped', reason: 'call recording is not pending' };+ }++ if (isUndefined(callRecording.calendarEventId)) {+ return { status: 'skipped', reason: 'no calendar event attached' };+ }++ const calendarEvent = (+ await fetchCalendarEventsByIds(client, [callRecording.calendarEventId])+ )[0];++ if (isUndefined(calendarEvent)) {+ return { status: 'skipped', reason: 'calendar event not found' };+ }++ if (+ hasMeetingEnded({+ startsAt: calendarEvent.startsAt,+ endsAt: calendarEvent.endsAt,+ now,+ })+ ) {+ // The recovery cron owns failing rows whose meeting is over.+ return { status: 'skipped', reason: 'meeting already ended' };+ }++ if (+ canRescheduleCallRecordingWithoutRecallLookup({+ callRecording,+ calendarEvent,+ workspaceId: getCurrentWorkspaceId(),+ now,+ })+ ) {+ return scheduleBot({ client, callRecording, calendarEvent });+ }++ // Ambiguous attempts need a Recall bot lookup; doing one per event could+ // burst past the shared list budget, so the recovery cron owns them and+ // amortizes a single lookup across all ambiguous rows.+ return {+ status: 'deferred',+ reason: 'ambiguous prior attempt; the recovery cron will reconcile it',+ };+};++const scheduleBot = async ({+ client,+ callRecording,+ calendarEvent,+}: {+ client: CoreApiClient;+ callRecording: CallRecordingRecord;+ calendarEvent: CalendarEventRecord;+}): Promise<ResumePendingCallRecordingResult> => {+ const didScheduleRecallBot = await scheduleRecallBotForCallRecording(+ client,+ {+ callRecording,+ calendarEvent,+ },+ );++ return didScheduleRecallBot+ ? { status: 'scheduled' }+ : { status: 'deferred', reason: 'Recall bot scheduling failed' };+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/retry-failed-recall-cancellations.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/retry-failed-recall-cancellations.util.tsindex 7451718fcce..b3de1a8b343 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/retry-failed-recall-cancellations.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/retry-failed-recall-cancellations.util.ts@@ -7,10 +7,9 @@ import { NON_TERMINAL_CALL_RECORDING_STATUSES } from 'src/logic-functions/constaimport { fetchCalendarEventsByIds } from 'src/logic-functions/data/fetch-calendar-events-by-ids.util';import { findCallRecordingsByFilter } from 'src/logic-functions/data/find-call-recordings-by-filter.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 { replaceCanceledCallRecordingExternalBotId } from 'src/logic-functions/data/replace-canceled-call-recording-external-bot-id.util';import { cancelOrEjectRecallBot } from 'src/logic-functions/recall-api/cancel-or-eject-recall-bot.util';-import { findScheduledRecallBotIdForCallRecording } from 'src/logic-functions/recall-api/find-scheduled-recall-bot-id-for-call-recording.util';+import { findScheduledRecallBotIdsByCallRecordingId } from 'src/logic-functions/recall-api/find-scheduled-recall-bot-ids-by-call-recording-id.util';import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';import { getUniqueSortedIds } from 'src/logic-functions/utils/get-unique-sorted-ids.util';@@ -49,17 +48,32 @@ export const retryFailedRecallCancellations = async ({)).map((calendarEvent) => [calendarEvent.id, calendarEvent]),);+ const recoverableCallRecordingIds = new Set(+ canceledCallRecordings+ .filter(+ (callRecording) =>+ isUndefined(callRecording.externalBotId) &&+ isWithinCanceledBotRecoveryWindow({+ callRecording,+ calendarEvent: isUndefined(callRecording.calendarEventId)+ ? undefined+ : calendarEventsById.get(callRecording.calendarEventId),+ now,+ }),+ )+ .map((callRecording) => callRecording.id),+ );+ const externalBotIdByCallRecordingId =+ await lookupRecoverableExternalBotIds(recoverableCallRecordingIds);const canceledExternalBotCallRecordingIds: string[] = [];for (const callRecording of canceledCallRecordings) {- const calendarEvent = isUndefined(callRecording.calendarEventId)- ? undefined- : calendarEventsById.get(callRecording.calendarEventId);const externalBotId = await recoverRecallBotIdForCanceledCallRecording({client,callRecording,- calendarEvent,- now,+ listedExternalBotId: recoverableCallRecordingIds.has(callRecording.id)+ ? externalBotIdByCallRecordingId?.get(callRecording.id)+ : undefined,});if (isUndefined(externalBotId)) {@@ -98,21 +112,31 @@ export const retryFailedRecallCancellations = async ({return { canceledExternalBotCallRecordingIds };};-const recoverRecallBotIdForCanceledCallRecording = async ({- client,+// One workspace-wide list request covers every recoverable row; undefined+// means the lookup failed and recovery must wait for the next run.+const lookupRecoverableExternalBotIds = async (+ recoverableCallRecordingIds: Set<string>,+): Promise<Map<string, string> | undefined> => {+ if (recoverableCallRecordingIds.size === 0) {+ return new Map();+ }++ const lookupResult = await findScheduledRecallBotIdsByCallRecordingId();++ return lookupResult.ok+ ? lookupResult.externalBotIdByCallRecordingId+ : undefined;+};++const isWithinCanceledBotRecoveryWindow = ({callRecording,calendarEvent,now,}: {- client: CoreApiClient;callRecording: CallRecordingRecord;calendarEvent: CalendarEventRecord | undefined;now: Date;-}): Promise<string | undefined> => {- if (!isUndefined(callRecording.externalBotId)) {- return callRecording.externalBotId;- }-+}): boolean => {if (!isUndefined(calendarEvent) &&hasMeetingEnded({@@ -122,50 +146,15 @@ const recoverRecallBotIdForCanceledCallRecording = async ({startGraceHours: CANCELED_BOT_RECOVERY_AFTER_START_HOURS,})) {- return undefined;+ return false;}// Recovery only closes the crash window right after cancellation; once a row ages out the daily cleanup sweep owns it, so stop the per-run Recall lookup instead of listing forever (notably for rows whose calendar event was deleted and can no longer bound the retry).// updatedAt tracks the cancellation write, so a request scheduled far ahead but canceled recently still gets its window; createdAt would age it out from scheduling time.- if (- hasCanceledRecoveryWindowElapsed({- canceledAt: callRecording.updatedAt ?? callRecording.createdAt,- now,- })- ) {- return undefined;- }-- const currentWorkspaceId = getCurrentWorkspaceId();-- if (isUndefined(currentWorkspaceId)) {- return undefined;- }-- const scheduledRecallBotLookupResult =- await findScheduledRecallBotIdForCallRecording({- callRecordingId: callRecording.id,- workspaceId: currentWorkspaceId,- });-- if (- !scheduledRecallBotLookupResult.ok ||- isUndefined(scheduledRecallBotLookupResult.externalBotId)- ) {- return undefined;- }-- const externalBotId = scheduledRecallBotLookupResult.externalBotId;- const didClaimRecoveredBot = await replaceCanceledCallRecordingExternalBotId(- client,- {- id: callRecording.id,- expectedExternalBotId: null,- nextExternalBotId: externalBotId,- },- );-- return didClaimRecoveredBot ? externalBotId : undefined;+ return !hasCanceledRecoveryWindowElapsed({+ canceledAt: callRecording.updatedAt ?? callRecording.createdAt,+ now,+ });};const hasCanceledRecoveryWindowElapsed = ({@@ -187,3 +176,32 @@ const hasCanceledRecoveryWindowElapsed = ({now.getTime());};++const recoverRecallBotIdForCanceledCallRecording = async ({+ client,+ callRecording,+ listedExternalBotId,+}: {+ client: CoreApiClient;+ callRecording: CallRecordingRecord;+ listedExternalBotId: string | undefined;+}): Promise<string | undefined> => {+ if (!isUndefined(callRecording.externalBotId)) {+ return callRecording.externalBotId;+ }++ if (isUndefined(listedExternalBotId)) {+ return undefined;+ }++ const didClaimRecoveredBot = await replaceCanceledCallRecordingExternalBotId(+ client,+ {+ id: callRecording.id,+ expectedExternalBotId: null,+ nextExternalBotId: listedExternalBotId,+ },+ );++ return didClaimRecoveredBot ? listedExternalBotId : undefined;+};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bot-for-call-recording.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bot-for-call-recording.util.tsindex 08974ced45b..6719047f7da 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bot-for-call-recording.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bot-for-call-recording.util.ts@@ -2,13 +2,17 @@ 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 { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';import { type MeetingRecording } from 'src/logic-functions/types/meeting-recording.type';import { buildRecallBotAutomaticVideoOutput } from 'src/logic-functions/domain/build-recall-bot-automatic-video-output.util';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 {+ computeRecallBotCreationIdempotencyKey,+ 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.@@ -33,6 +37,7 @@ export const scheduleRecallBotForCallRecording = async (isUndefined(freshCallRecording) ||freshCallRecording.recordingRequestStatus !==CallRecordingRequestStatus.REQUESTED ||+ freshCallRecording.status !== CallRecordingStatus.SCHEDULED ||!isUndefined(freshCallRecording.externalBotId)) {return false;@@ -49,15 +54,42 @@ export const scheduleRecallBotForCallRecording = async (}const automaticVideoOutput = await buildRecallBotAutomaticVideoOutput();+ const metadata = buildRecallRoutingMetadata({+ callRecordingId: callRecording.id,+ workspaceId,+ });+ const idempotencyKey = computeRecallBotCreationIdempotencyKey({+ meetingUrl,+ joinAt,+ metadata,+ });++ // Persisted before the POST so a crash leaves proof that a bot creation may+ // have reached Recall; while the stored key still matches the scheduling+ // inputs, recovery can re-send the creation idempotently instead of asking+ // Recall whether a bot already exists. Re-sends of the same key keep the+ // first attempt's timestamp so repeated unknown outcomes age out of the+ // resend window instead of staying trusted forever.+ const recordedAttemptTimestamp =+ freshCallRecording.botScheduleIdempotencyKey === idempotencyKey+ ? freshCallRecording.botScheduleAttemptedAt+ : undefined;++ await updateCallRecording(client, {+ id: callRecording.id,+ data: {+ botScheduleAttemptedAt:+ recordedAttemptTimestamp ?? new Date().toISOString(),+ botScheduleIdempotencyKey: idempotencyKey,+ },+ });const scheduleResult = await scheduleRecallBot({meetingUrl,joinAt,- metadata: buildRecallRoutingMetadata({- callRecordingId: callRecording.id,- workspaceId,- }),+ metadata,automaticVideoOutput,+ idempotencyKey,});if (!scheduleResult.ok) {diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bots-for-pending-call-recordings.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bots-for-pending-call-recordings.util.tsindex bf2bada651e..6f005ee39ec 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bots-for-pending-call-recordings.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/flows/schedule-recall-bots-for-pending-call-recordings.util.ts@@ -1,16 +1,36 @@import { isUndefined } from '@sniptt/guards';import { type CoreApiClient } from 'twenty-client-sdk/core';+import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';+import { type CalendarEventRecord } from 'src/logic-functions/types/calendar-event-record.type';+import { type CallRecordingRecord } from 'src/logic-functions/types/call-recording-record.type';+import { canRescheduleCallRecordingWithoutRecallLookup } from 'src/logic-functions/domain/can-reschedule-call-recording-without-recall-lookup.util';+import { getCurrentWorkspaceId } from 'src/logic-functions/data/get-current-workspace-id.util';import { hasMeetingEnded } from 'src/logic-functions/domain/has-meeting-ended.util';-import { attachExistingRecallBotToCallRecording } from 'src/logic-functions/flows/attach-existing-recall-bot-to-call-recording.util';import { scheduleRecallBotForCallRecording } from 'src/logic-functions/flows/schedule-recall-bot-for-call-recording.util';import { fetchCalendarEventsByIds } from 'src/logic-functions/data/fetch-calendar-events-by-ids.util';import { findOpenScheduledCallRecordings } from 'src/logic-functions/data/find-open-scheduled-call-recordings.util';+import { findScheduledRecallBotIdsByCallRecordingId } from 'src/logic-functions/recall-api/find-scheduled-recall-bot-ids-by-call-recording-id.util';import { getUniqueSortedIds } from 'src/logic-functions/utils/get-unique-sorted-ids.util';+import { updateCallRecording } from 'src/logic-functions/data/update-call-recording.util';++export const BOT_NEVER_SCHEDULED_FAILURE_REASON = 'bot_never_scheduled';+export const BOT_SCHEDULE_OUTCOME_UNKNOWN_FAILURE_REASON =+ 'bot_schedule_outcome_unknown';++// Mirrors the stale-state convergence lookback: past it no automatic pull+// pass will resolve the row anymore, so keeping it pending only wastes runs.+const UNRESOLVED_ATTEMPT_MAX_AGE_DAYS = 7;export type ScheduleRecallBotsForPendingCallRecordingsResult = {attachedCallRecordingIds: string[];scheduledCallRecordingIds: string[];+ markedFailedCallRecordingIds: string[];+};++type ResumableCallRecording = {+ callRecording: CallRecordingRecord;+ calendarEvent: CalendarEventRecord;};// Resumes a CallRecording inserted before its Recall bot was scheduled.@@ -21,12 +41,17 @@ export const scheduleRecallBotsForPendingCallRecordings = async ({client: CoreApiClient;now: Date;}): Promise<ScheduleRecallBotsForPendingCallRecordingsResult> => {+ const result: ScheduleRecallBotsForPendingCallRecordingsResult = {+ attachedCallRecordingIds: [],+ scheduledCallRecordingIds: [],+ markedFailedCallRecordingIds: [],+ };const pendingCallRecordings = (await findOpenScheduledCallRecordings(client)).filter((callRecording) => isUndefined(callRecording.externalBotId));if (pendingCallRecordings.length === 0) {- return { attachedCallRecordingIds: [], scheduledCallRecordingIds: [] };+ return result;}const calendarEventsById = new Map(@@ -41,51 +66,222 @@ export const scheduleRecallBotsForPendingCallRecordings = async ({)).map((calendarEvent) => [calendarEvent.id, calendarEvent]),);- const attachedCallRecordingIds: string[] = [];- const scheduledCallRecordingIds: string[] = [];+ const resumableCallRecordings: ResumableCallRecording[] = [];for (const callRecording of pendingCallRecordings) {const calendarEvent = isUndefined(callRecording.calendarEventId)? undefined: calendarEventsById.get(callRecording.calendarEventId);+ if (isUndefined(calendarEvent)) {+ continue;+ }+if (- isUndefined(calendarEvent) ||hasMeetingEnded({startsAt: calendarEvent.startsAt,endsAt: calendarEvent.endsAt,now,})) {+ await resolveEndedPendingCallRecording({+ client,+ callRecording,+ calendarEvent,+ now,+ result,+ });continue;}- const attachResult = await attachExistingRecallBotToCallRecording(client, {+ resumableCallRecordings.push({ callRecording, calendarEvent });+ }++ if (resumableCallRecordings.length === 0) {+ return result;+ }++ // Rows without a schedule-attempt marker never reached Recall, so no bot+ // can exist for them. Rows whose stored idempotency key still matches the+ // current scheduling inputs can re-send the creation and let Recall dedupe+ // it. Only attempts whose inputs drifted since the attempt pay for a+ // Recall lookup.+ const workspaceId = getCurrentWorkspaceId();+ const ambiguousCallRecordings = resumableCallRecordings.filter(+ ({ callRecording, calendarEvent }) =>+ !canRescheduleCallRecordingWithoutRecallLookup({+ callRecording,+ calendarEvent,+ workspaceId,+ now,+ }),+ );+ const unambiguousCallRecordings = resumableCallRecordings.filter(+ ({ callRecording, calendarEvent }) =>+ canRescheduleCallRecordingWithoutRecallLookup({+ callRecording,+ calendarEvent,+ workspaceId,+ now,+ }),+ );++ for (const { callRecording, calendarEvent } of unambiguousCallRecordings) {+ await scheduleBotForResumableCallRecording({+ client,callRecording,+ calendarEvent,+ result,});+ }- if (attachResult.status === 'attached') {- attachedCallRecordingIds.push(callRecording.id);- continue;- }+ if (ambiguousCallRecordings.length === 0) {+ return result;+ }- // A failed lookup can hide an existing bot; creating one now could duplicate it, so defer to the next run.- if (attachResult.status === 'lookup-failed') {+ // A run that POSTed a bot but died before the id write-back leaves the bot+ // claimable by metadata; one workspace-wide lookup finds them all without a+ // per-recording list call.+ const lookupResult = await findScheduledRecallBotIdsByCallRecordingId();++ // A failed lookup can hide existing bots; creating one now could duplicate+ // them, so defer to the next run.+ if (!lookupResult.ok) {+ return result;+ }++ for (const { callRecording, calendarEvent } of ambiguousCallRecordings) {+ const existingExternalBotId =+ lookupResult.externalBotIdByCallRecordingId.get(callRecording.id);++ if (!isUndefined(existingExternalBotId)) {+ await updateCallRecording(client, {+ id: callRecording.id,+ data: { externalBotId: existingExternalBotId },+ });+ result.attachedCallRecordingIds.push(callRecording.id);continue;}- const didScheduleRecallBot = await scheduleRecallBotForCallRecording(+ await scheduleBotForResumableCallRecording({client,- {- callRecording,- calendarEvent,- },+ callRecording,+ calendarEvent,+ result,+ });+ }++ return result;+};++const scheduleBotForResumableCallRecording = async ({+ client,+ callRecording,+ calendarEvent,+ result,+}: {+ client: CoreApiClient;+ callRecording: CallRecordingRecord;+ calendarEvent: CalendarEventRecord;+ result: ScheduleRecallBotsForPendingCallRecordingsResult;+}): Promise<void> => {+ const didScheduleRecallBot = await scheduleRecallBotForCallRecording(+ client,+ {+ callRecording,+ calendarEvent,+ },+ );++ if (didScheduleRecallBot) {+ result.scheduledCallRecordingIds.push(callRecording.id);+ }+};++// Only an absent attempt marker proves no POST reached Recall; a marked row+// may have a bot that joined and recorded before the id write-back was lost,+// so it keeps its recovery chance until the convergence lookback has passed.+const resolveEndedPendingCallRecording = async ({+ client,+ callRecording,+ calendarEvent,+ now,+ result,+}: {+ client: CoreApiClient;+ callRecording: CallRecordingRecord;+ calendarEvent: CalendarEventRecord;+ now: Date;+ result: ScheduleRecallBotsForPendingCallRecordingsResult;+}): Promise<void> => {+ if (isUndefined(callRecording.botScheduleAttemptedAt)) {+ await markCallRecordingFailed({+ client,+ callRecording,+ failureReason: BOT_NEVER_SCHEDULED_FAILURE_REASON,+ logMessage: `call recording ${callRecording.id} never got a Recall bot and its meeting has ended; marking it failed`,+ });+ result.markedFailedCallRecordingIds.push(callRecording.id);++ return;+ }++ if (!hasUnresolvedAttemptAgedOut({ calendarEvent, now })) {+ console.warn(+ `[call-recorder] call recording ${callRecording.id} has an unresolved Recall bot creation attempt and its meeting has ended; waiting for convergence`,);- if (didScheduleRecallBot) {- scheduledCallRecordingIds.push(callRecording.id);- }+ return;}- return { attachedCallRecordingIds, scheduledCallRecordingIds };+ await markCallRecordingFailed({+ client,+ callRecording,+ failureReason: BOT_SCHEDULE_OUTCOME_UNKNOWN_FAILURE_REASON,+ logMessage: `call recording ${callRecording.id} has an unresolved Recall bot creation attempt older than the convergence lookback; marking it failed`,+ });+ result.markedFailedCallRecordingIds.push(callRecording.id);+};++const hasUnresolvedAttemptAgedOut = ({+ calendarEvent,+ now,+}: {+ calendarEvent: CalendarEventRecord;+ now: Date;+}): boolean => {+ // Mirrors hasMeetingEnded: an unparseable end time falls back to the start+ // time so these rows still age out of the pending sweep eventually.+ const meetingEndTime = [calendarEvent.endsAt, calendarEvent.startsAt]+ .filter((candidate) => !isUndefined(candidate))+ .map((candidate) => new Date(candidate).getTime())+ .find((candidateTime) => !Number.isNaN(candidateTime));++ return (+ !isUndefined(meetingEndTime) &&+ meetingEndTime + UNRESOLVED_ATTEMPT_MAX_AGE_DAYS * 24 * 60 * 60 * 1000 <=+ now.getTime()+ );+};++const markCallRecordingFailed = async ({+ client,+ callRecording,+ failureReason,+ logMessage,+}: {+ client: CoreApiClient;+ callRecording: CallRecordingRecord;+ failureReason: string;+ logMessage: string;+}): Promise<void> => {+ console.warn(`[call-recorder] ${logMessage}`);++ await updateCallRecording(client, {+ id: callRecording.id,+ data: {+ status: CallRecordingStatus.FAILED,+ callRecorderFailureReason: failureReason,+ },+ });};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/find-scheduled-recall-bot-id-for-call-recording.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/find-scheduled-recall-bot-id-for-call-recording.util.tsdeleted file mode 100644index 99bd41ea83f..00000000000--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/find-scheduled-recall-bot-id-for-call-recording.util.ts+++ /dev/null@@ -1,41 +0,0 @@-import { listScheduledRecallBots } from 'src/logic-functions/recall-api/list-scheduled-recall-bots.util';--const ACTIVE_RECALL_BOT_STATUSES = [- 'ready',- 'joining_call',- 'in_waiting_room',- 'in_call_not_recording',- 'recording_permission_allowed',- 'recording_permission_denied',- 'in_call_recording',-];--export type FindScheduledRecallBotIdResult =- | { ok: true; externalBotId: string | undefined }- | { ok: false };--export const findScheduledRecallBotIdForCallRecording = async ({- callRecordingId,- workspaceId,-}: {- callRecordingId: string;- workspaceId: string;-}): Promise<FindScheduledRecallBotIdResult> => {- const listResult = await listScheduledRecallBots({- metadata: {- twentyWorkspaceId: workspaceId,- twentyCallRecordingId: callRecordingId,- },- statuses: ACTIVE_RECALL_BOT_STATUSES,- });-- if (!listResult.ok) {- console.warn(- `[call-recorder] failed to look up existing Recall bot for call recording ${callRecordingId}: ${listResult.errorMessage}`,- );-- return { ok: false };- }-- return { ok: true, externalBotId: listResult.bots[0]?.id };-};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/find-scheduled-recall-bot-ids-by-call-recording-id.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/find-scheduled-recall-bot-ids-by-call-recording-id.util.tsnew file mode 100644index 00000000000..3d6372dba6b--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/find-scheduled-recall-bot-ids-by-call-recording-id.util.ts@@ -0,0 +1,62 @@+import { isUndefined } from '@sniptt/guards';++import { ACTIVE_RECALL_BOT_STATUSES } from 'src/logic-functions/constants/active-recall-bot-statuses';+import { getCurrentWorkspaceId } from 'src/logic-functions/data/get-current-workspace-id.util';+import { listScheduledRecallBots } from 'src/logic-functions/recall-api/list-scheduled-recall-bots.util';+import { isNonEmptyString } from 'src/logic-functions/utils/is-non-empty-string.util';++export type FindScheduledRecallBotIdsByCallRecordingIdResult =+ | { ok: true; externalBotIdByCallRecordingId: Map<string, string> }+ | { ok: false };++// One workspace-wide list request covers every pending recording; Recall's+// list endpoint has the tightest rate budget, so per-recording lookups must+// not fan out.+export const findScheduledRecallBotIdsByCallRecordingId =+ async (): Promise<FindScheduledRecallBotIdsByCallRecordingIdResult> => {+ const workspaceId = getCurrentWorkspaceId();++ if (isUndefined(workspaceId)) {+ return { ok: true, externalBotIdByCallRecordingId: new Map() };+ }++ const listResult = await listScheduledRecallBots({+ metadata: { twentyWorkspaceId: workspaceId },+ statuses: ACTIVE_RECALL_BOT_STATUSES,+ });++ if (!listResult.ok) {+ console.warn(+ `[call-recorder] failed to look up existing Recall bots for pending call recordings: ${listResult.errorMessage}`,+ );++ return { ok: false };+ }++ // A truncated list can hide existing bots; callers treat a map miss as+ // permission to create, so an incomplete map must read as a failed lookup.+ if (listResult.truncated) {+ console.warn(+ '[call-recorder] Recall bot list was truncated; deferring bot recovery to the next run',+ );++ return { ok: false };+ }++ const externalBotIdByCallRecordingId = new Map<string, string>();++ for (const bot of listResult.bots) {+ const callRecordingId = bot.metadata.twentyCallRecordingId;++ if (+ !isNonEmptyString(callRecordingId) ||+ externalBotIdByCallRecordingId.has(callRecordingId)+ ) {+ continue;+ }++ externalBotIdByCallRecordingId.set(callRecordingId, bot.id);+ }++ return { ok: true, externalBotIdByCallRecordingId };+ };diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/schedule-recall-bot.util.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/schedule-recall-bot.util.tsindex 71dfe546c8a..2f1ab4baeaa 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/schedule-recall-bot.util.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/recall-api/schedule-recall-bot.util.ts@@ -20,6 +20,7 @@ export type ScheduleRecallBotArgs = {joinAt: string;metadata: RecallRoutingMetadata;automaticVideoOutput?: RecallBotAutomaticVideoOutput;+ idempotencyKey?: string;};export const scheduleRecallBot = async ({@@ -27,6 +28,11 @@ export const scheduleRecallBot = async ({joinAt,metadata,automaticVideoOutput,+ idempotencyKey = computeRecallBotCreationIdempotencyKey({+ meetingUrl,+ joinAt,+ metadata,+ }),}: ScheduleRecallBotArgs): Promise<RecallBotScheduleResult> => {const configResult = getRecallApiConfig();@@ -35,11 +41,6 @@ export const scheduleRecallBot = async ({}const automaticLeave = getRecallBotAutomaticLeave();- const idempotencyKey = computeRecallBotCreationIdempotencyKey({- meetingUrl,- joinAt,- metadata,- });const result = await recallBotApiRequest<RecallBotResponse>({config: configResult.config,@@ -82,7 +83,7 @@ export const scheduleRecallBot = async ({};};-const computeRecallBotCreationIdempotencyKey = ({+export const computeRecallBotCreationIdempotencyKey = ({meetingUrl,joinAt,metadata,diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/schedule-recall-bot-on-call-recording-update.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/schedule-recall-bot-on-call-recording-update.tsnew file mode 100644index 00000000000..78c7026129c--- /dev/null+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/schedule-recall-bot-on-call-recording-update.ts@@ -0,0 +1,129 @@+import { isUndefined } from '@sniptt/guards';+import { CoreApiClient } from 'twenty-client-sdk/core';+import {+ defineLogicFunction,+ type DatabaseEventPayload,+ type ObjectRecordBaseEvent,+} from 'twenty-sdk/define';++import { SCHEDULE_RECALL_BOT_ON_CALL_RECORDING_UPDATE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER } from 'src/constants/schedule-recall-bot-on-call-recording-update-logic-function-universal-identifier';+import { CallRecordingRequestStatus } from 'src/logic-functions/constants/call-recording-request-status';+import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';+import {+ resumePendingCallRecording,+ type ResumePendingCallRecordingResult,+} from 'src/logic-functions/flows/resume-pending-call-recording.util';++const CALL_RECORDING_OBJECT_NAME = 'callRecording';++// Only these fields can transition a row into the pending shape; ignoring the+// rest keeps this trigger from re-firing on its own scheduling-progress+// writes (botScheduleAttemptedAt, botScheduleIdempotencyKey, externalBotId+// write-back) and on webhook artifact updates.+const PENDING_TRANSITION_FIELDS = [+ 'recordingRequestStatus',+ 'status',+ 'externalBotId',+ 'calendarEventId',+];++type CallRecordingForDatabaseEvent = {+ id: string;+ status?: string | null;+ recordingRequestStatus?: string | null;+ externalBotId?: string | null;+};++type CallRecordingDatabaseEvent = DatabaseEventPayload<+ ObjectRecordBaseEvent<CallRecordingForDatabaseEvent>+>;++// Created rows are scheduled inline by the run that inserts them; reacting to+// creations here would race that run into duplicate Recall creates. This+// trigger only resumes rows that fall back to pending later (a bot cleared+// after vanishing at Recall, a canceled request re-requested, a failed row+// reset by calendar reconciliation), which the recovery cron would otherwise+// pick up minutes later.+export const scheduleRecallBotOnCallRecordingUpdateHandler = async (+ event: CallRecordingDatabaseEvent,+): Promise<+ | { skipped: true; reason: string }+ | { callRecordingId: string; result: ResumePendingCallRecordingResult }+> => {+ const [objectName, action] = event.name.split('.');++ if (objectName !== CALL_RECORDING_OBJECT_NAME || action !== 'updated') {+ return { skipped: true, reason: 'not a call recording update' };+ }++ const updatedFields = event.properties.updatedFields ?? [];++ if (+ !updatedFields.some((updatedField) =>+ PENDING_TRANSITION_FIELDS.includes(updatedField),+ )+ ) {+ return { skipped: true, reason: 'no pending-transition field changed' };+ }++ if (contradictsPendingCallRecording(event.properties)) {+ return { skipped: true, reason: 'call recording is not pending' };+ }++ const result = await resumePendingCallRecording({+ client: new CoreApiClient(),+ callRecordingId: event.recordId,+ now: new Date(),+ });++ return { callRecordingId: event.recordId, result };+};++// Values can come from a full `after` snapshot or, on slim payloads, from the+// per-field diff; any known value that contradicts the pending shape lets the+// trigger skip without the authoritative fetch. Unknown values stay ambiguous+// and the resume flow re-fetches to decide.+const contradictsPendingCallRecording = (+ properties: CallRecordingDatabaseEvent['properties'],+): boolean => {+ const knownValues = properties.after ?? resolveDiffAfterValues(properties);++ return (+ (!isUndefined(knownValues.recordingRequestStatus) &&+ knownValues.recordingRequestStatus !==+ CallRecordingRequestStatus.REQUESTED) ||+ (!isUndefined(knownValues.status) &&+ knownValues.status !== CallRecordingStatus.SCHEDULED) ||+ (!isUndefined(knownValues.externalBotId) &&+ knownValues.externalBotId !== null)+ );+};++const resolveDiffAfterValues = (+ properties: CallRecordingDatabaseEvent['properties'],+): Partial<CallRecordingForDatabaseEvent> => {+ const diff = properties.diff ?? {};++ return {+ ...(isUndefined(diff.status) ? {} : { status: diff.status.after }),+ ...(isUndefined(diff.recordingRequestStatus)+ ? {}+ : { recordingRequestStatus: diff.recordingRequestStatus.after }),+ ...(isUndefined(diff.externalBotId)+ ? {}+ : { externalBotId: diff.externalBotId.after }),+ };+};++export default defineLogicFunction({+ universalIdentifier:+ SCHEDULE_RECALL_BOT_ON_CALL_RECORDING_UPDATE_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,+ name: 'schedule-recall-bot-on-call-recording-update',+ description:+ 'Resumes Recall bot scheduling as soon as a call recording transitions back to pending instead of waiting for the recovery cron.',+ timeoutSeconds: 60,+ handler: scheduleRecallBotOnCallRecordingUpdateHandler,+ databaseEventTriggerSettings: {+ eventName: `${CALL_RECORDING_OBJECT_NAME}.updated`,+ },+});diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-record.type.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-record.type.tsindex 0cf11c58fd2..8d432711086 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-record.type.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-record.type.ts@@ -12,6 +12,8 @@ export type CallRecordingRecord = {endedAt?: string;calendarEventId?: string;externalBotId?: string;+ botScheduleAttemptedAt?: string;+ botScheduleIdempotencyKey?: string;externalRecordingId?: string;callRecorderFailureReason?: string;};diff --git a/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-update-fields.type.ts b/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-update-fields.type.tsindex a465f3e824b..03eabc041c8 100644--- a/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-update-fields.type.ts+++ b/packages/twenty-apps/public/call-recorder/src/logic-functions/types/call-recording-update-fields.type.ts@@ -13,6 +13,9 @@ export type CallRecordingUpdateFields = Partial<{calendarEventId: string;// null clears stale app-owned state on cancel/eject or reschedule.externalBotId: string | null;+ // null clears attempt state once its outcome is resolved (bot confirmed gone).+ botScheduleAttemptedAt: string | null;+ botScheduleIdempotencyKey: string | null;externalRecordingId: string;callRecorderFailureReason: string | null;transcript: Record<string, unknown>;