@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/actions/voice-call.js

@@ -0,0 +1,756 @@
+import {
+  logger,
+  requireConfirmation,
+  resolveActionArgs
+} from "@elizaos/core";
+import {
+  readTwilioCredentialsFromEnv,
+  sendTwilioVoiceCall
+} from "@elizaos/plugin-phone/twilio";
+import { hasLifeOpsAccess } from "../lifeops/access.js";
+import { LifeOpsService } from "../lifeops/service.js";
+const ACTION_NAME = "VOICE_CALL";
+const OWNER_NUMBER_ENV_KEYS = [
+  "ELIZA_E2E_TWILIO_RECIPIENT",
+  "TWILIO_OWNER_NUMBER"
+];
+const EXTERNAL_ALLOWLIST_ENV_KEY = "TWILIO_CALL_EXTERNAL_ALLOWLIST";
+const E164_RE = /^\+[1-9]\d{1,14}$/;
+const PLACEHOLDER_555_RE = /^\+?1?[-\s]?\(?5{3}\)?[-\s]?5{3}[-\s]?5{4}$/;
+const SUBACTIONS = {
+  dial: {
+    description: "Outbound Twilio voice call. recipientKind: owner escalation env owner number + standing-policy ack; external third party RelationshipStore + allow-list; e164 raw phoneNumber. Draft first; confirmed:true dispatch.",
+    descriptionCompressed: "Twilio voice dial: recipientKind=owner|external|e164; draft-confirm; approval-queue",
+    required: ["recipientKind"],
+    optional: ["phoneNumber", "recipient", "bodyText", "confirmed", "reason"]
+  }
+};
+function isE164(value) {
+  return E164_RE.test(value);
+}
+function isE164PhoneNumber(value) {
+  return /^\+[1-9]\d{7,14}$/.test(value.trim());
+}
+function isPlaceholderOrNonNumeric(value) {
+  if (PLACEHOLDER_555_RE.test(value)) return true;
+  if (/[a-zA-Z]/.test(value)) return true;
+  return false;
+}
+function normalizeLookup(value) {
+  return value.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function messageText(message) {
+  return typeof message.content.text === "string" ? message.content.text : "";
+}
+function isStandingOwnerCallPolicy(message) {
+  const text = normalizeLookup(messageText(message));
+  if (!text) {
+    return false;
+  }
+  const isConditional = /\b(if|when|whenever)\b/.test(text) || /\bget stuck\b/.test(text) || /\bblocked\b/.test(text);
+  const mentionsCall = /\b(call|phone|dial)\b/.test(text);
+  const mentionsBlockedWork = /\b(stuck|blocked|jam|jams|unblock)\b/.test(text) && /\b(browser|computer|desktop|remote|workflow|machine)\b/.test(text);
+  return isConditional && mentionsCall && mentionsBlockedWork;
+}
+function buildCallUserPolicyAcknowledgement(userText) {
+  const normalized = userText.trim().toLowerCase();
+  if (!normalized) {
+    return null;
+  }
+  const isStandingEscalationPolicy = /\bif\b/u.test(normalized) && /\b(?:stuck|blocked|jammed|jams|unblock|can't continue|cannot continue)\b/u.test(
+    normalized
+  ) && /\b(?:browser|computer|desktop|screen|remote workflow|on my machine)\b/u.test(
+    normalized
+  ) && /\b(?:call me|phone me|ring me|dial me)\b/u.test(normalized);
+  if (!isStandingEscalationPolicy) {
+    return null;
+  }
+  return {
+    text: "If I get stuck in the browser or on your computer, I'll escalate by phone so you can jump in and unblock it. I will still require confirmation before placing an actual call.",
+    success: true,
+    values: {
+      success: true,
+      policyRecorded: true
+    },
+    data: {
+      actionName: ACTION_NAME,
+      action: "dial",
+      subaction: "dial",
+      recipientKind: "owner",
+      policyRecorded: true,
+      policyType: "stuck_computer_phone_escalation",
+      channel: "phone_call"
+    }
+  };
+}
+function readOwnerNumber(runtime) {
+  for (const key of OWNER_NUMBER_ENV_KEYS) {
+    const envVal = process.env[key]?.trim();
+    if (envVal) return envVal;
+    const setting = runtime?.getSetting?.(key);
+    if (typeof setting === "string" && setting.trim().length > 0) {
+      return setting.trim();
+    }
+  }
+  return null;
+}
+function readExternalAllowList(runtime) {
+  const raw = process.env[EXTERNAL_ALLOWLIST_ENV_KEY] ?? (() => {
+    const s = runtime?.getSetting?.(EXTERNAL_ALLOWLIST_ENV_KEY);
+    return typeof s === "string" ? s : void 0;
+  })();
+  const list = /* @__PURE__ */ new Set();
+  if (raw) {
+    for (const part of raw.split(/[\s,;]+/)) {
+      const trimmed = part.trim();
+      if (trimmed) list.add(trimmed);
+    }
+  }
+  const owner = readOwnerNumber(runtime);
+  if (owner) list.add(owner);
+  return Array.from(list);
+}
+function normalizePhoneAllowListKey(value) {
+  return value.replace(/[^0-9+]/g, "").replace(/^\+/, "");
+}
+function getPendingCallCacheKey(roomId, actionName) {
+  return `lifeops:twilio-call:pending:${actionName}:${roomId}`;
+}
+async function readPendingCallDraft(runtime, roomId, actionName) {
+  if (typeof runtime.getCache !== "function") {
+    return null;
+  }
+  return await runtime.getCache(
+    getPendingCallCacheKey(roomId, actionName)
+  ) ?? null;
+}
+async function clearPendingCallDraft(runtime, roomId, actionName) {
+  if (typeof runtime.deleteCache !== "function") {
+    return;
+  }
+  await runtime.deleteCache(getPendingCallCacheKey(roomId, actionName));
+}
+async function resolveExternalCallRecipient(args) {
+  const explicit = args.providedTo?.trim();
+  if (explicit && isE164PhoneNumber(explicit)) {
+    return { to: explicit, matchedRelationshipId: null };
+  }
+  const service = new LifeOpsService(args.runtime);
+  const relationships = await service.listRelationships({ limit: 200 });
+  const haystack = normalizeLookup(
+    [explicit ?? "", args.messageText ?? ""].join(" ")
+  );
+  if (!haystack) {
+    return { to: null, matchedRelationshipId: null };
+  }
+  const candidates = relationships.filter(
+    (relationship) => typeof relationship.phone === "string" && relationship.phone
+  );
+  for (const relationship of candidates) {
+    const lookupValues = [
+      relationship.name,
+      relationship.primaryHandle,
+      relationship.email ?? "",
+      relationship.notes ?? "",
+      ...relationship.tags
+    ].map(normalizeLookup).filter((value) => value.length > 0);
+    const matched = lookupValues.some(
+      (value) => haystack.includes(value) || value.includes(haystack)
+    );
+    if (matched && relationship.phone) {
+      return {
+        to: relationship.phone,
+        matchedRelationshipId: relationship.id
+      };
+    }
+  }
+  return { to: explicit ?? null, matchedRelationshipId: null };
+}
+function deliveryToResult(delivery, to, recipientKind) {
+  return {
+    text: delivery.ok ? `Placed call to ${to}.` : `Call to ${to} failed.`,
+    success: delivery.ok,
+    values: {
+      success: delivery.ok,
+      to,
+      sid: delivery.sid ?? null
+    },
+    data: {
+      actionName: ACTION_NAME,
+      action: "dial",
+      subaction: "dial",
+      recipientKind,
+      to,
+      sid: delivery.sid ?? null,
+      status: delivery.status,
+      error: delivery.error,
+      retryCount: delivery.retryCount ?? 0
+    }
+  };
+}
+function invalidPhoneResult(to, contact, recipientKind, errorCode) {
+  const subject = contact ?? "this contact";
+  const text = errorCode === "PLACEHOLDER_PHONE_NUMBER" ? `"${to}" looks like a placeholder phone number. Please share the real E.164 number (e.g. +15551234567) for ${subject} before I can place the call.` : `I need a valid phone number in E.164 format (e.g. +15551234567) to place the call. Please confirm the number for ${subject}.`;
+  return {
+    text,
+    success: false,
+    values: { success: false, error: errorCode, to, contact: contact ?? null },
+    data: {
+      actionName: ACTION_NAME,
+      action: "dial",
+      subaction: "dial",
+      recipientKind,
+      error: errorCode,
+      to,
+      contact: contact ?? null
+    }
+  };
+}
+async function dialE164(runtime, message, params) {
+  const credentials = readTwilioCredentialsFromEnv();
+  if (!credentials) {
+    return {
+      text: "Twilio is not configured. Set TWILIO_ACCOUNT_SID, TWILIO_AUTH_TOKEN, and TWILIO_PHONE_NUMBER.",
+      success: false,
+      values: { success: false, error: "TWILIO_NOT_CONFIGURED" },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "e164"
+      }
+    };
+  }
+  const to = (params.phoneNumber ?? "").trim();
+  if (!to) {
+    return {
+      text: "Missing required parameter: phoneNumber (E.164 phone number).",
+      success: false,
+      values: { success: false, error: "MISSING_TO" },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "e164"
+      }
+    };
+  }
+  if (isPlaceholderOrNonNumeric(to)) {
+    return invalidPhoneResult(
+      to,
+      void 0,
+      "e164",
+      "PLACEHOLDER_PHONE_NUMBER"
+    );
+  }
+  if (!isE164(to)) {
+    return invalidPhoneResult(to, void 0, "e164", "INVALID_PHONE_NUMBER");
+  }
+  const messageBody = (params.bodyText ?? "").trim();
+  if (!messageBody) {
+    return {
+      text: "Missing required parameter: bodyText.",
+      success: false,
+      values: { success: false, error: "MISSING_MESSAGE" },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "e164"
+      }
+    };
+  }
+  const callPrompt = `Place voice call to ${to} with message: "${messageBody}"?`;
+  const decision = await requireConfirmation({
+    runtime,
+    message,
+    actionName: ACTION_NAME,
+    pendingKey: `e164:${to}`,
+    prompt: callPrompt
+  });
+  if (decision.status !== "confirmed") {
+    return {
+      text: decision.status === "pending" ? `${callPrompt} Reply yes to confirm or no to cancel.` : "Voice call cancelled.",
+      success: false,
+      values: {
+        success: false,
+        error: decision.status === "pending" ? "DRAFT_REQUIRES_CONFIRMATION" : "CANCELLED",
+        draft: decision.status === "pending",
+        to,
+        message: messageBody
+      },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "e164",
+        draft: decision.status === "pending",
+        to,
+        message: messageBody,
+        awaitingUserInput: decision.status === "pending"
+      }
+    };
+  }
+  const result = await sendTwilioVoiceCall({
+    credentials,
+    to,
+    message: messageBody
+  });
+  if (!result.ok) {
+    return {
+      text: `Voice call to ${to} failed: ${result.error ?? "unknown error"}.`,
+      success: false,
+      values: {
+        success: false,
+        error: result.error ?? "CALL_FAILED",
+        status: result.status
+      },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "e164",
+        to,
+        message: messageBody,
+        status: result.status,
+        retryCount: result.retryCount
+      }
+    };
+  }
+  return {
+    text: `Placed voice call to ${to}.`,
+    success: true,
+    values: { success: true, to, sid: result.sid ?? null },
+    data: {
+      actionName: ACTION_NAME,
+      action: "dial",
+      subaction: "dial",
+      recipientKind: "e164",
+      to,
+      message: messageBody,
+      sid: result.sid ?? null,
+      status: result.status,
+      retryCount: result.retryCount
+    }
+  };
+}
+async function dialOwner(runtime, message, params) {
+  const policyAcknowledgement = buildCallUserPolicyAcknowledgement(
+    messageText(message)
+  );
+  if (policyAcknowledgement) {
+    return policyAcknowledgement;
+  }
+  const pendingDraft = await readPendingCallDraft(
+    runtime,
+    message.roomId,
+    "CALL_USER"
+  );
+  if (params.confirmed !== true && isStandingOwnerCallPolicy(message)) {
+    return {
+      text: "Recorded. If I get stuck in the browser or on your computer, I'll escalate by phone so you can jump in to unblock it.",
+      success: true,
+      values: {
+        success: true,
+        policyRecorded: true,
+        channel: "phone_call"
+      },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "owner",
+        policyRecorded: true,
+        channel: "phone_call"
+      }
+    };
+  }
+  const to = readOwnerNumber(runtime);
+  if (!to) {
+    logger.warn(
+      { action: ACTION_NAME, recipientKind: "owner" },
+      `[${ACTION_NAME}] owner phone number not configured`
+    );
+    return {
+      text: "",
+      success: false,
+      values: { success: false, error: "OWNER_NUMBER_NOT_CONFIGURED" },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "owner",
+        error: "OWNER_NUMBER_NOT_CONFIGURED"
+      }
+    };
+  }
+  if (!isE164(to) || isPlaceholderOrNonNumeric(to)) {
+    return invalidPhoneResult(
+      to,
+      "the owner",
+      "owner",
+      isPlaceholderOrNonNumeric(to) ? "PLACEHOLDER_PHONE_NUMBER" : "INVALID_PHONE_NUMBER"
+    );
+  }
+  const credentials = readTwilioCredentialsFromEnv();
+  if (!credentials) {
+    return {
+      text: "",
+      success: false,
+      values: { success: false, error: "TWILIO_NOT_CONFIGURED" },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "owner",
+        error: "TWILIO_NOT_CONFIGURED"
+      }
+    };
+  }
+  const spokenMessage = params.bodyText?.trim() || pendingDraft?.message?.trim() || "Your agent is calling you.";
+  const ownerPrompt = `Place voice call to owner ${to} with message: "${spokenMessage}"?`;
+  const ownerDecision = await requireConfirmation({
+    runtime,
+    message,
+    actionName: "VOICE_CALL_OWNER",
+    pendingKey: `owner:${to}`,
+    prompt: ownerPrompt
+  });
+  if (ownerDecision.status !== "confirmed") {
+    return {
+      text: ownerDecision.status === "pending" ? `${ownerPrompt} Reply yes to confirm or no to cancel.` : "Voice call cancelled.",
+      success: false,
+      values: {
+        success: false,
+        requiresConfirmation: ownerDecision.status === "pending"
+      },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "owner",
+        requiresConfirmation: ownerDecision.status === "pending",
+        awaitingUserInput: ownerDecision.status === "pending"
+      }
+    };
+  }
+  const delivery = await sendTwilioVoiceCall({
+    credentials,
+    to,
+    message: spokenMessage
+  });
+  const result = deliveryToResult(delivery, to, "owner");
+  if (result.success) {
+    await clearPendingCallDraft(runtime, message.roomId, "CALL_USER");
+    if (pendingDraft?.approvalTaskId && typeof runtime.deleteTask === "function") {
+      await runtime.deleteTask(pendingDraft.approvalTaskId);
+    }
+  }
+  return result;
+}
+async function dialExternal(runtime, message, params) {
+  const pendingDraft = await readPendingCallDraft(
+    runtime,
+    message.roomId,
+    "CALL_EXTERNAL"
+  );
+  const resolvedRecipient = await resolveExternalCallRecipient({
+    runtime,
+    providedTo: params.recipient ?? pendingDraft?.to ?? void 0,
+    messageText: messageText(message)
+  });
+  const to = resolvedRecipient.to?.trim();
+  if (!to) {
+    return {
+      text: "Who should I call, or which saved contact/phone number should I use?",
+      success: false,
+      values: {
+        success: false,
+        error: "MISSING_RECIPIENT",
+        requiresConfirmation: true
+      },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "external",
+        error: "MISSING_RECIPIENT",
+        requiresConfirmation: true
+      }
+    };
+  }
+  if (isPlaceholderOrNonNumeric(to)) {
+    return invalidPhoneResult(
+      to,
+      void 0,
+      "external",
+      "PLACEHOLDER_PHONE_NUMBER"
+    );
+  }
+  if (!isE164(to)) {
+    return invalidPhoneResult(
+      to,
+      void 0,
+      "external",
+      "INVALID_PHONE_NUMBER"
+    );
+  }
+  const spokenMessage = params.bodyText?.trim() || pendingDraft?.message?.trim() || "This is a call from an automated assistant.";
+  const externalPrompt = `Place voice call to ${to} with message: "${spokenMessage}"?`;
+  const externalDecision = await requireConfirmation({
+    runtime,
+    message,
+    actionName: "VOICE_CALL_EXTERNAL",
+    pendingKey: `external:${to}`,
+    prompt: externalPrompt
+  });
+  if (externalDecision.status !== "confirmed") {
+    return {
+      text: externalDecision.status === "pending" ? `${externalPrompt} Reply yes to confirm or no to cancel.` : "Voice call cancelled.",
+      success: false,
+      values: {
+        success: false,
+        requiresConfirmation: externalDecision.status === "pending",
+        to
+      },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "external",
+        requiresConfirmation: externalDecision.status === "pending",
+        awaitingUserInput: externalDecision.status === "pending",
+        to,
+        matchedRelationshipId: resolvedRecipient.matchedRelationshipId ?? null
+      }
+    };
+  }
+  const allowList = readExternalAllowList(runtime);
+  const normalizedTo = normalizePhoneAllowListKey(to);
+  const isAllowed = allowList.some(
+    (candidate) => normalizePhoneAllowListKey(candidate) === normalizedTo
+  );
+  if (!isAllowed) {
+    logger.warn(
+      { action: ACTION_NAME, recipientKind: "external", to },
+      `[${ACTION_NAME}] recipient not in allow-list`
+    );
+    return {
+      text: "",
+      success: false,
+      values: { success: false, reason: "disallowed-recipient", to },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "external",
+        reason: "disallowed-recipient",
+        to,
+        matchedRelationshipId: resolvedRecipient.matchedRelationshipId ?? null
+      }
+    };
+  }
+  const credentials = readTwilioCredentialsFromEnv();
+  if (!credentials) {
+    return {
+      text: "",
+      success: false,
+      values: { success: false, error: "TWILIO_NOT_CONFIGURED" },
+      data: {
+        actionName: ACTION_NAME,
+        action: "dial",
+        subaction: "dial",
+        recipientKind: "external",
+        error: "TWILIO_NOT_CONFIGURED"
+      }
+    };
+  }
+  const delivery = await sendTwilioVoiceCall({
+    credentials,
+    to,
+    message: spokenMessage
+  });
+  const result = deliveryToResult(delivery, to, "external");
+  if (result.success) {
+    await clearPendingCallDraft(runtime, message.roomId, "CALL_EXTERNAL");
+    if (pendingDraft?.approvalTaskId && typeof runtime.deleteTask === "function") {
+      await runtime.deleteTask(pendingDraft.approvalTaskId);
+    }
+  }
+  return result;
+}
+function normalizeRecipientKind(value) {
+  if (typeof value !== "string") return null;
+  const normalized = value.trim().toLowerCase();
+  if (normalized === "owner" || normalized === "external" || normalized === "e164") {
+    return normalized;
+  }
+  return null;
+}
+const voiceCallAction = {
+  name: ACTION_NAME,
+  suppressPostActionContinuation: true,
+  similes: [
+    "CALL_ME",
+    "ESCALATE_TO_USER",
+    "CALL_THIRD_PARTY",
+    "PHONE_SOMEONE",
+    "DIAL"
+  ],
+  tags: [
+    "domain:meta",
+    "capability:execute",
+    "capability:send",
+    "surface:remote-api",
+    "risk:user-visible"
+  ],
+  description: "Owner-only outbound voice call via registered provider. Action dial; recipientKind=owner|external|e164. Provider Twilio; Android/app-phone implementation-only until VOICE_CALL provider wired. owner env owner number + standing escalation policy; external RelationshipStore contact + allow-list; e164 raw phoneNumber. All paths draft first; confirmed:true required; approval queue.",
+  descriptionCompressed: "Twilio voice dial: recipientKind=owner|external|e164; draft-confirm; approval-queue",
+  contexts: ["contacts", "messaging", "phone", "tasks", "automation"],
+  roleGate: { minRole: "OWNER" },
+  validate: async () => true,
+  parameters: [
+    {
+      name: "action",
+      description: "dial.",
+      required: false,
+      schema: { type: "string", enum: ["dial"] }
+    },
+    {
+      name: "recipientKind",
+      description: "owner escalation env number | external RelationshipStore lookup + allow-list | e164 raw E.164 phoneNumber.",
+      required: true,
+      schema: {
+        type: "string",
+        enum: ["owner", "external", "e164"]
+      }
+    },
+    {
+      name: "phoneNumber",
+      description: "recipientKind=e164: destination E.164 phoneNumber.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "recipient",
+      description: "recipientKind=external: contact name or E.164; names via RelationshipStore.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "bodyText",
+      description: "Optional spoken message on connect.",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "confirmed",
+      description: "true required to place call. Without: draft/approval-queue.",
+      required: false,
+      schema: { type: "boolean" }
+    },
+    {
+      name: "reason",
+      description: "Optional call reason; approval task audit.",
+      required: false,
+      schema: { type: "string" }
+    }
+  ],
+  handler: async (runtime, message, state, options) => {
+    if (!await hasLifeOpsAccess(runtime, message)) {
+      return {
+        success: false,
+        text: "Voice-call actions are restricted to the owner.",
+        data: { actionName: ACTION_NAME, error: "PERMISSION_DENIED" }
+      };
+    }
+    const resolved = await resolveActionArgs({
+      runtime,
+      message,
+      state,
+      options,
+      actionName: ACTION_NAME,
+      subactions: SUBACTIONS,
+      defaultSubaction: "dial"
+    });
+    if (!resolved.ok) {
+      return {
+        success: false,
+        text: resolved.clarification,
+        data: { actionName: ACTION_NAME, missing: resolved.missing }
+      };
+    }
+    const { params } = resolved;
+    const recipientKind = normalizeRecipientKind(params.recipientKind);
+    if (!recipientKind) {
+      return {
+        success: false,
+        text: "VOICE_CALL.dial requires recipientKind = owner | external | e164.",
+        values: { success: false, error: "MISSING_RECIPIENT_KIND" },
+        data: {
+          actionName: ACTION_NAME,
+          action: "dial",
+          subaction: "dial",
+          error: "MISSING_RECIPIENT_KIND"
+        }
+      };
+    }
+    switch (recipientKind) {
+      case "e164":
+        return dialE164(runtime, message, params);
+      case "owner":
+        return dialOwner(runtime, message, params);
+      case "external":
+        return dialExternal(runtime, message, params);
+    }
+  },
+  examples: [
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Call me at +15551234567 and say the build is done" }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: 'Draft voice call to +15551234567:\n\n"The build is done."\n\nSay "confirm" to place the call.'
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: {
+          text: "If you get stuck in the browser or on my computer, call me and let me jump in to unblock it."
+        }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "Recorded. If I get stuck in the browser or on your computer, I'll escalate by phone so you can jump in to unblock it."
+        }
+      }
+    ],
+    [
+      {
+        name: "{{name1}}",
+        content: { text: "Call the dentist and reschedule my appointment." }
+      },
+      {
+        name: "{{agentName}}",
+        content: {
+          text: "I can draft that call and hold it behind your approval. Tell me which saved contact or phone number to use, and I'll ask for confirmation before dialing."
+        }
+      }
+    ]
+  ]
+};
+const __internal = {
+  readOwnerNumber,
+  readExternalAllowList
+};
+export {
+  __internal,
+  voiceCallAction
+};
+//# sourceMappingURL=voice-call.js.map