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

package/dist/lifeops/runtime-service-delegates.js

@@ -0,0 +1,839 @@
+function trimmedString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : null;
+}
+function objectRecord(value) {
+  return value && typeof value === "object" ? value : null;
+}
+function resolveRuntimeConnectorAccountId(args) {
+  const metadata = objectRecord(args.grant?.metadata);
+  return trimmedString(args.accountId) ?? trimmedString(args.grant?.connectorAccountId) ?? trimmedString(metadata?.accountId) ?? trimmedString(metadata?.connectorAccountId) ?? trimmedString(args.grant?.cloudConnectionId) ?? args.defaultAccountId ?? "default";
+}
+function getRuntimeService(runtime, serviceTypes) {
+  for (const serviceType of serviceTypes) {
+    const service = runtime.getService(serviceType);
+    if (service && typeof service === "object") {
+      return service;
+    }
+  }
+  return null;
+}
+function connectorContext(args) {
+  return {
+    runtime: args.runtime,
+    source: args.source,
+    accountId: args.accountId,
+    account: { accountId: args.accountId },
+    target: args.target ? { ...args.target, accountId: args.accountId } : void 0
+  };
+}
+function connectorTarget(args) {
+  return {
+    source: args.source,
+    accountId: args.accountId,
+    channelId: args.channelId,
+    threadId: args.threadId,
+    entityId: args.entityId,
+    roomId: args.roomId,
+    metadata: {
+      ...args.metadata,
+      accountId: args.accountId
+    }
+  };
+}
+function unavailable(reason, error) {
+  return error === void 0 ? { status: "unavailable", reason } : { status: "unavailable", reason, error };
+}
+function getXRuntimeService(runtime) {
+  return getRuntimeService(runtime, ["x", "twitter"]);
+}
+async function getXAccountStatusWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.getAccountStatus !== "function") {
+    return unavailable("X runtime service getAccountStatus is not registered.");
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    const status = await service.getAccountStatus(accountId);
+    return {
+      status: "handled",
+      accountId,
+      value: {
+        accountId: status.accountId ?? accountId,
+        configured: status.configured === true,
+        connected: status.connected === true,
+        reason: typeof status.reason === "string" ? status.reason : "connected",
+        identity: status.identity ?? null,
+        grantedCapabilities: Array.isArray(status.grantedCapabilities) ? status.grantedCapabilities : [],
+        grantedScopes: Array.isArray(status.grantedScopes) ? status.grantedScopes : [],
+        authMode: typeof status.authMode === "string" ? status.authMode : void 0
+      }
+    };
+  } catch (error) {
+    return unavailable("X runtime service getAccountStatus failed.", error);
+  }
+}
+async function sendXDirectMessageWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.sendDirectMessageForAccount !== "function" && typeof service?.handleSendMessage !== "function") {
+    return unavailable(
+      "X runtime service handleSendMessage is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.sendDirectMessageForAccount === "function") {
+    try {
+      const value = await service.sendDirectMessageForAccount(accountId, {
+        participantId: args.participantId,
+        text: args.text
+      });
+      return {
+        status: "handled",
+        accountId,
+        value: {
+          ok: true,
+          status: value.status ?? 201,
+          externalId: value.messageId ?? null
+        }
+      };
+    } catch (error) {
+      return unavailable(
+        "X runtime service sendDirectMessageForAccount failed.",
+        error
+      );
+    }
+  }
+  const target = connectorTarget({
+    source: "x",
+    accountId,
+    channelId: args.participantId,
+    entityId: args.participantId,
+    metadata: { xUserId: args.participantId }
+  });
+  const handleSendMessage = service.handleSendMessage;
+  if (typeof handleSendMessage !== "function") {
+    return unavailable(
+      "X runtime service handleSendMessage is not registered."
+    );
+  }
+  try {
+    await handleSendMessage(args.runtime, target, {
+      text: args.text,
+      source: "lifeops",
+      metadata: { accountId }
+    });
+    return {
+      status: "handled",
+      accountId,
+      value: { ok: true, status: 201, externalId: null }
+    };
+  } catch (error) {
+    return unavailable("X runtime service handleSendMessage failed.", error);
+  }
+}
+async function fetchXDirectMessagesWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.fetchDirectMessagesForAccount !== "function" && typeof service?.fetchConnectorMessages !== "function") {
+    return unavailable(
+      "X runtime service fetchConnectorMessages is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.fetchDirectMessagesForAccount === "function") {
+    try {
+      const value = await service.fetchDirectMessagesForAccount(accountId, {
+        participantId: args.participantId,
+        limit: args.limit
+      });
+      return { status: "handled", accountId, value };
+    } catch (error) {
+      return unavailable(
+        "X runtime service fetchDirectMessagesForAccount failed.",
+        error
+      );
+    }
+  }
+  const target = args.participantId ? connectorTarget({
+    source: "x",
+    accountId,
+    channelId: args.participantId,
+    entityId: args.participantId
+  }) : void 0;
+  const fetchConnectorMessages = service.fetchConnectorMessages;
+  if (typeof fetchConnectorMessages !== "function") {
+    return unavailable(
+      "X runtime service fetchConnectorMessages is not registered."
+    );
+  }
+  try {
+    const value = await fetchConnectorMessages(
+      connectorContext({
+        runtime: args.runtime,
+        source: "x",
+        accountId,
+        target
+      }),
+      { accountId, target, limit: args.limit }
+    );
+    return { status: "handled", accountId, value };
+  } catch (error) {
+    return unavailable(
+      "X runtime service fetchConnectorMessages failed.",
+      error
+    );
+  }
+}
+async function createXPostWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.createPostForAccount !== "function" && typeof service?.handleSendPost !== "function") {
+    return unavailable(
+      "X runtime service createPostForAccount is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.createPostForAccount === "function") {
+    try {
+      const value = await service.createPostForAccount(accountId, {
+        text: args.text,
+        replyToTweetId: args.replyToTweetId
+      });
+      return { status: "handled", accountId, value };
+    } catch (error) {
+      return unavailable(
+        "X runtime service createPostForAccount failed.",
+        error
+      );
+    }
+  }
+  const handleSendPost = service.handleSendPost;
+  if (typeof handleSendPost !== "function") {
+    return unavailable("X runtime service handleSendPost is not registered.");
+  }
+  try {
+    const value = await handleSendPost(
+      args.runtime,
+      {
+        text: args.text,
+        ...args.replyToTweetId ? { replyToTweetId: args.replyToTweetId } : {},
+        metadata: { accountId }
+      },
+      {
+        runtime: args.runtime,
+        source: "x",
+        accountId,
+        account: { accountId },
+        metadata: { accountId },
+        target: connectorTarget({ source: "x", accountId })
+      }
+    );
+    return { status: "handled", accountId, value };
+  } catch (error) {
+    return unavailable("X runtime service handleSendPost failed.", error);
+  }
+}
+async function fetchXFeedWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.fetchFeedForAccount !== "function" && typeof service?.fetchConnectorFeed !== "function") {
+    return unavailable(
+      "X runtime service fetchFeedForAccount is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.fetchFeedForAccount === "function") {
+    try {
+      const value = await service.fetchFeedForAccount(accountId, {
+        feedType: args.feedType,
+        limit: args.limit,
+        cursor: args.cursor
+      });
+      return { status: "handled", accountId, value };
+    } catch (error) {
+      return unavailable(
+        "X runtime service fetchFeedForAccount failed.",
+        error
+      );
+    }
+  }
+  const fetchConnectorFeed = service.fetchConnectorFeed;
+  if (typeof fetchConnectorFeed !== "function") {
+    return unavailable(
+      "X runtime service fetchConnectorFeed is not registered."
+    );
+  }
+  try {
+    const context = connectorContext({
+      runtime: args.runtime,
+      source: "x",
+      accountId
+    });
+    const value = await fetchConnectorFeed(context, {
+      accountId,
+      feed: args.feedType,
+      limit: args.limit,
+      cursor: args.cursor
+    });
+    return { status: "handled", accountId, value };
+  } catch (error) {
+    return unavailable("X runtime service fetchConnectorFeed failed.", error);
+  }
+}
+async function searchXPostsWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.searchPostsForAccount !== "function" && typeof service?.searchConnectorPosts !== "function") {
+    return unavailable(
+      "X runtime service searchPostsForAccount is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.searchPostsForAccount === "function") {
+    try {
+      const value = await service.searchPostsForAccount(accountId, {
+        query: args.query,
+        limit: args.limit,
+        cursor: args.cursor
+      });
+      return { status: "handled", accountId, value };
+    } catch (error) {
+      return unavailable(
+        "X runtime service searchPostsForAccount failed.",
+        error
+      );
+    }
+  }
+  const searchConnectorPosts = service.searchConnectorPosts;
+  if (typeof searchConnectorPosts !== "function") {
+    return unavailable(
+      "X runtime service searchConnectorPosts is not registered."
+    );
+  }
+  try {
+    const value = await searchConnectorPosts(
+      connectorContext({ runtime: args.runtime, source: "x", accountId }),
+      { query: args.query, limit: args.limit, cursor: args.cursor }
+    );
+    return { status: "handled", accountId, value };
+  } catch (error) {
+    return unavailable("X runtime service searchConnectorPosts failed.", error);
+  }
+}
+async function sendXConversationMessageWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.sendDirectMessageToConversationForAccount !== "function") {
+    return unavailable(
+      "X runtime service sendDirectMessageToConversationForAccount is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    const value = await service.sendDirectMessageToConversationForAccount(
+      accountId,
+      {
+        conversationId: args.conversationId,
+        text: args.text
+      }
+    );
+    return {
+      status: "handled",
+      accountId,
+      value: {
+        ok: true,
+        status: value.status ?? 201,
+        externalId: value.messageId ?? null
+      }
+    };
+  } catch (error) {
+    return unavailable(
+      "X runtime service sendDirectMessageToConversationForAccount failed.",
+      error
+    );
+  }
+}
+async function createXDirectMessageGroupWithRuntimeService(args) {
+  const service = getXRuntimeService(args.runtime);
+  if (typeof service?.createDirectMessageGroupForAccount !== "function") {
+    return unavailable(
+      "X runtime service createDirectMessageGroupForAccount is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    const value = await service.createDirectMessageGroupForAccount(accountId, {
+      participantIds: args.participantIds,
+      text: args.text
+    });
+    return {
+      status: "handled",
+      accountId,
+      value: {
+        ok: true,
+        status: value.status ?? 201,
+        conversationId: value.conversationId ?? null,
+        externalId: value.messageId ?? null
+      }
+    };
+  } catch (error) {
+    return unavailable(
+      "X runtime service createDirectMessageGroupForAccount failed.",
+      error
+    );
+  }
+}
+async function listCalendlyEventTypesWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "calendly"
+  ]);
+  if (typeof service?.listEventTypes !== "function") {
+    return unavailable(
+      "Calendly runtime service listEventTypes is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.isConnected === "function" && !service.isConnected(accountId)) {
+    return unavailable(
+      "Calendly runtime service is not connected for accountId."
+    );
+  }
+  try {
+    return {
+      status: "handled",
+      accountId,
+      value: await service.listEventTypes(accountId)
+    };
+  } catch (error) {
+    return unavailable(
+      "Calendly runtime service listEventTypes failed.",
+      error
+    );
+  }
+}
+async function getCalendlyBookingUrlWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "calendly"
+  ]);
+  if (typeof service?.getBookingUrl !== "function") {
+    return unavailable(
+      "Calendly runtime service getBookingUrl is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.isConnected === "function" && !service.isConnected(accountId)) {
+    return unavailable(
+      "Calendly runtime service is not connected for accountId."
+    );
+  }
+  try {
+    return {
+      status: "handled",
+      accountId,
+      value: await service.getBookingUrl(args.query, accountId)
+    };
+  } catch (error) {
+    return unavailable("Calendly runtime service getBookingUrl failed.", error);
+  }
+}
+async function listCalendlyScheduledEventsWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "calendly"
+  ]);
+  if (typeof service?.listScheduledEvents !== "function") {
+    return unavailable(
+      "Calendly runtime service listScheduledEvents is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.isConnected === "function" && !service.isConnected(accountId)) {
+    return unavailable(
+      "Calendly runtime service is not connected for accountId."
+    );
+  }
+  try {
+    return {
+      status: "handled",
+      accountId,
+      value: await service.listScheduledEvents(args.options, accountId)
+    };
+  } catch (error) {
+    return unavailable(
+      "Calendly runtime service listScheduledEvents failed.",
+      error
+    );
+  }
+}
+async function getCalendlyAvailabilityWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "calendly"
+  ]);
+  if (typeof service?.getAvailability !== "function") {
+    return unavailable(
+      "Calendly runtime service getAvailability is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.isConnected === "function" && !service.isConnected(accountId)) {
+    return unavailable(
+      "Calendly runtime service is not connected for accountId."
+    );
+  }
+  try {
+    return {
+      status: "handled",
+      accountId,
+      value: await service.getAvailability(
+        args.eventTypeUri,
+        args.options,
+        accountId
+      )
+    };
+  } catch (error) {
+    return unavailable(
+      "Calendly runtime service getAvailability failed.",
+      error
+    );
+  }
+}
+async function createCalendlySingleUseLinkWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "calendly"
+  ]);
+  if (typeof service?.createSingleUseLink !== "function") {
+    return unavailable(
+      "Calendly runtime service createSingleUseLink is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  if (typeof service.isConnected === "function" && !service.isConnected(accountId)) {
+    return unavailable(
+      "Calendly runtime service is not connected for accountId."
+    );
+  }
+  try {
+    return {
+      status: "handled",
+      accountId,
+      value: await service.createSingleUseLink(args.eventTypeUri, accountId)
+    };
+  } catch (error) {
+    return unavailable(
+      "Calendly runtime service createSingleUseLink failed.",
+      error
+    );
+  }
+}
+async function searchMessagesWithRuntimeService(args) {
+  const service = getRuntimeService(
+    args.runtime,
+    [args.serviceType]
+  );
+  if (typeof service?.searchConnectorMessages !== "function") {
+    return unavailable(
+      `${args.source} runtime service searchConnectorMessages is not registered.`
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  const target = connectorTarget({
+    source: args.source,
+    accountId,
+    channelId: args.channelId,
+    roomId: args.roomId
+  });
+  try {
+    const value = await service.searchConnectorMessages(
+      connectorContext({
+        runtime: args.runtime,
+        source: args.source,
+        accountId,
+        target
+      }),
+      {
+        accountId,
+        target,
+        query: args.query,
+        channelId: args.channelId,
+        roomId: args.roomId,
+        limit: args.limit
+      }
+    );
+    return { status: "handled", accountId, value };
+  } catch (error) {
+    return unavailable(
+      `${args.source} runtime service searchConnectorMessages failed.`,
+      error
+    );
+  }
+}
+function searchDiscordMessagesWithRuntimeService(args) {
+  return searchMessagesWithRuntimeService({
+    ...args,
+    serviceType: "discord",
+    source: "discord"
+  });
+}
+async function sendDiscordMessageWithRuntimeService(args) {
+  const service = getRuntimeService(
+    args.runtime,
+    ["discord"]
+  );
+  if (typeof service?.handleSendMessage !== "function") {
+    return unavailable(
+      "Discord runtime service handleSendMessage is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  const target = connectorTarget({
+    source: "discord",
+    accountId,
+    channelId: args.channelId
+  });
+  try {
+    await service.handleSendMessage(args.runtime, target, {
+      text: args.text,
+      source: "lifeops",
+      metadata: { accountId }
+    });
+    return { status: "handled", accountId, value: { ok: true } };
+  } catch (error) {
+    return unavailable(
+      "Discord runtime service handleSendMessage failed.",
+      error
+    );
+  }
+}
+function searchTelegramMessagesWithRuntimeService(args) {
+  return searchMessagesWithRuntimeService({
+    ...args,
+    serviceType: "telegram",
+    source: "telegram"
+  });
+}
+function searchSignalMessagesWithRuntimeService(args) {
+  return searchMessagesWithRuntimeService({
+    ...args,
+    serviceType: "signal",
+    source: "signal"
+  });
+}
+async function sendTelegramMessageWithRuntimeService(args) {
+  const service = getRuntimeService(
+    args.runtime,
+    ["telegram"]
+  );
+  if (typeof service?.handleSendMessage !== "function") {
+    return unavailable(
+      "Telegram runtime service handleSendMessage is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  const target = connectorTarget({
+    source: "telegram",
+    accountId,
+    channelId: args.target
+  });
+  try {
+    await service.handleSendMessage(args.runtime, target, {
+      text: args.message,
+      source: "lifeops",
+      metadata: { accountId }
+    });
+    return { status: "handled", accountId, value: { ok: true } };
+  } catch (error) {
+    return unavailable(
+      "Telegram runtime service handleSendMessage failed.",
+      error
+    );
+  }
+}
+async function readSignalRecentWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "signal"
+  ]);
+  if (typeof service?.getRecentMessages !== "function") {
+    return unavailable(
+      "Signal runtime service getRecentMessages is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    return {
+      status: "handled",
+      accountId,
+      value: await service.getRecentMessages(args.limit, accountId)
+    };
+  } catch (error) {
+    return unavailable(
+      "Signal runtime service getRecentMessages failed.",
+      error
+    );
+  }
+}
+async function sendSignalMessageWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "signal"
+  ]);
+  if (typeof service?.sendMessage !== "function") {
+    return unavailable("Signal runtime service sendMessage is not registered.");
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    const result = await service.sendMessage(args.recipient, args.text, {
+      accountId
+    });
+    const timestamp = result.timestamp;
+    if (typeof timestamp !== "number" || !Number.isFinite(timestamp)) {
+      return unavailable(
+        "Signal runtime service sendMessage returned invalid data."
+      );
+    }
+    return { status: "handled", accountId, value: { timestamp } };
+  } catch (error) {
+    return unavailable("Signal runtime service sendMessage failed.", error);
+  }
+}
+function firstMessageId(result) {
+  return trimmedString(result.messages?.[0]?.id);
+}
+async function sendWhatsAppMessageWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "whatsapp"
+  ]);
+  if (typeof service?.sendMessage !== "function") {
+    return unavailable(
+      "WhatsApp runtime service sendMessage is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    const sent = await service.sendMessage({
+      accountId,
+      type: "text",
+      to: args.request.to,
+      content: args.request.text,
+      replyToMessageId: args.request.replyToMessageId
+    });
+    const messageId = firstMessageId(sent);
+    if (!messageId) {
+      return unavailable(
+        "WhatsApp runtime service sendMessage returned invalid data."
+      );
+    }
+    return {
+      status: "handled",
+      accountId,
+      value: { ok: true, messageId }
+    };
+  } catch (error) {
+    return unavailable("WhatsApp runtime service sendMessage failed.", error);
+  }
+}
+async function fetchWhatsAppMessagesWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "whatsapp"
+  ]);
+  if (typeof service?.fetchConnectorMessages !== "function") {
+    return unavailable(
+      "WhatsApp runtime service fetchConnectorMessages is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  const target = args.chatId ? connectorTarget({ source: "whatsapp", accountId, channelId: args.chatId }) : void 0;
+  try {
+    const value = await service.fetchConnectorMessages(
+      connectorContext({
+        runtime: args.runtime,
+        source: "whatsapp",
+        accountId,
+        target
+      }),
+      { accountId, target, channelId: args.chatId, limit: args.limit }
+    );
+    return { status: "handled", accountId, value };
+  } catch (error) {
+    return unavailable(
+      "WhatsApp runtime service fetchConnectorMessages failed.",
+      error
+    );
+  }
+}
+async function sendIMessageWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "imessage"
+  ]);
+  if (typeof service?.sendMessage !== "function") {
+    return unavailable(
+      "iMessage runtime service sendMessage is not registered."
+    );
+  }
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    const sent = await service.sendMessage(args.to, args.text, {
+      accountId,
+      mediaUrl: args.mediaUrl,
+      maxBytes: args.maxBytes
+    });
+    if (!sent.success) {
+      return unavailable(
+        sent.error ?? "iMessage runtime service sendMessage failed."
+      );
+    }
+    return { status: "handled", accountId, value: sent };
+  } catch (error) {
+    return unavailable("iMessage runtime service sendMessage failed.", error);
+  }
+}
+async function readIMessagesWithRuntimeService(args) {
+  const service = getRuntimeService(args.runtime, [
+    "imessage"
+  ]);
+  const accountId = resolveRuntimeConnectorAccountId(args);
+  try {
+    if (typeof service?.getMessages === "function") {
+      return {
+        status: "handled",
+        accountId,
+        value: await service.getMessages({
+          chatId: args.chatId,
+          limit: args.limit,
+          accountId
+        })
+      };
+    }
+    if (typeof service?.getRecentMessages === "function") {
+      return {
+        status: "handled",
+        accountId,
+        value: await service.getRecentMessages(args.limit)
+      };
+    }
+    return unavailable(
+      "iMessage runtime service read method is not registered."
+    );
+  } catch (error) {
+    return unavailable("iMessage runtime service read failed.", error);
+  }
+}
+export {
+  createCalendlySingleUseLinkWithRuntimeService,
+  createXDirectMessageGroupWithRuntimeService,
+  createXPostWithRuntimeService,
+  fetchWhatsAppMessagesWithRuntimeService,
+  fetchXDirectMessagesWithRuntimeService,
+  fetchXFeedWithRuntimeService,
+  getCalendlyAvailabilityWithRuntimeService,
+  getCalendlyBookingUrlWithRuntimeService,
+  getXAccountStatusWithRuntimeService,
+  listCalendlyEventTypesWithRuntimeService,
+  listCalendlyScheduledEventsWithRuntimeService,
+  readIMessagesWithRuntimeService,
+  readSignalRecentWithRuntimeService,
+  resolveRuntimeConnectorAccountId,
+  searchDiscordMessagesWithRuntimeService,
+  searchSignalMessagesWithRuntimeService,
+  searchTelegramMessagesWithRuntimeService,
+  searchXPostsWithRuntimeService,
+  sendDiscordMessageWithRuntimeService,
+  sendIMessageWithRuntimeService,
+  sendSignalMessageWithRuntimeService,
+  sendTelegramMessageWithRuntimeService,
+  sendWhatsAppMessageWithRuntimeService,
+  sendXConversationMessageWithRuntimeService,
+  sendXDirectMessageWithRuntimeService
+};
+//# sourceMappingURL=runtime-service-delegates.js.map