Merge branch 'main' into ehco/call-recording-converge-on-meeting-start

Author: ehconitin

package.json

@@ -74,6 +74,7 @@
       "packages/twenty-utils",
       "packages/twenty-zapier",
       "packages/twenty-website",
+      "packages/twenty-website-redone",
       "packages/twenty-docs",
       "packages/twenty-e2e-testing",
       "packages/twenty-shared",

packages/twenty-apps/internal/twenty-meeting-bot/src/logic-functions/domain/build-pending-transcript-marker.util.ts

@@ -0,0 +1,13 @@
+import { type TranscriptMarker } from 'src/logic-functions/types/transcript-marker.type';
+
+export const buildPendingTranscriptMarker = ({
+  recallTranscriptId,
+  requestedAt,
+}: {
+  recallTranscriptId: string;
+  requestedAt: string;
+}): TranscriptMarker => ({
+  recallTranscriptId,
+  status: 'PENDING',
+  requestedAt,
+});

packages/twenty-apps/internal/twenty-meeting-bot/src/logic-functions/flows/__tests__/converge-diverged-call-recordings.test.ts

@@ -163,15 +163,15 @@ describe('convergeDivergedCallRecordings', () => {
       callRecordingId: 'call-recording-1',
     });
     expect(client.mutations).toEqual([
-      {
+      expect.objectContaining({
         id: 'call-recording-1',
-        data: {
+        data: expect.objectContaining({
           status: 'PROCESSING',
           startedAt: '2026-06-09T13:02:00.000Z',
           endedAt: '2026-06-09T14:00:00.000Z',
           externalRecordingId: 'recall-recording-1',
-        },
-      },
+        }),
+      }),
     ]);
     expect(chargeCompletedCallRecordingMock).not.toHaveBeenCalled();
     expect(result).toEqual({
@@ -470,6 +470,11 @@ describe('convergeDivergedCallRecordings', () => {
         id: 'call-recording-1',
         data: {
           endedAt: '2026-06-09T14:00:00.000Z',
+          transcript: {
+            recallTranscriptId: 'recall-transcript-1',
+            status: 'PENDING',
+            requestedAt: NOW.toISOString(),
+          },
         },
       },
     ]);

packages/twenty-apps/internal/twenty-meeting-bot/src/logic-functions/flows/__tests__/handle-recall-webhook.test.ts

@@ -750,25 +750,17 @@ describe('handleRecallWebhook', () => {
           status: 'PROCESSING',
           externalBotId: 'recall-bot-1',
           externalRecordingId: 'recall-recording-1',
+          transcript: {
+            recallTranscriptId: 'recall-transcript-1',
+            status: 'PENDING',
+            requestedAt: expect.any(String),
+          },
         },
       },
     ]);
   });
 
