@twentyhq/call-recorder 1.0.1 → 1.0.2

package/src/logic-functions/process-recall-webhook.mjs

@@ -0,0 +1,1744 @@
+import { createRequire as __createRequire } from 'module';
+const require = __createRequire(import.meta.url);
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e2) {
+    throw mod = 0, e2;
+  }
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/@sniptt/guards/build/guards/primitives.js
+var require_primitives = __commonJS({
+  "node_modules/@sniptt/guards/build/guards/primitives.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isSymbol = exports.isBigInt = exports.isString = exports.isNumber = exports.isBoolean = exports.isUndefined = void 0;
+    var isUndefined17 = (term) => {
+      return typeof term === "undefined";
+    };
+    exports.isUndefined = isUndefined17;
+    var isBoolean = (term) => {
+      return typeof term === "boolean";
+    };
+    exports.isBoolean = isBoolean;
+    var isNumber = (term) => {
+      return typeof term === "number" && !Number.isNaN(term);
+    };
+    exports.isNumber = isNumber;
+    var isString4 = (term) => {
+      return typeof term === "string";
+    };
+    exports.isString = isString4;
+    var isBigInt = (term) => {
+      return typeof term === "bigint";
+    };
+    exports.isBigInt = isBigInt;
+    var isSymbol = (term) => {
+      return typeof term === "symbol";
+    };
+    exports.isSymbol = isSymbol;
+  }
+});
+
+// node_modules/@sniptt/guards/build/guards/structural.js
+var require_structural = __commonJS({
+  "node_modules/@sniptt/guards/build/guards/structural.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isDate = exports.isWeakSet = exports.isWeakMap = exports.isSet = exports.isMap = exports.isArray = exports.isObject = exports.isFunction = exports.isNull = void 0;
+    var isNull5 = (term) => {
+      return term === null;
+    };
+    exports.isNull = isNull5;
+    var isFunction = (term) => {
+      return typeof term === "function";
+    };
+    exports.isFunction = isFunction;
+    var isObject2 = (term) => {
+      return !exports.isNull(term) && typeof term === "object";
+    };
+    exports.isObject = isObject2;
+    var isArray4 = (term) => {
+      return Array.isArray(term);
+    };
+    exports.isArray = isArray4;
+    var isMap = (term) => {
+      return term instanceof Map;
+    };
+    exports.isMap = isMap;
+    var isSet = (term) => {
+      return term instanceof Set;
+    };
+    exports.isSet = isSet;
+    var isWeakMap = (term) => {
+      return term instanceof WeakMap;
+    };
+    exports.isWeakMap = isWeakMap;
+    var isWeakSet = (term) => {
+      return term instanceof WeakSet;
+    };
+    exports.isWeakSet = isWeakSet;
+    var isDate = (term) => {
+      return term instanceof Date;
+    };
+    exports.isDate = isDate;
+  }
+});
+
+// node_modules/@sniptt/guards/build/guards/convenience.js
+var require_convenience = __commonJS({
+  "node_modules/@sniptt/guards/build/guards/convenience.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.isNegativeInteger = exports.isNonNegativeInteger = exports.isPositiveInteger = exports.isInteger = exports.isNumberOrNaN = exports.isNonEmptyString = exports.isNonEmptyArray = exports.isObjectOrNull = void 0;
+    var primitives_1 = require_primitives();
+    var structural_1 = require_structural();
+    var isObjectOrNull = (term) => {
+      return typeof term === "object";
+    };
+    exports.isObjectOrNull = isObjectOrNull;
+    var isNonEmptyArray3 = (term) => {
+      return structural_1.isArray(term) && term.length > 0;
+    };
+    exports.isNonEmptyArray = isNonEmptyArray3;
+    var isNonEmptyString2 = (term) => {
+      return primitives_1.isString(term) && term.length > 0;
+    };
+    exports.isNonEmptyString = isNonEmptyString2;
+    var isNumberOrNaN = (term) => {
+      return typeof term === "number";
+    };
+    exports.isNumberOrNaN = isNumberOrNaN;
+    var isInteger = (term) => {
+      return primitives_1.isNumber(term) && Number.isInteger(term);
+    };
+    exports.isInteger = isInteger;
+    var isPositiveInteger = (term) => {
+      return exports.isInteger(term) && term > 0;
+    };
+    exports.isPositiveInteger = isPositiveInteger;
+    var isNonNegativeInteger = (term) => {
+      return exports.isInteger(term) && term >= 0;
+    };
+    exports.isNonNegativeInteger = isNonNegativeInteger;
+    var isNegativeInteger = (term) => {
+      return exports.isInteger(term) && term < 0;
+    };
+    exports.isNegativeInteger = isNegativeInteger;
+  }
+});
+
+// node_modules/@sniptt/guards/build/index.js
+var require_build = __commonJS({
+  "node_modules/@sniptt/guards/build/index.js"(exports) {
+    "use strict";
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      Object.defineProperty(o, k2, { enumerable: true, get: function() {
+        return m[k];
+      } });
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    var __exportStar = exports && exports.__exportStar || function(m, exports2) {
+      for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports2, p)) __createBinding(exports2, m, p);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.structural = exports.primitives = exports.convenience = void 0;
+    exports.convenience = __importStar(require_convenience());
+    __exportStar(require_convenience(), exports);
+    exports.primitives = __importStar(require_primitives());
+    __exportStar(require_primitives(), exports);
+    exports.structural = __importStar(require_structural());
+    __exportStar(require_structural(), exports);
+  }
+});
+
+// src/logic-functions/process-recall-webhook.ts
+import { CoreApiClient } from "twenty-client-sdk/core";
+
+// twenty-sdk-define-stub:__twenty-sdk-define-stub__
+var __defineFactoryStub = (config) => ({
+  success: true,
+  config,
+  errors: []
+});
+var __anyHandler = {
+  get(_target, prop) {
+    if (prop === "__esModule") return true;
+    if (prop === Symbol.toPrimitive) return () => "";
+    if (typeof prop === "symbol") return void 0;
+    return new Proxy(() => void 0, __anyHandler);
+  },
+  apply() {
+    return new Proxy(() => void 0, __anyHandler);
+  }
+};
+var __anyStub = new Proxy(() => void 0, __anyHandler);
+var defineLogicFunction = __defineFactoryStub;
+
+// src/constants/process-recall-webhook-logic-function-universal-identifier.ts
+var PROCESS_RECALL_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER = "13d9c427-447e-494a-8d3c-1af5d0bacb82";
+
+// src/logic-functions/flows/handle-recall-webhook.util.ts
+var import_guards20 = __toESM(require_build());
+
+// src/logic-functions/domain/build-failed-transcript-marker.util.ts
+var buildFailedTranscriptMarker = ({
+  recallTranscriptId,
+  subCode
+}) => ({
+  recallTranscriptId,
+  status: "FAILED",
+  subCode
+});
+
+// src/logic-functions/domain/build-transcript-failure-reason.util.ts
+var import_guards = __toESM(require_build());
+var buildTranscriptFailureReason = (subCode) => {
+  return (0, import_guards.isNull)(subCode) ? "transcript_failed" : `transcript_failed:${subCode}`;
+};
+
+// src/logic-functions/flows/download-transcript.util.ts
+var import_guards7 = __toESM(require_build());
+
+// src/logic-functions/recall-api/retrieve-recall-transcript.util.ts
+var import_guards6 = __toESM(require_build());
+
+// src/logic-functions/utils/as-record.util.ts
+var import_guards2 = __toESM(require_build());
+var asRecord = (value) => (0, import_guards2.isObject)(value) && !(0, import_guards2.isArray)(value) ? value : void 0;
+
+// src/logic-functions/recall-api/get-recall-api-config.util.ts
+var import_guards4 = __toESM(require_build());
+
+// src/logic-functions/constants/call-recorder-name-env-var-name.ts
+var CALL_RECORDER_NAME_ENV_VAR_NAME = "CALL_RECORDER_NAME";
+
+// src/logic-functions/constants/default-call-recorder-name.ts
+var DEFAULT_CALL_RECORDER_NAME = "Twenty.com";
+
+// src/logic-functions/constants/default-recall-region.ts
+var DEFAULT_RECALL_REGION = "eu-central-1";
+
+// src/logic-functions/constants/recall-api-key-env-var-name.ts
+var RECALL_API_KEY_ENV_VAR_NAME = "RECALL_API_KEY";
+
+// src/logic-functions/constants/recall-region-env-var-name.ts
+var RECALL_REGION_ENV_VAR_NAME = "RECALL_REGION";
+
+// src/logic-functions/utils/get-application-variable-value.util.ts
+var getApplicationVariableValue = (key) => process.env[key];
+
+// src/logic-functions/utils/is-non-empty-string.util.ts
+var import_guards3 = __toESM(require_build());
+var isNonEmptyString = (value) => (0, import_guards3.isString)(value) && value.trim() !== "";
+
+// src/logic-functions/recall-api/get-recall-api-config.util.ts
+var getRecallApiConfig = () => {
+  const apiKey = normalizeOptionalString(
+    getApplicationVariableValue(RECALL_API_KEY_ENV_VAR_NAME)
+  );
+  if ((0, import_guards4.isUndefined)(apiKey)) {
+    return {
+      success: false,
+      error: "RECALL_API_KEY server variable is not set. A server admin must set it on the Call Recorder application registration before scheduling bots."
+    };
+  }
+  const region = normalizeOptionalString(
+    getApplicationVariableValue(RECALL_REGION_ENV_VAR_NAME)
+  ) ?? DEFAULT_RECALL_REGION;
+  const botName = normalizeOptionalString(
+    getApplicationVariableValue(CALL_RECORDER_NAME_ENV_VAR_NAME)
+  ) ?? DEFAULT_CALL_RECORDER_NAME;
+  return {
+    success: true,
+    config: {
+      apiKey,
+      baseUrl: `https://${region}.recall.ai/api/v1`,
+      botName
+    }
+  };
+};
+var normalizeOptionalString = (value) => isNonEmptyString(value) ? value.trim() : void 0;
+
+// src/logic-functions/utils/get-string.util.ts
+var getString = (value) => isNonEmptyString(value) ? value : void 0;
+
+// src/logic-functions/recall-api/recall-bot-api-request.util.ts
+var import_guards5 = __toESM(require_build());
+
+// src/logic-functions/constants/recall-api-max-attempts.ts
+var RECALL_API_MAX_ATTEMPTS = 3;
+
+// src/logic-functions/constants/recall-api-retry-delay-ms.ts
+var RECALL_API_RETRY_DELAY_MS = 500;
+
+// src/logic-functions/recall-api/recall-bot-api-request.util.ts
+var recallBotApiRequest = async (requestArgs) => {
+  const maxAttempts = requestArgs.maxAttempts ?? RECALL_API_MAX_ATTEMPTS;
+  for (let attemptNumber = 1; ; attemptNumber++) {
+    const { result, isRetryable } = await performRecallBotApiRequestAttempt(requestArgs);
+    if (!isRetryable || attemptNumber >= maxAttempts) {
+      return result;
+    }
+    await sleep(RECALL_API_RETRY_DELAY_MS * attemptNumber);
+  }
+};
+var performRecallBotApiRequestAttempt = async ({
+  config,
+  path,
+  method,
+  body,
+  allowNotFound = false
+}) => {
+  let response;
+  try {
+    response = await fetch(`${config.baseUrl}${path}`, {
+      method,
+      headers: {
+        Authorization: buildRecallApiAuthorizationHeader(config.apiKey),
+        ...(0, import_guards5.isUndefined)(body) ? {} : { "Content-Type": "application/json" }
+      },
+      ...(0, import_guards5.isUndefined)(body) ? {} : { body: JSON.stringify(body) }
+    });
+  } catch (error) {
+    return {
+      isRetryable: true,
+      result: {
+        ok: false,
+        status: null,
+        errorMessage: `Recall API request failed: ${error instanceof Error ? error.message : String(error)}`
+      }
+    };
+  }
+  if (allowNotFound && response.status === 404) {
+    return {
+      isRetryable: false,
+      result: {
+        ok: true,
+        status: response.status,
+        data: void 0
+      }
+    };
+  }
+  if (response.status === 204) {
+    return {
+      isRetryable: false,
+      result: {
+        ok: true,
+        status: response.status,
+        data: void 0
+      }
+    };
+  }
+  if (!response.ok) {
+    return {
+      isRetryable: isRetryableRecallApiStatus(response.status),
+      result: {
+        ok: false,
+        status: response.status,
+        errorMessage: await extractRecallApiErrorMessage(response)
+      }
+    };
+  }
+  try {
+    return {
+      isRetryable: false,
+      result: {
+        ok: true,
+        status: response.status,
+        data: await response.json()
+      }
+    };
+  } catch (error) {
+    return {
+      isRetryable: false,
+      result: {
+        ok: false,
+        status: response.status,
+        errorMessage: `Recall API returned a non-JSON response: ${error instanceof Error ? error.message : String(error)}`
+      }
+    };
+  }
+};
+var isRetryableRecallApiStatus = (status) => status === 429 || status >= 500;
+var sleep = (delayMs) => new Promise((resolve) => {
+  setTimeout(resolve, delayMs);
+});
+var buildRecallApiAuthorizationHeader = (apiKey) => {
+  const trimmedApiKey = apiKey.trim();
+  return trimmedApiKey.toLowerCase().startsWith("token ") ? trimmedApiKey : `Token ${trimmedApiKey}`;
+};
+var extractRecallApiErrorMessage = async (response) => {
+  const fallback = `Recall API responded with HTTP ${response.status}`;
+  try {
+    const body = await response.json();
+    return `${fallback}: ${JSON.stringify(body)}`;
+  } catch {
+    return fallback;
+  }
+};
+
+// src/logic-functions/recall-api/retrieve-recall-transcript.util.ts
+var retrieveRecallTranscript = async ({
+  transcriptId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/transcript/${transcriptId}/`,
+    method: "GET"
+  });
+  if (!result.ok) {
+    return result;
+  }
+  const transcript = extractRecallTranscriptDetails(result.data);
+  if (isMalformedRecallTranscriptDetails(transcript)) {
+    return {
+      ok: false,
+      status: result.status,
+      errorMessage: "Recall API returned malformed transcript details"
+    };
+  }
+  return { ok: true, transcript };
+};
+var extractRecallTranscriptDetails = (response) => {
+  const data = asRecord(response?.data);
+  const status = asRecord(response?.status);
+  return {
+    downloadUrl: getString(data?.download_url),
+    statusCode: getString(status?.code),
+    statusSubCode: getString(status?.sub_code)
+  };
+};
+var isMalformedRecallTranscriptDetails = ({
+  downloadUrl,
+  statusCode
+}) => (0, import_guards6.isUndefined)(downloadUrl) && (0, import_guards6.isUndefined)(statusCode) || (0, import_guards6.isUndefined)(downloadUrl) && statusCode === "done";
+
+// src/logic-functions/flows/download-transcript.util.ts
+var TRANSCRIPT_DOWNLOAD_TIMEOUT_MS = 2e4;
+var downloadTranscript = async ({
+  transcriptId
+}) => {
+  const retrieveResult = await retrieveRecallTranscript({ transcriptId });
+  if (!retrieveResult.ok) {
+    return { outcome: "error", errorMessage: retrieveResult.errorMessage };
+  }
+  const { downloadUrl, statusCode, statusSubCode } = retrieveResult.transcript;
+  if (!(0, import_guards7.isUndefined)(downloadUrl)) {
+    return downloadTranscriptContent(downloadUrl);
+  }
+  if (statusCode === "error" || statusCode === "failed") {
+    return { outcome: "failed", subCode: statusSubCode ?? null };
+  }
+  return { outcome: "pending" };
+};
+var downloadTranscriptContent = async (downloadUrl) => {
+  try {
+    const response = await fetch(downloadUrl, {
+      signal: AbortSignal.timeout(TRANSCRIPT_DOWNLOAD_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      console.warn(
+        `[call-recorder] transcript download responded with HTTP ${response.status}`
+      );
+      return {
+        outcome: "error",
+        errorMessage: "transcript download failed"
+      };
+    }
+    return { outcome: "filled", content: await response.json() };
+  } catch (error) {
+    console.warn(
+      `[call-recorder] transcript download failed: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return {
+      outcome: "error",
+      errorMessage: "transcript download failed"
+    };
+  }
+};
+
+// src/logic-functions/recall-api/extract-recall-bot-convergence.util.ts
+var import_guards9 = __toESM(require_build());
+
+// src/logic-functions/domain/map-recall-status-code-to-call-recording-status.util.ts
+var mapRecallStatusCodeToCallRecordingStatus = (statusCode) => {
+  switch (statusCode) {
+    case "joining_call":
+    case "in_waiting_room":
+      return "JOINING" /* JOINING */;
+    case "in_call_not_recording":
+    case "recording_permission_allowed":
+    case "in_call_recording":
+      return "RECORDING" /* RECORDING */;
+    // 'done' stays PROCESSING: COMPLETED is set only after all artifacts are ingested.
+    case "call_ended":
+    case "analysis_done":
+    case "done":
+      return "PROCESSING" /* PROCESSING */;
+    case "fatal":
+    case "analysis_failed":
+    case "recording_permission_denied":
+      return "FAILED" /* FAILED */;
+    default:
+      return void 0;
+  }
+};
+
+// src/logic-functions/recall-api/normalize-recall-timestamp.util.ts
+var import_guards8 = __toESM(require_build());
+var normalizeRecallTimestamp = (value) => {
+  if ((0, import_guards8.isUndefined)(value)) {
+    return void 0;
+  }
+  const parsed = new Date(value);
+  return Number.isNaN(parsed.getTime()) ? void 0 : parsed.toISOString();
+};
+
+// src/logic-functions/recall-api/extract-recall-bot-convergence.util.ts
+var extractRecallBotConvergence = (bot) => {
+  const statusChanges = extractStatusChanges(bot);
+  const latestStatusChange = getLatestStatusChange(statusChanges);
+  const status = mapRecallStatusCodeToCallRecordingStatus(
+    latestStatusChange?.code
+  );
+  const recording = extractFirstRecording(bot);
+  return {
+    status,
+    failureReason: status === "FAILED" /* FAILED */ ? latestStatusChange?.code : void 0,
+    startedAt: normalizeRecallTimestamp(
+      recording?.startedAt ?? findStatusChangeTimestamp(statusChanges, "in_call_recording")
+    ),
+    endedAt: normalizeRecallTimestamp(
+      recording?.completedAt ?? findStatusChangeTimestamp(statusChanges, "call_ended")
+    ),
+    externalRecordingId: recording?.id,
+    isRecallRecordingDone: !(0, import_guards9.isUndefined)(recording?.completedAt) || statusChanges.some((statusChange) => statusChange.code === "done")
+  };
+};
+var extractStatusChanges = (bot) => {
+  if (!(0, import_guards9.isArray)(bot.status_changes)) {
+    return [];
+  }
+  return bot.status_changes.flatMap((statusChange) => {
+    const code = getString(asRecord(statusChange)?.code);
+    if ((0, import_guards9.isUndefined)(code)) {
+      return [];
+    }
+    return [{ code, createdAt: getString(asRecord(statusChange)?.created_at) }];
+  });
+};
+var getLatestStatusChange = (statusChanges) => statusChanges.reduce(
+  (latestStatusChange, statusChange) => {
+    if ((0, import_guards9.isUndefined)(latestStatusChange)) {
+      return statusChange;
+    }
+    const statusChangeTime = getStatusChangeTime(statusChange);
+    const latestStatusChangeTime = getStatusChangeTime(latestStatusChange);
+    if ((0, import_guards9.isUndefined)(statusChangeTime) && (0, import_guards9.isUndefined)(latestStatusChangeTime)) {
+      return statusChange;
+    }
+    if ((0, import_guards9.isUndefined)(statusChangeTime)) {
+      return latestStatusChange;
+    }
+    if ((0, import_guards9.isUndefined)(latestStatusChangeTime)) {
+      return statusChange;
+    }
+    return statusChangeTime >= latestStatusChangeTime ? statusChange : latestStatusChange;
+  },
+  void 0
+);
+var getStatusChangeTime = (statusChange) => {
+  const normalizedTimestamp = normalizeRecallTimestamp(statusChange.createdAt);
+  if ((0, import_guards9.isUndefined)(normalizedTimestamp)) {
+    return void 0;
+  }
+  return new Date(normalizedTimestamp).getTime();
+};
+var extractFirstRecording = (bot) => {
+  if (!(0, import_guards9.isArray)(bot.recordings)) {
+    return void 0;
+  }
+  const recording = asRecord(bot.recordings[0]);
+  if ((0, import_guards9.isUndefined)(recording)) {
+    return void 0;
+  }
+  return {
+    id: getString(recording.id),
+    startedAt: getString(recording.started_at),
+    completedAt: getString(recording.completed_at)
+  };
+};
+var findStatusChangeTimestamp = (statusChanges, code) => statusChanges.find((statusChange) => statusChange.code === code)?.createdAt;
+
+// src/logic-functions/recall-api/get-recall-bot.util.ts
+var getRecallBot = async ({
+  externalBotId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/bot/${externalBotId}/`,
+    method: "GET"
+  });
+  if (!result.ok) {
+    return result;
+  }
+  const bot = asRecord(result.data);
+  if (bot === void 0) {
+    return {
+      ok: false,
+      status: result.status,
+      errorMessage: "Recall API returned an empty bot response"
+    };
+  }
+  return { ok: true, bot };
+};
+
+// src/logic-functions/flows/ingest-call-recording-media.util.ts
+var import_guards10 = __toESM(require_build());
+import { MetadataApiClient } from "twenty-client-sdk/metadata";
+
+// src/constants/call-recording-audio-field-universal-identifier.ts
+var CALL_RECORDING_AUDIO_FIELD_UNIVERSAL_IDENTIFIER = "2eafc2d0-8fec-430c-a939-65ca5fbc0f08";
+
+// src/constants/call-recording-video-field-universal-identifier.ts
+var CALL_RECORDING_VIDEO_FIELD_UNIVERSAL_IDENTIFIER = "bb9523d3-457e-4f4b-8c79-27a77afb87da";
+
+// src/logic-functions/utils/get-record-at-path.util.ts
+var getRecordAtPath = (record, path) => path.reduce(
+  (currentValue, pathPart) => asRecord(currentValue)?.[pathPart],
+  record
+);
+
+// src/logic-functions/recall-api/extract-recall-media-urls.util.ts
+var extractRecallMediaUrls = (recording) => {
+  const mediaShortcuts = asRecord(recording.media_shortcuts);
+  return {
+    videoUrl: extractArtifactDownloadUrl(mediaShortcuts, "video_mixed"),
+    audioUrl: extractArtifactDownloadUrl(mediaShortcuts, "audio_mixed")
+  };
+};
+var extractArtifactDownloadUrl = (mediaShortcuts, artifactKey) => getString(getRecordAtPath(mediaShortcuts, [artifactKey, "download_url"])) ?? getString(
+  getRecordAtPath(mediaShortcuts, [artifactKey, "data", "download_url"])
+);
+
+// src/logic-functions/recall-api/get-recall-recording.util.ts
+var getRecallRecording = async ({
+  externalRecordingId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/recording/${externalRecordingId}/`,
+    method: "GET"
+  });
+  if (!result.ok) {
+    return result;
+  }
+  return { ok: true, recording: result.data ?? {} };
+};
+
+// src/logic-functions/flows/ingest-call-recording-media.util.ts
+var MEDIA_DOWNLOAD_TIMEOUT_MS = 12e4;
+var ingestCallRecordingMedia = async ({
+  callRecordingId,
+  externalRecordingId,
+  hasAudio,
+  hasVideo
+}) => {
+  if (hasAudio && hasVideo) {
+    return {};
+  }
+  const recordingResult = await getRecallRecording({ externalRecordingId });
+  if (!recordingResult.ok) {
+    console.warn(
+      `[call-recorder] failed to fetch Recall recording ${externalRecordingId} while ingesting media for call recording ${callRecordingId}: ${recordingResult.errorMessage}`
+    );
+    return {};
+  }
+  const mediaUrls = extractRecallMediaUrls(recordingResult.recording);
+  const metadataClient = new MetadataApiClient();
+  const updateFields = {};
+  if (!hasVideo && !(0, import_guards10.isUndefined)(mediaUrls.videoUrl)) {
+    const video = await ingestMediaArtifact({
+      callRecordingId,
+      metadataClient,
+      url: mediaUrls.videoUrl,
+      fileName: "video.mp4",
+      fieldMetadataUniversalIdentifier: CALL_RECORDING_VIDEO_FIELD_UNIVERSAL_IDENTIFIER
+    });
+    if (!(0, import_guards10.isUndefined)(video)) {
+      updateFields.video = video;
+    }
+  }
+  if (!hasAudio && !(0, import_guards10.isUndefined)(mediaUrls.audioUrl)) {
+    const audio = await ingestMediaArtifact({
+      callRecordingId,
+      metadataClient,
+      url: mediaUrls.audioUrl,
+      fileName: "audio.mp3",
+      fieldMetadataUniversalIdentifier: CALL_RECORDING_AUDIO_FIELD_UNIVERSAL_IDENTIFIER
+    });
+    if (!(0, import_guards10.isUndefined)(audio)) {
+      updateFields.audio = audio;
+    }
+  }
+  return updateFields;
+};
+var ingestMediaArtifact = async ({
+  callRecordingId,
+  metadataClient,
+  url,
+  fileName,
+  fieldMetadataUniversalIdentifier
+}) => {
+  try {
+    const { buffer, contentType } = await downloadMediaFile(url);
+    const uploadedFile = await metadataClient.uploadFile(
+      buffer,
+      fileName,
+      contentType,
+      fieldMetadataUniversalIdentifier
+    );
+    return [{ fileId: uploadedFile.id, label: fileName }];
+  } catch (error) {
+    console.warn(
+      `[call-recorder] failed to ingest ${fileName} for call recording ${callRecordingId}: ${error instanceof Error ? error.message : String(error)}`
+    );
+    return void 0;
+  }
+};
+var downloadMediaFile = async (url) => {
+  const response = await fetch(url, {
+    signal: AbortSignal.timeout(MEDIA_DOWNLOAD_TIMEOUT_MS)
+  });
+  if (!response.ok) {
+    throw new Error(`download failed with status ${response.status}`);
+  }
+  return {
+    buffer: Buffer.from(await response.arrayBuffer()),
+    contentType: response.headers.get("content-type") ?? "application/octet-stream"
+  };
+};
+
+// src/logic-functions/domain/is-call-recording-status-downgrade.util.ts
+var import_guards11 = __toESM(require_build());
+var CALL_RECORDING_STATUS_PROGRESSION = {
+  ["SCHEDULED" /* SCHEDULED */]: 0,
+  ["JOINING" /* JOINING */]: 1,
+  ["RECORDING" /* RECORDING */]: 2,
+  ["PROCESSING" /* PROCESSING */]: 3,
+  ["FAILED" /* FAILED */]: 4,
+  ["COMPLETED" /* COMPLETED */]: 5
+};
+var getCallRecordingStatusRank = (status) => status in CALL_RECORDING_STATUS_PROGRESSION ? CALL_RECORDING_STATUS_PROGRESSION[status] : void 0;
+var isCallRecordingStatusDowngrade = ({
+  fromStatus,
+  toStatus
+}) => {
+  const fromRank = (0, import_guards11.isUndefined)(fromStatus) ? void 0 : getCallRecordingStatusRank(fromStatus);
+  const toRank = getCallRecordingStatusRank(toStatus);
+  if ((0, import_guards11.isUndefined)(fromRank) || (0, import_guards11.isUndefined)(toRank)) {
+    return false;
+  }
+  return toRank < fromRank;
+};
+
+// src/logic-functions/domain/is-recall-recording-done-signal.util.ts
+var isRecallRecordingDoneSignal = ({
+  event,
+  statusCode
+}) => {
+  return event === "recording.done" || event === "recording.failed" || statusCode === "done";
+};
+
+// src/logic-functions/recall-api/parse-recall-webhook-event.util.ts
+var import_guards12 = __toESM(require_build());
+
+// src/logic-functions/recall-api/get-recall-webhook-bot-metadata.util.ts
+var getRecallWebhookBotMetadata = (body) => {
+  const data = asRecord(body.data);
+  const bot = asRecord(body.bot);
+  return asRecord(bot?.metadata) ?? asRecord(getRecordAtPath(data, ["bot", "metadata"])) ?? asRecord(getRecordAtPath(data, ["recording", "metadata"])) ?? asRecord(data?.metadata);
+};
+
+// src/logic-functions/recall-api/parse-recall-webhook-event.util.ts
+var parseRecallWebhookEvent = (body) => {
+  const event = getString(body.event) ?? getString(body.type);
+  if ((0, import_guards12.isUndefined)(event)) {
+    return void 0;
+  }
+  const data = asRecord(body.data);
+  const bot = asRecord(body.bot);
+  return {
+    event,
+    statusCode: getString(getRecordAtPath(data, ["status", "code"])) ?? getString(getRecordAtPath(data, ["data", "code"])) ?? getString(getRecordAtPath(bot, ["status", "code"])) ?? getStatusCodeFromEventName(event),
+    statusTimestamp: normalizeRecallTimestamp(
+      getString(getRecordAtPath(data, ["status", "created_at"])) ?? getString(getRecordAtPath(data, ["data", "updated_at"])) ?? getString(getRecordAtPath(bot, ["status", "created_at"]))
+    ),
+    externalBotId: getString(data?.bot_id) ?? getString(getRecordAtPath(data, ["bot", "id"])) ?? getString(getRecordAtPath(data, ["recording", "bot_id"])) ?? getString(getRecordAtPath(data, ["recording", "bot", "id"])) ?? getString(bot?.id),
+    externalRecordingId: getString(getRecordAtPath(data, ["status", "recording_id"])) ?? getString(getRecordAtPath(data, ["recording", "id"])) ?? getString(data?.recording_id),
+    callRecordingIdFromMetadata: getString(
+      getRecallWebhookBotMetadata(body)?.twentyCallRecordingId
+    ),
+    recordingStartedAt: normalizeRecallTimestamp(
+      getString(getRecordAtPath(data, ["recording", "started_at"]))
+    ),
+    recordingEndedAt: normalizeRecallTimestamp(
+      getString(getRecordAtPath(data, ["recording", "completed_at"]))
+    ),
+    transcriptId: getString(getRecordAtPath(data, ["transcript", "id"])),
+    transcriptFailureSubCode: getString(
+      getRecordAtPath(data, ["status", "sub_code"])
+    )
+  };
+};
+var getStatusCodeFromEventName = (event) => {
+  if (!event.startsWith("bot.")) {
+    return void 0;
+  }
+  const statusCode = event.slice("bot.".length);
+  return statusCode === "status_change" ? void 0 : statusCode;
+};
+
+// src/logic-functions/domain/parse-transcript-marker.util.ts
+var import_guards13 = __toESM(require_build());
+var parseTranscriptMarker = (transcript) => {
+  const candidate = asRecord(transcript);
+  if ((0, import_guards13.isUndefined)(candidate)) {
+    return void 0;
+  }
+  if (candidate.status !== "PENDING" && candidate.status !== "FAILED") {
+    return void 0;
+  }
+  return {
+    recallTranscriptId: (0, import_guards13.isString)(candidate.recallTranscriptId) ? candidate.recallTranscriptId : null,
+    status: candidate.status,
+    ...(0, import_guards13.isString)(candidate.requestedAt) ? { requestedAt: candidate.requestedAt } : {},
+    ...(0, import_guards13.isString)(candidate.subCode) ? { subCode: candidate.subCode } : {}
+  };
+};
+
+// src/logic-functions/constants/non-terminal-call-recording-statuses.ts
+var NON_TERMINAL_CALL_RECORDING_STATUSES = [
+  "SCHEDULED" /* SCHEDULED */,
+  "JOINING" /* JOINING */,
+  "RECORDING" /* RECORDING */,
+  "PROCESSING" /* PROCESSING */
+];
+
+// src/logic-functions/data/complete-call-recording-ingestion.util.ts
+var completeCallRecordingIngestion = async (client, { id }) => {
+  const result = await client.mutation({
+    updateCallRecordings: {
+      __args: {
+        filter: {
+          id: { eq: id },
+          status: { in: NON_TERMINAL_CALL_RECORDING_STATUSES }
+        },
+        data: { status: "COMPLETED" /* COMPLETED */ }
+      },
+      id: true
+    }
+  });
+  return (result.updateCallRecordings ?? []).length > 0;
+};
+
+// src/logic-functions/flows/charge-completed-call-recording.util.ts
+var import_guards15 = __toESM(require_build());
+
+// node_modules/twenty-sdk/dist/billing/index.mjs
+var e = "TWENTY_API_URL";
+var t = "TWENTY_APP_ACCESS_TOKEN";
+var n = 5e3;
+var r = async ({ creditsUsedMicro: r2, operationType: i, quantity: a = 1, resourceContext: o }) => {
+  let s = process.env[e], c = process.env[t];
+  if (!(!s || !c)) try {
+    let e2 = await fetch(`${s.replace(/\/$/, "")}/app/billing/charge`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${c}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        creditsUsedMicro: r2,
+        quantity: a,
+        operationType: i,
+        resourceContext: o
+      }),
+      signal: AbortSignal.timeout(n)
+    });
+    if (!e2.ok) {
+      let t2 = await e2.text().catch(() => "");
+      console.error(`chargeCredits: ${e2.status} ${e2.statusText}: ${t2}`);
+    }
+  } catch (e2) {
+    console.error(`chargeCredits: ${e2 instanceof Error ? e2.message : String(e2)}`);
+  }
+};
+
+// src/logic-functions/domain/compute-call-recording-charge.util.ts
+var import_guards14 = __toESM(require_build());
+
+// src/logic-functions/constants/call-recording-micro-credits-per-hour.ts
+var CALL_RECORDING_MICRO_CREDITS_PER_HOUR = 1e6;
+
+// src/logic-functions/constants/milliseconds-per-minute.ts
+var MILLISECONDS_PER_MINUTE = 6e4;
+
+// src/logic-functions/domain/compute-call-recording-charge.util.ts
+var MILLISECONDS_PER_HOUR = 36e5;
+var computeCallRecordingCharge = ({
+  startedAt,
+  endedAt
+}) => {
+  if ((0, import_guards14.isUndefined)(startedAt) || (0, import_guards14.isUndefined)(endedAt)) {
+    return void 0;
+  }
+  const durationMilliseconds = new Date(endedAt).getTime() - new Date(startedAt).getTime();
+  if (!Number.isFinite(durationMilliseconds) || durationMilliseconds <= 0) {
+    return void 0;
+  }
+  return {
+    creditsUsedMicro: Math.round(
+      durationMilliseconds / MILLISECONDS_PER_HOUR * CALL_RECORDING_MICRO_CREDITS_PER_HOUR
+    ),
+    quantityMinutes: Math.max(
+      1,
+      Math.round(durationMilliseconds / MILLISECONDS_PER_MINUTE)
+    )
+  };
+};
+
+// src/logic-functions/flows/charge-completed-call-recording.util.ts
+var chargeCompletedCallRecording = async ({
+  callRecordingId,
+  startedAt,
+  endedAt
+}) => {
+  const charge = computeCallRecordingCharge({ startedAt, endedAt });
+  if ((0, import_guards15.isUndefined)(charge)) {
+    console.warn(
+      `[call-recorder] call recording ${callRecordingId} completed without usable recording timestamps; it will not be billed`
+    );
+    return;
+  }
+  await r({
+    creditsUsedMicro: charge.creditsUsedMicro,
+    quantity: charge.quantityMinutes,
+    operationType: "CALL_RECORDING",
+    resourceContext: "recall"
+  });
+};
+
+// src/logic-functions/flows/complete-and-charge-call-recording.util.ts
+var completeAndChargeCallRecording = async (client, {
+  id,
+  startedAt,
+  endedAt
+}) => {
+  const claimed = await completeCallRecordingIngestion(client, { id });
+  if (claimed) {
+    await chargeCompletedCallRecording({
+      callRecordingId: id,
+      startedAt,
+      endedAt
+    });
+  }
+  return claimed;
+};
+
+// src/logic-functions/domain/is-call-recording-ingestion-complete.util.ts
+var import_guards16 = __toESM(require_build());
+var isCallRecordingIngestionComplete = ({
+  transcript,
+  audio,
+  video
+}) => !(0, import_guards16.isNull)(transcript) && !(0, import_guards16.isUndefined)(transcript) && (0, import_guards16.isUndefined)(parseTranscriptMarker(transcript)) && (0, import_guards16.isNonEmptyArray)(audio) && (0, import_guards16.isNonEmptyArray)(video);
+
+// src/logic-functions/domain/should-complete-call-recording-ingestion.util.ts
+var shouldCompleteCallRecordingIngestion = ({
+  current,
+  updateData
+}) => current.status !== "COMPLETED" /* COMPLETED */ && current.status !== "FAILED" /* FAILED */ && updateData.status !== "FAILED" /* FAILED */ && computeCallRecordingCharge({
+  startedAt: updateData.startedAt ?? current.startedAt,
+  endedAt: updateData.endedAt ?? current.endedAt
+}) !== void 0 && isCallRecordingIngestionComplete({
+  transcript: updateData.transcript ?? current.transcript,
+  audio: updateData.audio ?? current.audio,
+  video: updateData.video ?? current.video
+});
+
+// src/logic-functions/data/update-call-recording.util.ts
+var updateCallRecording = async (client, {
+  id,
+  data
+}) => {
+  await client.mutation({
+    updateCallRecording: {
+      __args: {
+        id,
+        data
+      },
+      id: true
+    }
+  });
+};
+
+// src/logic-functions/flows/persist-call-recording-progress.util.ts
+var persistCallRecordingProgress = async (client, {
+  id,
+  current,
+  updateData
+}) => {
+  const completesIngestion = shouldCompleteCallRecordingIngestion({
+    current,
+    updateData
+  });
+  if (!completesIngestion) {
+    await updateCallRecording(client, { id, data: updateData });
+    return { completesIngestion: false };
+  }
+  const nonStatusUpdate = { ...updateData };
+  delete nonStatusUpdate.status;
+  delete nonStatusUpdate.callRecorderFailureReason;
+  if (Object.keys(nonStatusUpdate).length > 0) {
+    await updateCallRecording(client, { id, data: nonStatusUpdate });
+  }
+  await completeAndChargeCallRecording(client, {
+    id,
+    startedAt: updateData.startedAt ?? current.startedAt,
+    endedAt: updateData.endedAt ?? current.endedAt
+  });
+  return { completesIngestion: true };
+};
+
+// src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util.ts
+var import_guards19 = __toESM(require_build());
+
+// src/logic-functions/domain/build-pending-transcript-marker.util.ts
+var buildPendingTranscriptMarker = ({
+  recallTranscriptId,
+  requestedAt
+}) => ({
+  recallTranscriptId,
+  status: "PENDING",
+  requestedAt
+});
+
+// src/logic-functions/recall-api/create-async-recall-transcript.util.ts
+var import_guards17 = __toESM(require_build());
+var createAsyncRecallTranscript = async ({
+  externalRecordingId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const result = await recallBotApiRequest({
+    config: configResult.config,
+    path: `/recording/${externalRecordingId}/create_transcript/`,
+    method: "POST",
+    body: {
+      provider: { recallai_async: { language_code: "auto" } },
+      diarization: { use_separate_streams_when_available: true }
+    },
+    maxAttempts: 1
+  });
+  if (!result.ok) {
+    return result;
+  }
+  if (!(0, import_guards17.isString)(result.data?.id)) {
+    return {
+      ok: false,
+      status: null,
+      errorMessage: "Recall API created a transcript but the response did not include a transcript id"
+    };
+  }
+  return { ok: true, transcriptId: result.data.id };
+};
+
+// src/logic-functions/recall-api/list-recall-transcripts.util.ts
+var import_guards18 = __toESM(require_build());
+var RECALL_TRANSCRIPT_LIST_MAX_PAGES = 10;
+var listRecallTranscripts = async ({
+  externalRecordingId
+}) => {
+  const configResult = getRecallApiConfig();
+  if (!configResult.success) {
+    return { ok: false, status: null, errorMessage: configResult.error };
+  }
+  const transcripts = [];
+  let path = buildListRecallTranscriptsPath({
+    externalRecordingId
+  });
+  for (let pageIndex = 0; !(0, import_guards18.isUndefined)(path) && pageIndex < RECALL_TRANSCRIPT_LIST_MAX_PAGES; pageIndex++) {
+    const result = await recallBotApiRequest({
+      config: configResult.config,
+      path,
+      method: "GET"
+    });
+    if (!result.ok) {
+      return result;
+    }
+    const pageTranscripts = extractRecallTranscriptSummaries(result.data);
+    if ((0, import_guards18.isUndefined)(pageTranscripts)) {
+      return {
+        ok: false,
+        status: result.status,
+        errorMessage: "Recall API returned malformed transcript list"
+      };
+    }
+    transcripts.push(...pageTranscripts);
+    path = extractNextPath(result.data, configResult.config.baseUrl);
+  }
+  if (!(0, import_guards18.isUndefined)(path)) {
+    return {
+      ok: false,
+      status: null,
+      errorMessage: `Recall transcript list exceeded ${RECALL_TRANSCRIPT_LIST_MAX_PAGES} pages`
+    };
+  }
+  return { ok: true, transcripts };
+};
+var buildListRecallTranscriptsPath = ({
+  externalRecordingId
+}) => {
+  const searchParams = new URLSearchParams({
+    recording_id: externalRecordingId
+  });
+  return `/transcript/?${searchParams.toString()}`;
+};
+var extractRecallTranscriptSummaries = (response) => {
+  if (!(0, import_guards18.isArray)(response?.results)) {
+    return void 0;
+  }
+  const transcripts = [];
+  for (const result of response.results) {
+    const transcript = extractRecallTranscriptSummary(result);
+    if ((0, import_guards18.isUndefined)(transcript)) {
+      return void 0;
+    }
+    transcripts.push(transcript);
+  }
+  return transcripts;
+};
+var extractRecallTranscriptSummary = (transcript) => {
+  const transcriptRecord = asRecord(transcript);
+  const transcriptId = getString(transcriptRecord?.id);
+  if ((0, import_guards18.isUndefined)(transcriptRecord) || (0, import_guards18.isUndefined)(transcriptId)) {
+    return void 0;
+  }
+  const status = asRecord(transcriptRecord.status);
+  return {
+    id: transcriptId,
+    statusCode: getString(status?.code),
+    statusSubCode: getString(status?.sub_code)
+  };
+};
+var extractNextPath = (response, baseUrl) => {
+  const nextPage = getString(response?.next);
+  if ((0, import_guards18.isUndefined)(nextPage) || !nextPage.startsWith(baseUrl)) {
+    return void 0;
+  }
+  return nextPage.slice(baseUrl.length);
+};
+
+// src/logic-functions/flows/reconcile-call-recording-transcript-artifact.util.ts
+var reconcileCallRecordingTranscriptArtifact = async ({
+  callRecordingId,
+  currentStatus,
+  externalRecordingId,
+  requestedAt,
+  transcript
+}) => {
+  const existingTranscriptMarker = parseTranscriptMarker(transcript);
+  if (!(0, import_guards19.isNull)(transcript) && !(0, import_guards19.isUndefined)(transcript) && (0, import_guards19.isUndefined)(existingTranscriptMarker)) {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  if (existingTranscriptMarker?.status === "FAILED") {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  const listResult = await listRecallTranscripts({ externalRecordingId });
+  if (!listResult.ok) {
+    console.warn(
+      `[call-recorder] failed to list Recall transcripts for recording ${externalRecordingId}: ${listResult.errorMessage}`
+    );
+    return buildEmptyTranscriptArtifactResult();
+  }
+  const transcriptArtifact = selectRecallTranscriptArtifact(
+    listResult.transcripts
+  );
+  const pendingTranscriptMarkerRecallTranscriptId = existingTranscriptMarker?.status === "PENDING" ? existingTranscriptMarker.recallTranscriptId ?? void 0 : void 0;
+  const transcriptIdToDownload = transcriptArtifact?.id ?? pendingTranscriptMarkerRecallTranscriptId;
+  if ((0, import_guards19.isUndefined)(transcriptArtifact) && (0, import_guards19.isUndefined)(pendingTranscriptMarkerRecallTranscriptId)) {
+    const createResult = await createAsyncRecallTranscript({
+      externalRecordingId
+    });
+    if (!createResult.ok) {
+      console.warn(
+        `[call-recorder] failed to request transcript for Recall recording ${externalRecordingId}: ${createResult.errorMessage}`
+      );
+      return buildEmptyTranscriptArtifactResult();
+    }
+    return {
+      updateData: {
+        transcript: buildPendingTranscriptMarker({
+          recallTranscriptId: createResult.transcriptId,
+          requestedAt
+        })
+      },
+      requestedTranscript: true
+    };
+  }
+  if (!(0, import_guards19.isUndefined)(transcriptArtifact) && (transcriptArtifact.statusCode === "failed" || transcriptArtifact.statusCode === "error")) {
+    return {
+      updateData: buildTranscriptFailureUpdate({
+        currentStatus,
+        transcriptId: transcriptArtifact.id,
+        subCode: transcriptArtifact.statusSubCode ?? null
+      }),
+      requestedTranscript: false
+    };
+  }
+  if (!(0, import_guards19.isUndefined)(transcriptArtifact) && transcriptArtifact.statusCode !== "done") {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  if ((0, import_guards19.isUndefined)(transcriptIdToDownload)) {
+    return buildEmptyTranscriptArtifactResult();
+  }
+  const downloadResult = await downloadTranscript({
+    transcriptId: transcriptIdToDownload
+  });
+  if (downloadResult.outcome === "filled") {
+    return {
+      updateData: {
+        transcript: downloadResult.content
+      },
+      requestedTranscript: false
+    };
+  }
+  if (downloadResult.outcome === "failed") {
+    return {
+      updateData: buildTranscriptFailureUpdate({
+        currentStatus,
+        transcriptId: transcriptIdToDownload,
+        subCode: downloadResult.subCode
+      }),
+      requestedTranscript: false
+    };
+  }
+  if (downloadResult.outcome === "error") {
+    console.warn(
+      `[call-recorder] could not fill transcript for call recording ${callRecordingId}: ${downloadResult.errorMessage}`
+    );
+  }
+  return buildEmptyTranscriptArtifactResult();
+};
+var buildEmptyTranscriptArtifactResult = () => ({
+  updateData: {},
+  requestedTranscript: false
+});
+var selectRecallTranscriptArtifact = (transcripts) => transcripts.find((transcript) => transcript.statusCode !== "deleted");
+var buildTranscriptFailureUpdate = ({
+  currentStatus,
+  transcriptId,
+  subCode
+}) => ({
+  transcript: buildFailedTranscriptMarker({
+    recallTranscriptId: transcriptId,
+    subCode
+  }),
+  callRecorderFailureReason: buildTranscriptFailureReason(subCode),
+  ...isCallRecordingStatusDowngrade({
+    fromStatus: currentStatus,
+    toStatus: "FAILED" /* FAILED */
+  }) ? {} : { status: "FAILED" /* FAILED */ }
+});
+
+// src/logic-functions/flows/handle-recall-webhook.util.ts
+var handleRecallWebhook = async ({
+  client,
+  body
+}) => {
+  const webhookEvent = parseRecallWebhookEvent(body);
+  if ((0, import_guards20.isUndefined)(webhookEvent)) {
+    return {
+      status: "skipped",
+      event: null,
+      reason: "missing event type"
+    };
+  }
+  const { event } = webhookEvent;
+  if (event === "transcript.done" || event === "transcript.failed") {
+    return handleRecallTranscriptEvent({ client, webhookEvent, event });
+  }
+  return handleRecallStatusEvent({ client, webhookEvent });
+};
+var handleRecallStatusEvent = async ({
+  client,
+  webhookEvent
+}) => {
+  const { event, statusCode } = webhookEvent;
+  const callRecordingStatus = mapRecallEventToCallRecordingStatus({
+    event,
+    statusCode
+  });
+  if ((0, import_guards20.isUndefined)(callRecordingStatus)) {
+    return {
+      status: "skipped",
+      event,
+      reason: `unsupported Recall event status ${statusCode ?? event}`
+    };
+  }
+  const callRecording = await findMatchingCallRecording({
+    client,
+    webhookEvent
+  });
+  if ((0, import_guards20.isUndefined)(callRecording)) {
+    return {
+      status: "skipped",
+      event,
+      reason: "no matching call recording"
+    };
+  }
+  if (isCallRecordingStatusDowngrade({
+    fromStatus: callRecording.status,
+    toStatus: callRecordingStatus
+  })) {
+    return {
+      status: "skipped",
+      event,
+      reason: `stale status event (${callRecording.status} -> ${callRecordingStatus})`
+    };
+  }
+  const updateData = {
+    ...(0, import_guards20.isUndefined)(webhookEvent.externalBotId) ? {} : { externalBotId: webhookEvent.externalBotId },
+    ...buildExternalRecordingIdUpdate(webhookEvent),
+    ...buildCallRecordingStatusUpdate({
+      reason: getRecallWebhookFailureReason(webhookEvent),
+      status: callRecordingStatus
+    }),
+    ...buildRecordingTimestampsUpdate({ webhookEvent, callRecording })
+  };
+  if (isRecallRecordingDoneSignal({ event, statusCode })) {
+    const externalRecordingIdResolution = await resolveExternalRecordingId({
+      callRecording,
+      webhookEvent
+    });
+    Object.assign(
+      updateData,
+      await buildTranscriptArtifactUpdate({
+        callRecording,
+        externalRecordingId: externalRecordingIdResolution.externalRecordingId
+      })
+    );
+    Object.assign(
+      updateData,
+      await buildMediaIngestionUpdate({
+        callRecording,
+        externalRecordingId: externalRecordingIdResolution.externalRecordingId
+      })
+    );
+    const terminalArtifactGateFailureUpdate = buildTerminalArtifactGateFailureUpdate({
+      callRecording,
+      providerLookupFailed: externalRecordingIdResolution.providerLookupFailed,
+      updateData,
+      webhookEvent
+    });
+    if (!(0, import_guards20.isUndefined)(terminalArtifactGateFailureUpdate)) {
+      Object.assign(updateData, terminalArtifactGateFailureUpdate);
+    }
+  }
+  const { completesIngestion } = await persistCallRecordingProgress(client, {
+    id: callRecording.id,
+    current: callRecording,
+    updateData
+  });
+  return {
+    status: "updated",
+    event,
+    callRecordingId: callRecording.id,
+    callRecordingStatus: completesIngestion ? "COMPLETED" /* COMPLETED */ : updateData.status ?? callRecordingStatus
+  };
+};
+var findMatchingCallRecording = async ({
+  client,
+  webhookEvent
+}) => {
+  if (!(0, import_guards20.isUndefined)(webhookEvent.callRecordingIdFromMetadata)) {
+    return findCallRecordingByFilter(client, {
+      id: { eq: webhookEvent.callRecordingIdFromMetadata }
+    });
+  }
+  if ((0, import_guards20.isUndefined)(webhookEvent.externalBotId)) {
+    return void 0;
+  }
+  return findCallRecordingByFilter(client, {
+    externalBotId: { eq: webhookEvent.externalBotId }
+  });
+};
+var findCallRecordingByFilter = async (client, filter) => {
+  const queryResult = await client.query({
+    callRecordings: {
+      __args: {
+        filter,
+        first: 1
+      },
+      edges: {
+        node: {
+          id: true,
+          status: true,
+          startedAt: true,
+          endedAt: true,
+          externalRecordingId: true,
+          transcript: true,
+          audio: { fileId: true },
+          video: { fileId: true }
+        }
+      }
+    }
+  });
+  const node = queryResult.callRecordings?.edges?.[0]?.node;
+  if ((0, import_guards20.isUndefined)(node) || (0, import_guards20.isNull)(node)) {
+    return void 0;
+  }
+  return {
+    id: node.id,
+    status: getString(node.status),
+    startedAt: getString(node.startedAt),
+    endedAt: getString(node.endedAt),
+    externalRecordingId: getString(node.externalRecordingId),
+    transcript: node.transcript ?? void 0,
+    audio: node.audio ?? void 0,
+    video: node.video ?? void 0
+  };
+};
+var mapRecallEventToCallRecordingStatus = ({
+  event,
+  statusCode
+}) => {
+  if (event === "recording.done") {
+    return "PROCESSING" /* PROCESSING */;
+  }
+  if (event === "recording.failed") {
+    return "FAILED" /* FAILED */;
+  }
+  return mapRecallStatusCodeToCallRecordingStatus(statusCode);
+};
+var buildRecordingTimestampsUpdate = ({
+  webhookEvent,
+  callRecording
+}) => {
+  const { event, statusCode, statusTimestamp } = webhookEvent;
+  const impliesRecordingStarted = statusCode === "in_call_recording";
+  const impliesRecordingEnded = event === "recording.done" || statusCode === "call_ended" || statusCode === "done";
+  const startedAt = webhookEvent.recordingStartedAt ?? (impliesRecordingStarted ? statusTimestamp : void 0);
+  const endedAt = webhookEvent.recordingEndedAt ?? (impliesRecordingEnded ? statusTimestamp : void 0);
+  return {
+    ...!(0, import_guards20.isUndefined)(startedAt) && (0, import_guards20.isUndefined)(callRecording.startedAt) ? { startedAt } : {},
+    ...!(0, import_guards20.isUndefined)(endedAt) && (0, import_guards20.isUndefined)(callRecording.endedAt) ? { endedAt } : {}
+  };
+};
+var buildExternalRecordingIdUpdate = (webhookEvent) => (0, import_guards20.isUndefined)(webhookEvent.externalRecordingId) ? {} : { externalRecordingId: webhookEvent.externalRecordingId };
+var buildCallRecordingStatusUpdate = ({
+  reason,
+  status
+}) => {
+  if (status === "FAILED" /* FAILED */) {
+    return { status, callRecorderFailureReason: reason };
+  }
+  return { status };
+};
+var buildTerminalArtifactGateFailureUpdate = ({
+  callRecording,
+  providerLookupFailed,
+  updateData,
+  webhookEvent
+}) => {
+  if (updateData.status === "FAILED" /* FAILED */) {
+    return (0, import_guards20.isUndefined)(updateData.callRecorderFailureReason) ? {
+      status: "FAILED" /* FAILED */,
+      callRecorderFailureReason: getRecallWebhookFailureReason(webhookEvent)
+    } : void 0;
+  }
+  if (providerLookupFailed || hasRecordingArtifactPath({ callRecording, updateData })) {
+    return void 0;
+  }
+  return {
+    status: "FAILED" /* FAILED */,
+    callRecorderFailureReason: "recording_artifacts_unavailable"
+  };
+};
+var getRecallWebhookFailureReason = ({
+  event,
+  statusCode
+}) => statusCode ?? event;
+var hasRecordingArtifactPath = ({
+  callRecording,
+  updateData
+}) => {
+  return !(0, import_guards20.isUndefined)(
+    updateData.externalRecordingId ?? callRecording.externalRecordingId
+  ) || (0, import_guards20.isNonEmptyArray)(updateData.audio ?? callRecording.audio) || (0, import_guards20.isNonEmptyArray)(updateData.video ?? callRecording.video) || hasReachableTranscript(updateData.transcript ?? callRecording.transcript);
+};
+var hasReachableTranscript = (transcript) => {
+  if ((0, import_guards20.isNull)(transcript) || (0, import_guards20.isUndefined)(transcript)) {
+    return false;
+  }
+  const marker = parseTranscriptMarker(transcript);
+  return (0, import_guards20.isUndefined)(marker) || marker.status === "PENDING";
+};
+var isTranscriptUnset = (callRecording) => (0, import_guards20.isUndefined)(callRecording.transcript);
+var buildMediaIngestionUpdate = async ({
+  callRecording,
+  externalRecordingId
+}) => {
+  const hasAudio = (0, import_guards20.isNonEmptyArray)(callRecording.audio);
+  const hasVideo = (0, import_guards20.isNonEmptyArray)(callRecording.video);
+  if (hasAudio && hasVideo) {
+    return {};
+  }
+  if ((0, import_guards20.isUndefined)(externalRecordingId)) {
+    console.warn(
+      `[call-recorder] cannot ingest media for call recording ${callRecording.id}: no Recall recording id available`
+    );
+    return {};
+  }
+  return ingestCallRecordingMedia({
+    callRecordingId: callRecording.id,
+    externalRecordingId,
+    hasAudio,
+    hasVideo
+  });
+};
+var buildTranscriptArtifactUpdate = async ({
+  callRecording,
+  externalRecordingId
+}) => {
+  if ((0, import_guards20.isUndefined)(externalRecordingId)) {
+    console.warn(
+      `[call-recorder] cannot reconcile transcript for call recording ${callRecording.id}: no Recall recording id available`
+    );
+    return {};
+  }
+  const transcriptArtifactResult = await reconcileCallRecordingTranscriptArtifact({
+    callRecordingId: callRecording.id,
+    currentStatus: callRecording.status,
+    externalRecordingId,
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    transcript: callRecording.transcript
+  });
+  return {
+    ...(0, import_guards20.isUndefined)(callRecording.externalRecordingId) ? { externalRecordingId } : {},
+    ...transcriptArtifactResult.updateData
+  };
+};
+var resolveExternalRecordingId = async ({
+  callRecording,
+  webhookEvent
+}) => {
+  const externalRecordingId = webhookEvent.externalRecordingId ?? callRecording.externalRecordingId;
+  if (!(0, import_guards20.isUndefined)(externalRecordingId)) {
+    return { externalRecordingId, providerLookupFailed: false };
+  }
+  if ((0, import_guards20.isUndefined)(webhookEvent.externalBotId)) {
+    return { externalRecordingId: void 0, providerLookupFailed: false };
+  }
+  return fetchExternalRecordingIdFromRecallBot(webhookEvent.externalBotId);
+};
+var fetchExternalRecordingIdFromRecallBot = async (externalBotId) => {
+  const botResult = await getRecallBot({ externalBotId });
+  if (!botResult.ok) {
+    console.warn(
+      `[call-recorder] failed to fetch Recall bot ${externalBotId} while resolving a recording id: ${botResult.errorMessage}`
+    );
+    return { externalRecordingId: void 0, providerLookupFailed: true };
+  }
+  return {
+    externalRecordingId: extractRecallBotConvergence(botResult.bot).externalRecordingId,
+    providerLookupFailed: false
+  };
+};
+var handleRecallTranscriptEvent = async ({
+  client,
+  webhookEvent,
+  event
+}) => {
+  const callRecording = await findMatchingCallRecording({
+    client,
+    webhookEvent
+  });
+  if ((0, import_guards20.isUndefined)(callRecording)) {
+    return {
+      status: "skipped",
+      event,
+      reason: "no matching call recording"
+    };
+  }
+  const { transcriptId } = webhookEvent;
+  if (event === "transcript.failed") {
+    return applyTranscriptFailure({
+      client,
+      callRecording,
+      event,
+      transcriptId,
+      subCode: webhookEvent.transcriptFailureSubCode ?? null
+    });
+  }
+  if ((0, import_guards20.isUndefined)(transcriptId)) {
+    return {
+      status: "skipped",
+      event,
+      reason: "missing transcript id"
+    };
+  }
+  const downloadResult = await downloadTranscript({ transcriptId });
+  switch (downloadResult.outcome) {
+    case "filled": {
+      const updateData = {
+        transcript: downloadResult.content,
+        ...(0, import_guards20.isUndefined)(callRecording.externalRecordingId) ? buildExternalRecordingIdUpdate(webhookEvent) : {}
+      };
+      await persistCallRecordingProgress(client, {
+        id: callRecording.id,
+        current: callRecording,
+        updateData
+      });
+      return {
+        status: "updated",
+        event,
+        callRecordingId: callRecording.id,
+        transcriptOutcome: "FILLED"
+      };
+    }
+    case "failed":
+      return applyTranscriptFailure({
+        client,
+        callRecording,
+        event,
+        transcriptId,
+        subCode: downloadResult.subCode
+      });
+    case "pending":
+    case "error": {
+      const reason = downloadResult.outcome === "pending" ? "transcript not downloadable yet" : downloadResult.errorMessage;
+      console.warn(
+        `[call-recorder] could not fill transcript for call recording ${callRecording.id}: ${reason}`
+      );
+      return {
+        status: "skipped",
+        event,
+        reason
+      };
+    }
+  }
+};
+var applyTranscriptFailure = async ({
+  client,
+  callRecording,
+  event,
+  transcriptId,
+  subCode
+}) => {
+  const existingMarker = parseTranscriptMarker(callRecording.transcript);
+  if (!isTranscriptUnset(callRecording) && (0, import_guards20.isUndefined)(existingMarker)) {
+    return {
+      status: "skipped",
+      event,
+      reason: "transcript already filled"
+    };
+  }
+  console.warn(
+    `[call-recorder] transcript failed for call recording ${callRecording.id}${(0, import_guards20.isNull)(subCode) ? "" : ` (${subCode})`}`
+  );
+  await updateCallRecording(client, {
+    id: callRecording.id,
+    data: {
+      transcript: buildFailedTranscriptMarker({
+        recallTranscriptId: transcriptId ?? existingMarker?.recallTranscriptId ?? null,
+        subCode
+      }),
+      callRecorderFailureReason: buildTranscriptFailureReason(subCode),
+      ...isCallRecordingStatusDowngrade({
+        fromStatus: callRecording.status,
+        toStatus: "FAILED" /* FAILED */
+      }) ? {} : { status: "FAILED" /* FAILED */ }
+    }
+  });
+  return {
+    status: "updated",
+    event,
+    callRecordingId: callRecording.id,
+    transcriptOutcome: "FAILED"
+  };
+};
+
+// src/logic-functions/process-recall-webhook.ts
+var processRecallWebhookHandler = (body) => handleRecallWebhook({
+  client: new CoreApiClient(),
+  body
+});
+var process_recall_webhook_default = defineLogicFunction({
+  universalIdentifier: PROCESS_RECALL_WEBHOOK_LOGIC_FUNCTION_UNIVERSAL_IDENTIFIER,
+  name: "process-recall-webhook",
+  description: "Updates the matching CallRecording lifecycle status from a verified Recall.ai webhook event.",
+  timeoutSeconds: 30,
+  handler: processRecallWebhookHandler
+});
+export {
+  process_recall_webhook_default as default,
+  processRecallWebhookHandler
+};
+//# sourceMappingURL=process-recall-webhook.mjs.map