-  it('does not re-request a transcript on a redelivered done event', async () => {
-    listRecallTranscriptsMock.mockResolvedValue({
-      ok: true,
-      transcripts: [
-        {
-          id: 'recall-transcript-1',
-          createdAt: '2026-01-01T14:06:00.000Z',
-          downloadUrl: undefined,
-          provider: 'recallai_async',
-          statusCode: 'processing',
-          statusSubCode: undefined,
-        },
-      ],
-    });
+  it('does not re-request a transcript on a redelivered done event while Recall list is stale', async () => {
     const client = new FakeCoreApiClient([
       {
         id: 'call-recording-1',
@@ -800,6 +792,9 @@ describe('handleRecallWebhook', () => {
     expect(listRecallTranscriptsMock).toHaveBeenCalledWith({
       externalRecordingId: 'recall-recording-1',
     });
+    expect(retrieveRecallTranscriptMock).toHaveBeenCalledWith({
+      transcriptId: 'recall-transcript-1',
+    });
     expect(client.mutations).toEqual([
       {
         id: 'call-recording-1',
@@ -858,14 +853,14 @@ describe('handleRecallWebhook', () => {
       callRecordingId: 'call-recording-1',
     });
     expect(client.mutations).toEqual([
-      {
+      expect.objectContaining({
         id: 'call-recording-1',
-        data: {
+        data: expect.objectContaining({
           status: 'PROCESSING',
           externalBotId: 'recall-bot-1',
           externalRecordingId: 'recall-recording-9',
-        },
-      },
+        }),
+      }),
     ]);
   });
 
@@ -972,15 +967,15 @@ describe('handleRecallWebhook', () => {
       callRecordingId: 'call-recording-1',
     });
     expect(client.mutations).toEqual([
-      {
+      expect.objectContaining({
         id: 'call-recording-1',
-        data: {
+        data: expect.objectContaining({
           status: 'PROCESSING',
           externalBotId: 'recall-bot-1',
           externalRecordingId: 'recall-recording-1',
           audio: [{ fileId: 'file-audio-1', label: 'audio.mp3' }],
-        },
-      },
+        }),
+      }),
     ]);
     expect(chargeCompletedCallRecordingMock).not.toHaveBeenCalled();
   });

packages/twenty-apps/internal/twenty-meeting-bot/src/logic-functions/flows/converge-diverged-call-recordings.util.ts

@@ -119,6 +119,7 @@ export const convergeDivergedCallRecordings = async ({
       client,
       candidate,
       externalBotId: candidate.externalBotId,
+      now,
       result,
     });
   }
@@ -229,11 +230,13 @@ const convergeCallRecording = async ({
   client,
   candidate,
   externalBotId,
+  now,
   result,
 }: {
   client: CoreApiClient;
   candidate: DivergedCallRecordingCandidate;
   externalBotId: string;
+  now: Date;
   result: ConvergeDivergedCallRecordingsResult;
 }): Promise<void> => {
   const botResult = await getRecallBot({ externalBotId });
@@ -269,6 +272,7 @@ const convergeCallRecording = async ({
         callRecordingId: candidate.id,
         currentStatus: candidate.status,
         externalRecordingId,
+        requestedAt: now.toISOString(),
         transcript: candidate.transcript,
       });
 

packages/twenty-apps/internal/twenty-meeting-bot/src/logic-functions/flows/handle-recall-webhook.util.ts

@@ -353,6 +353,7 @@ const buildTranscriptArtifactUpdate = async ({
       callRecordingId: callRecording.id,
       currentStatus: callRecording.status,
       externalRecordingId,
+      requestedAt: new Date().toISOString(),
       transcript: callRecording.transcript,
     });
 

packages/twenty-apps/internal/twenty-meeting-bot/src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util.ts

@@ -3,6 +3,7 @@ import { isNull, isUndefined } from '@sniptt/guards';
 import { CallRecordingStatus } from 'src/logic-functions/constants/call-recording-status';
 import { type CallRecordingUpdateFields } from 'src/logic-functions/data/update-call-recording.util';
 import { buildFailedTranscriptMarker } from 'src/logic-functions/domain/build-failed-transcript-marker.util';
+import { buildPendingTranscriptMarker } from 'src/logic-functions/domain/build-pending-transcript-marker.util';
 import { isCallRecordingStatusDowngrade } from 'src/logic-functions/domain/is-call-recording-status-downgrade.util';
 import { parseTranscriptMarker } from 'src/logic-functions/domain/parse-transcript-marker.util';
 import { createAsyncRecallTranscript } from 'src/logic-functions/recall-api/create-async-recall-transcript.util';
@@ -26,11 +27,13 @@ export const reconcileCallRecordingTranscriptArtifact = async ({
   callRecordingId,
   currentStatus,
   externalRecordingId,
+  requestedAt,
   transcript,
 }: {
   callRecordingId: string;
   currentStatus: string | undefined;
   externalRecordingId: string;
+  requestedAt: string;
   transcript: unknown;
 }): Promise<ReconcileCallRecordingTranscriptArtifactResult> => {
   const existingTranscriptMarker = parseTranscriptMarker(transcript);
@@ -60,8 +63,17 @@ export const reconcileCallRecordingTranscriptArtifact = async ({
   const transcriptArtifact = selectRecallTranscriptArtifact(
     listResult.transcripts,
   );
+  const pendingTranscriptMarkerRecallTranscriptId =
+    existingTranscriptMarker?.status === 'PENDING'
+      ? (existingTranscriptMarker.recallTranscriptId ?? undefined)
+      : undefined;
+  const transcriptIdToDownload =
+    transcriptArtifact?.id ?? pendingTranscriptMarkerRecallTranscriptId;
 
-  if (isUndefined(transcriptArtifact)) {
+  if (
+    isUndefined(transcriptArtifact) &&
+    isUndefined(pendingTranscriptMarkerRecallTranscriptId)
+  ) {
     const createResult = await createAsyncRecallTranscript({
       externalRecordingId,
       callRecordingId,
@@ -75,12 +87,21 @@ export const reconcileCallRecordingTranscriptArtifact = async ({
       return buildEmptyTranscriptArtifactResult();
     }
 
-    return { updateData: {}, requestedTranscript: true };
+    return {
+      updateData: {
+        transcript: buildPendingTranscriptMarker({
+          recallTranscriptId: createResult.transcriptId,
+          requestedAt,
+        }),
+      },
+      requestedTranscript: true,
+    };
   }
 
   if (
-    transcriptArtifact.statusCode === 'failed' ||
-    transcriptArtifact.statusCode === 'error'
+    !isUndefined(transcriptArtifact) &&
+    (transcriptArtifact.statusCode === 'failed' ||
+      transcriptArtifact.statusCode === 'error')
   ) {
     return {
       updateData: buildTranscriptFailureUpdate({
@@ -92,12 +113,19 @@ export const reconcileCallRecordingTranscriptArtifact = async ({
     };
   }
 
-  if (transcriptArtifact.statusCode !== 'done') {
+  if (
+    !isUndefined(transcriptArtifact) &&
+    transcriptArtifact.statusCode !== 'done'
+  ) {
+    return buildEmptyTranscriptArtifactResult();
+  }
+
+  if (isUndefined(transcriptIdToDownload)) {
     return buildEmptyTranscriptArtifactResult();
   }
 
   const downloadResult = await downloadTranscript({
-    transcriptId: transcriptArtifact.id,
+    transcriptId: transcriptIdToDownload,
   });
 
   if (downloadResult.outcome === 'filled') {
@@ -113,7 +141,7 @@ export const reconcileCallRecordingTranscriptArtifact = async ({
     return {
       updateData: buildTranscriptFailureUpdate({
         currentStatus,
-        transcriptId: transcriptArtifact.id,
+        transcriptId: transcriptIdToDownload,
         subCode: downloadResult.subCode,
       }),
       requestedTranscript: false,

packages/twenty-server/src/engine/api/mcp/services/__tests__/mcp-tool-executor.service.spec.ts

@@ -4,15 +4,16 @@ import {
   MCP_PROGRESS_NOTIFICATION_METHOD,
   TOOL_CALL_PROGRESS_TOKEN_PREFIX,
 } from 'src/engine/api/mcp/constants/mcp-progress-notification.const';
-import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
 import { McpToolExecutorService } from 'src/engine/api/mcp/services/mcp-tool-executor.service';
+import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
 
 describe('McpToolExecutorService', () => {
   let service: McpToolExecutorService;
 
   beforeEach(() => {
     const metricsService = {
       incrementCounterBy: jest.fn().mockResolvedValue(undefined),
+      recordHistogram: jest.fn(),
     } as unknown as MetricsService;
 
     service = new McpToolExecutorService(metricsService);

packages/twenty-server/src/engine/api/mcp/services/mcp-tool-executor.service.ts

@@ -1,10 +1,15 @@
 import { Injectable } from '@nestjs/common';
 
+import { isNonEmptyString } from '@sniptt/guards';
 import { type ToolSet } from 'ai';
 import { isDefined } from 'twenty-shared/utils';
 
-import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
 import { MetricsService } from 'src/engine/core-modules/metrics/metrics.service';
+import { MetricsKeys } from 'src/engine/core-modules/metrics/types/metrics-keys.type';
+import { estimateToolOutputTokens } from 'src/engine/core-modules/tool-provider/utils/estimate-tool-output-tokens.util';
+import { getToolMetricName } from 'src/engine/core-modules/tool-provider/utils/get-tool-metric-name.util';
+import { isToolOutputSuccessful } from 'src/engine/core-modules/tool-provider/utils/is-tool-output-successful.util';
+import { resolveToolName } from 'src/engine/core-modules/tool-provider/utils/resolve-tool-name.util';
 
 import { JSON_RPC_ERROR_CODE } from 'src/engine/api/mcp/constants/json-rpc-error-code.const';
 import {
@@ -33,14 +38,23 @@ export class McpToolExecutorService {
     params: Record<string, unknown>,
     sseWriter?: (data: Record<string, unknown>) => void,
   ) {
-    const toolName = params.name as keyof typeof toolSet;
+    if (!isNonEmptyString(params.name)) {
+      return wrapJsonRpcResponse(id, {
+        error: {
+          code: JSON_RPC_ERROR_CODE.INVALID_PARAMS,
+          message: 'Tool name is required',
+        },
+      });
+    }
+
+    const toolName = params.name;
     const tool = toolSet[toolName];
 
     if (!isDefined(tool) || !isDefined(tool.execute)) {
       return wrapJsonRpcResponse(id, {
         error: {
           code: JSON_RPC_ERROR_CODE.INVALID_PARAMS,
-          message: `Unknown tool: ${String(params.name)}`,
+          message: `Unknown tool: ${toolName}`,
         },
       });
     }
@@ -57,15 +71,34 @@ export class McpToolExecutorService {
       });
     }
 
+    const metricToolName = getToolMetricName(
+      resolveToolName({
+        toolName,
+        input: params.arguments,
+      }),
+    );
+
     try {
       const result = await tool.execute(params.arguments, {
         toolCallId: '1',
         messages: [],
       });
 
-      void this.metricsService.incrementCounterBy({
-        key: MetricsKeys.McpToolExecutionSucceeded,
+      const succeeded = isToolOutputSuccessful(result);
+
+      this.metricsService.incrementCounterBy({
+        key: succeeded
+          ? MetricsKeys.McpToolExecutionSucceeded
+          : MetricsKeys.McpToolExecutionFailed,
         amount: 1,
+        attributes: { tool: metricToolName },
+      });
+
+      this.metricsService.recordHistogram({
+        key: MetricsKeys.McpToolOutputTokens,
+        value: estimateToolOutputTokens(result),
+        unit: 'token',
+        attributes: { tool: metricToolName },
       });
 
       return wrapJsonRpcResponse(id, {
@@ -75,9 +108,10 @@ export class McpToolExecutorService {
         },
       });
     } catch (executionError) {
-      void this.metricsService.incrementCounterBy({
+      this.metricsService.incrementCounterBy({
         key: MetricsKeys.McpToolExecutionFailed,
         amount: 1,
+        attributes: { tool: metricToolName },
       });
 
       return wrapJsonRpcResponse(id, {