spectrum-ts 1.0.1 → 1.1.0

package/dist/{chunk-2Y5GBI6W.js → chunk-PXX7ISZ6.js}

@@ -1,3 +1,58 @@
+// src/content/poll.ts
+import z from "zod";
+var pollChoiceSchema = z.object({
+  title: z.string().nonempty()
+});
+var pollSchema = z.object({
+  type: z.literal("poll"),
+  title: z.string().nonempty().max(300),
+  options: z.array(pollChoiceSchema).min(2).max(10)
+});
+var pollOptionSchema = z.object({
+  type: z.literal("poll_option"),
+  option: pollChoiceSchema,
+  poll: pollSchema,
+  selected: z.boolean(),
+  title: z.string().nonempty()
+}).superRefine((value, ctx) => {
+  if (value.title !== value.option.title) {
+    ctx.addIssue({
+      code: "custom",
+      message: "poll_option title must match option.title",
+      path: ["title"]
+    });
+  }
+  if (!value.poll.options.some(
+    (pollOption) => pollOption.title === value.option.title
+  )) {
+    ctx.addIssue({
+      code: "custom",
+      message: "poll_option option must exist in poll.options",
+      path: ["option"]
+    });
+  }
+});
+var asPoll = (input) => pollSchema.parse({ type: "poll", ...input });
+var asPollOption = (input) => pollOptionSchema.parse({
+  type: "poll_option",
+  ...input,
+  title: input.option.title
+});
+var option = (title) => ({ title });
+var normalize = (raw) => typeof raw === "string" ? { title: raw } : { title: raw.title };
+var collectOptions = (args) => {
+  const [first] = args;
+  if (args.length === 1 && Array.isArray(first)) {
+    return first;
+  }
+  return args;
+};
+function poll(title, ...rest) {
+  return {
+    build: async () => asPoll({ title, options: collectOptions(rest).map(normalize) })
+  };
+}
+
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
 function stream(setup) {
@@ -122,6 +177,10 @@ var cloud = {
 };
 
 export {
+  asPoll,
+  asPollOption,
+  option,
+  poll,
   stream,
   mergeStreams,
   SpectrumCloudError,

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { C as ContentBuilder, U as User, M as Message, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-D5KhSXLy.js';
-export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-D5KhSXLy.js';
+import { C as ContentBuilder, U as User, M as Message, a as ContentInput, b as Content, P as ProviderMessage, c as PlatformDef, d as Platform, e as PlatformProviderConfig, S as SpectrumLike, f as CustomEventStreams, g as Space, I as InboundMessage, O as OutboundMessage } from './types-DJQLFwWW.js';
+export { A as AnyPlatformDef, E as EventProducer, h as PlatformInstance, i as PlatformMessage, j as PlatformSpace, k as PlatformUser, l as SchemaMessage } from './types-DJQLFwWW.js';
 import vCard from 'vcf';
 import z__default from 'zod';
 export { M as ManagedStream, m as mergeStreams, s as stream } from './stream-B55k7W8-.js';
@@ -138,6 +138,41 @@ declare const groupSchema: z__default.ZodObject<{
 type Group = z__default.infer<typeof groupSchema>;
 declare function group(...items: [ContentInput, ContentInput, ...ContentInput[]]): ContentBuilder;
 
+declare const pollChoiceSchema: z__default.ZodObject<{
+    title: z__default.ZodString;
+}, z__default.core.$strip>;
+declare const pollSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"poll">;
+    title: z__default.ZodString;
+    options: z__default.ZodArray<z__default.ZodObject<{
+        title: z__default.ZodString;
+    }, z__default.core.$strip>>;
+}, z__default.core.$strip>;
+declare const pollOptionSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"poll_option">;
+    option: z__default.ZodObject<{
+        title: z__default.ZodString;
+    }, z__default.core.$strip>;
+    poll: z__default.ZodObject<{
+        type: z__default.ZodLiteral<"poll">;
+        title: z__default.ZodString;
+        options: z__default.ZodArray<z__default.ZodObject<{
+            title: z__default.ZodString;
+        }, z__default.core.$strip>>;
+    }, z__default.core.$strip>;
+    selected: z__default.ZodBoolean;
+    title: z__default.ZodString;
+}, z__default.core.$strip>;
+type Poll = z__default.infer<typeof pollSchema>;
+type PollChoice = z__default.infer<typeof pollChoiceSchema>;
+type PollOption = z__default.infer<typeof pollOptionSchema>;
+type PollChoiceInput = string | {
+    title: string;
+};
+declare const option: (title: string) => PollChoice;
+declare function poll(title: string, options: PollChoiceInput[]): ContentBuilder;
+declare function poll(title: string, ...options: PollChoiceInput[]): ContentBuilder;
+
 declare const reactionSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"reaction">;
     emoji: z__default.ZodString;
@@ -2234,4 +2269,4 @@ declare class UnsupportedError extends Error {
 declare const fromVCard: (vcf: string) => ContactInput;
 declare const toVCard: (contact: Contact) => Promise<string>;
 
-export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, Emoji, type EmojiKey, type Group, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type Reaction, type Richlink, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, UnsupportedError, type UnsupportedKind, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, group, reaction, resolveContents, richlink, text, toVCard, voice };
+export { type CloudPlatform, type Contact, type ContactAddress, type ContactDetails, type ContactEmail, type ContactInput, type ContactName, type ContactOrg, type ContactPhone, Content, ContentBuilder, ContentInput, type DedicatedTokenData, Emoji, type EmojiKey, type Group, type ImessageInfoData, Message, Platform, PlatformDef, PlatformProviderConfig, type PlatformStatus, type PlatformsData, type Poll, type PollChoice, type PollChoiceInput, type PollOption, type Reaction, type Richlink, type SharedTokenData, Space, Spectrum, SpectrumCloudError, type SpectrumInstance, type SubscriptionData, type SubscriptionStatus, type TokenData, UnsupportedError, type UnsupportedKind, User, type Voice, attachment, cloud, contact, custom, definePlatform, fromVCard, group, option, poll, reaction, resolveContents, richlink, text, toVCard, voice };

package/dist/index.js

@@ -9,8 +9,10 @@ import {
   SpectrumCloudError,
   cloud,
   mergeStreams,
+  option,
+  poll,
   stream
-} from "./chunk-2Y5GBI6W.js";
+} from "./chunk-PXX7ISZ6.js";
 import {
   UnsupportedError,
   attachment,
@@ -2205,6 +2207,8 @@ export {
   fromVCard,
   group,
   mergeStreams,
+  option,
+  poll,
   reaction,
   resolveContents,
   richlink,

package/dist/providers/imessage/index.d.ts

@@ -1,5 +1,5 @@
 import { M as ManagedStream } from '../../stream-B55k7W8-.js';
-import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-D5KhSXLy.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DJQLFwWW.js';
 import * as zod_v4_core from 'zod/v4/core';
 import * as z from 'zod';
 import z__default from 'zod';

package/dist/providers/imessage/index.js

@@ -3,10 +3,12 @@ import {
   asRichlink
 } from "../../chunk-LAGNM6I7.js";
 import {
+  asPoll,
+  asPollOption,
   cloud,
   mergeStreams,
   stream
-} from "../../chunk-2Y5GBI6W.js";
+} from "../../chunk-PXX7ISZ6.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -246,6 +248,8 @@ var send = async (client, spaceId, content) => {
       );
       return synthSendResult();
     }
+    case "poll":
+      throw UnsupportedError.content("poll", "iMessage (local mode)");
     default:
       throw UnsupportedError.content(content.type, "iMessage (local mode)");
   }
@@ -409,12 +413,98 @@ var MessageCache = class {
     this.map.clear();
   }
 };
-var caches = /* @__PURE__ */ new WeakMap();
+var PollCache = class {
+  map = /* @__PURE__ */ new Map();
+  max;
+  selectionEventTimesByPoll = /* @__PURE__ */ new Map();
+  selectionsByPoll = /* @__PURE__ */ new Map();
+  constructor(max = DEFAULT_MAX) {
+    this.max = max;
+  }
+  get(id) {
+    return this.map.get(id);
+  }
+  set(id, poll) {
+    if (this.map.has(id)) {
+      this.map.delete(id);
+    }
+    this.map.set(id, poll);
+    if (this.map.size > this.max) {
+      const first = this.map.keys().next().value;
+      if (first !== void 0) {
+        this.map.delete(first);
+        this.selectionEventTimesByPoll.delete(first);
+        this.selectionsByPoll.delete(first);
+      }
+    }
+  }
+  clear() {
+    this.map.clear();
+    this.selectionEventTimesByPoll.clear();
+    this.selectionsByPoll.clear();
+  }
+  actorSelectionDeltas(pollId, actorId, optionIds) {
+    const previous = this.selectionsByPoll.get(pollId)?.get(actorId);
+    if (!previous) {
+      return optionIds.map((optionId) => ({ optionId, selected: true }));
+    }
+    const current = new Set(optionIds);
+    const selected = optionIds.filter((optionId) => !previous.has(optionId)).map((optionId) => ({ optionId, selected: true }));
+    const deselected = [...previous].filter((optionId) => !current.has(optionId)).map((optionId) => ({ optionId, selected: false }));
+    return [...selected, ...deselected];
+  }
+  clearedActorSelectionDeltas(pollId, actorId) {
+    const previous = this.selectionsByPoll.get(pollId)?.get(actorId);
+    if (!previous) {
+      return [];
+    }
+    return [...previous].map((optionId) => ({ optionId, selected: false }));
+  }
+  actorSelection(pollId, actorId) {
+    const selection = this.selectionsByPoll.get(pollId)?.get(actorId);
+    return selection ? [...selection] : void 0;
+  }
+  commitActorSelection(pollId, actorId, optionIds, at) {
+    let selections = this.selectionsByPoll.get(pollId);
+    if (!selections) {
+      selections = /* @__PURE__ */ new Map();
+      this.selectionsByPoll.set(pollId, selections);
+    }
+    selections.set(actorId, new Set(optionIds));
+    if (!at) {
+      return;
+    }
+    let eventTimes = this.selectionEventTimesByPoll.get(pollId);
+    if (!eventTimes) {
+      eventTimes = /* @__PURE__ */ new Map();
+      this.selectionEventTimesByPoll.set(pollId, eventTimes);
+    }
+    const eventTime = at.getTime();
+    const previousTime = eventTimes.get(actorId);
+    if (previousTime === void 0 || eventTime >= previousTime) {
+      eventTimes.set(actorId, eventTime);
+    }
+  }
+  isStaleActorSelectionEvent(pollId, actorId, at) {
+    const previousTime = this.selectionEventTimesByPoll.get(pollId)?.get(actorId);
+    return previousTime !== void 0 && at.getTime() < previousTime;
+  }
+};
+var messageCaches = /* @__PURE__ */ new WeakMap();
+var pollCaches = /* @__PURE__ */ new WeakMap();
 var getMessageCache = (owner) => {
-  let cache = caches.get(owner);
+  let cache = messageCaches.get(owner);
   if (!cache) {
     cache = new MessageCache();
-    caches.set(owner, cache);
+    messageCaches.set(owner, cache);
+  }
+  return cache;
+};
+var getPollCache = (owner) => {
+  let cache = pollCaches.get(owner);
+  if (!cache) {
+    cache = new PollCache();
+    pollCaches.set(owner, cache);
   }
   return cache;
 };
@@ -735,13 +825,222 @@ var toMessages2 = async (client, cache, event) => {
   cacheMessage(cache, msg);
   return [msg];
 };
-var clientStream = (client) => {
-  const sub = client.messages.subscribe("message.received");
+var isVotedPollEvent = (event) => event.delta.type === "voted";
+var isUnvotedPollEvent = (event) => event.delta.type === "unvoted";
+var toCachedPoll = (input) => {
+  const poll = asPoll({
+    title: input.title,
+    options: input.options.map((optionInfo) => ({
+      title: optionInfo.text
+    }))
+  });
+  const optionsByIdentifier = /* @__PURE__ */ new Map();
+  for (const [index, optionInfo] of input.options.entries()) {
+    const option = poll.options[index];
+    if (option && optionInfo.optionIdentifier) {
+      optionsByIdentifier.set(optionInfo.optionIdentifier, option);
+    }
+  }
+  return { poll, optionsByIdentifier };
+};
+var cachePollInfo = (cache, info) => {
+  const cached = toCachedPoll(info);
+  cache.set(info.messageGuid, cached);
+  return cached;
+};
+var cachePollEvent = (cache, event) => {
+  if (event.delta.type === "created" || event.delta.type === "optionAdded") {
+    try {
+      const cached = toCachedPoll({
+        title: event.delta.title,
+        options: event.delta.options
+      });
+      cache.set(event.pollMessageGuid, cached);
+      return cached;
+    } catch (e) {
+      console.error("[spectrum-ts][imessage][poll] failed to cache poll", e);
+    }
+  }
+};
+var fetchPollInfo = async (client, cache, event) => {
+  try {
+    const info = await client.polls.get(event.pollMessageGuid);
+    cachePollInfo(cache, info);
+    return info;
+  } catch (e) {
+    console.error("[spectrum-ts][imessage][poll] failed to fetch poll", e);
+    return;
+  }
+};
+var resolvePoll = async (client, cache, event) => {
+  const pollId = event.pollMessageGuid;
+  const cached = cache.get(pollId);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const info = await client.polls.get(event.pollMessageGuid);
+    return cachePollInfo(cache, info);
+  } catch (e) {
+    console.error("[spectrum-ts][imessage][poll] failed to resolve poll", e);
+    return;
+  }
+};
+var buildPollOptionMessage = (input) => {
+  const option = input.cached.optionsByIdentifier.get(input.optionId);
+  if (!option) {
+    return;
+  }
+  const action = input.selected ? "selected" : "deselected";
+  return {
+    id: `${input.event.pollMessageGuid}:${input.senderAddress}:${input.optionId}:${action}:${input.event.at.getTime()}`,
+    sender: { id: input.senderAddress },
+    space: {
+      id: input.chatGuid,
+      type: input.chatGuid.includes(";+;") ? "group" : "dm"
+    },
+    timestamp: input.event.at,
+    content: asPollOption({
+      option,
+      poll: input.cached.poll,
+      selected: input.selected
+    })
+  };
+};
+var buildPollOptionMessages = (input) => {
+  const messages3 = [];
+  for (const delta of input.deltas) {
+    const message = buildPollOptionMessage({
+      cached: input.cached,
+      chatGuid: input.chatGuid,
+      event: input.event,
+      optionId: delta.optionId,
+      selected: delta.selected,
+      senderAddress: input.senderAddress
+    });
+    if (message) {
+      messages3.push(message);
+    }
+  }
+  return messages3;
+};
+var allOptionIdsKnown = (cached, optionIds) => optionIds.every((optionId) => cached.optionsByIdentifier.has(optionId));
+var refreshPollMetadata = async (client, pollCache, event, fallbackOptionIds) => {
+  const info = await fetchPollInfo(client, pollCache, event);
+  if (!info) {
+    return;
+  }
+  const refreshed = pollCache.get(info.messageGuid);
+  if (!refreshed) {
+    return;
+  }
+  return {
+    optionIds: [...fallbackOptionIds],
+    poll: refreshed
+  };
+};
+var toPollVoteMessages = async (client, pollCache, event) => {
+  const senderAddress = event.actor.address;
+  if (!senderAddress) {
+    return [];
+  }
+  const pollId = event.pollMessageGuid;
+  if (pollCache.isStaleActorSelectionEvent(pollId, senderAddress, event.at)) {
+    return [];
+  }
+  const cached = await resolvePoll(client, pollCache, event);
+  if (!cached) {
+    return [];
+  }
+  const chatGuidStr = event.chatGuid;
+  let currentOptionIds = [...event.delta.optionIdentifiers];
+  let resolvedPoll = cached;
+  if (currentOptionIds.some(
+    (optionId) => !resolvedPoll.optionsByIdentifier.has(optionId)
+  )) {
+    const snapshot = await refreshPollMetadata(
+      client,
+      pollCache,
+      event,
+      currentOptionIds
+    );
+    if (snapshot) {
+      currentOptionIds = snapshot.optionIds;
+      resolvedPoll = snapshot.poll;
+    }
+  }
+  if (!allOptionIdsKnown(resolvedPoll, currentOptionIds)) {
+    return [];
+  }
+  const deltas = pollCache.actorSelectionDeltas(
+    pollId,
+    senderAddress,
+    currentOptionIds
+  );
+  const messages3 = buildPollOptionMessages({
+    cached: resolvedPoll,
+    chatGuid: chatGuidStr,
+    deltas,
+    event,
+    senderAddress
+  });
+  pollCache.commitActorSelection(
+    pollId,
+    senderAddress,
+    currentOptionIds,
+    event.at
+  );
+  return messages3;
+};
+var toPollUnvoteMessages = async (client, pollCache, event) => {
+  const senderAddress = event.actor.address;
+  if (!senderAddress) {
+    return [];
+  }
+  const pollId = event.pollMessageGuid;
+  if (pollCache.isStaleActorSelectionEvent(pollId, senderAddress, event.at)) {
+    return [];
+  }
+  const cached = await resolvePoll(client, pollCache, event);
+  if (!cached) {
+    return [];
+  }
+  const chatGuidStr = event.chatGuid;
+  const messages3 = [];
+  const deltas = pollCache.clearedActorSelectionDeltas(pollId, senderAddress);
+  for (const delta of deltas) {
+    const message = buildPollOptionMessage({
+      cached,
+      chatGuid: chatGuidStr,
+      event,
+      optionId: delta.optionId,
+      selected: delta.selected,
+      senderAddress
+    });
+    if (message) {
+      messages3.push(message);
+    }
+  }
+  pollCache.commitActorSelection(pollId, senderAddress, [], event.at);
+  return messages3;
+};
+var toPollDeltaMessages = async (client, pollCache, event) => {
+  if (isVotedPollEvent(event)) {
+    return toPollVoteMessages(client, pollCache, event);
+  }
+  if (isUnvotedPollEvent(event)) {
+    return toPollUnvoteMessages(client, pollCache, event);
+  }
+  return [];
+};
+var clientStream = (client, pollCache) => {
+  const messageSub = client.messages.subscribe("message.received");
+  const pollSub = client.polls.subscribe();
   const cache = getMessageCache(client);
   return stream((emit, end) => {
-    const pump = (async () => {
+    const messagePump = (async () => {
       try {
-        for await (const event of sub) {
+        for await (const event of messageSub) {
           if (event.message.isFromMe) {
             continue;
           }
@@ -749,14 +1048,30 @@ var clientStream = (client) => {
             await emit(message);
           }
         }
-        end();
       } catch (e) {
         end(e);
       }
     })();
+    const pollPump = (async () => {
+      try {
+        for await (const event of pollSub) {
+          cachePollEvent(pollCache, event);
+          if (event.actor.isFromMe) {
+            continue;
+          }
+          const messages3 = await toPollDeltaMessages(client, pollCache, event);
+          for (const vote of messages3) {
+            await emit(vote);
+          }
+        }
+      } catch (e) {
+        console.error("[spectrum-ts][imessage][poll] stream failed", e);
+      }
+    })();
     return async () => {
-      sub.close();
-      await pump;
+      messageSub.close();
+      pollSub.close();
+      await Promise.all([messagePump, pollPump]);
     };
   });
 };
@@ -774,7 +1089,10 @@ var sendContactAttachment = async (remote, content) => {
   const upload = await sendVCardAttachment(remote, vcardFileName2(content), vcf);
   return upload.guid;
 };
-var messages2 = (clients) => mergeStreams(clients.map(clientStream));
+var messages2 = (clients) => {
+  const pollCache = getPollCache(clients);
+  return mergeStreams(clients.map((client) => clientStream(client, pollCache)));
+};
 var startTyping = async (clients, spaceId) => {
   const remote = clients[0];
   if (!remote) {
@@ -828,6 +1146,14 @@ var sendSingle = async (remote, chat, content) => {
         })
       );
     }
+    case "poll":
+      return toSendResult(
+        await remote.polls.create(
+          chat,
+          content.title,
+          content.options.map((o) => o.title)
+        )
+      );
     default:
       throw unsupportedContent(content.type);
   }
@@ -916,6 +1242,12 @@ var replyToMessage = async (clients, spaceId, msgId, content) => {
         })
       );
     }
+    case "poll":
+      throw UnsupportedError.content(
+        "poll",
+        PLATFORM,
+        "polls cannot be sent as replies"
+      );
     default:
       throw unsupportedContent(content.type);
   }

package/dist/providers/terminal/index.d.ts

@@ -1,4 +1,4 @@
-import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-D5KhSXLy.js';
+import { d as Platform, c as PlatformDef, P as ProviderMessage, M as Message } from '../../types-DJQLFwWW.js';
 import z__default from 'zod';
 import 'hotscript';
 
@@ -120,6 +120,26 @@ declare const terminal: Platform<PlatformDef<"terminal", z__default.ZodObject<{
         } | {
             type: "group";
             items: Message[];
+        } | {
+            type: "poll";
+            title: string;
+            options: {
+                title: string;
+            }[];
+        } | {
+            type: "poll_option";
+            option: {
+                title: string;
+            };
+            poll: {
+                type: "poll";
+                title: string;
+                options: {
+                    title: string;
+                }[];
+            };
+            selected: boolean;
+            title: string;
         };
         sender: {
             id: string;

package/dist/providers/whatsapp-business/index.d.ts

@@ -2,7 +2,7 @@ import { M as ManagedStream } from '../../stream-B55k7W8-.js';
 import { WhatsAppClient } from '@photon-ai/whatsapp-business';
 import * as z from 'zod';
 import z__default from 'zod';
-import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-D5KhSXLy.js';
+import { l as SchemaMessage, d as Platform, c as PlatformDef, P as ProviderMessage } from '../../types-DJQLFwWW.js';
 import * as zod_v4_core from 'zod/v4/core';
 import 'hotscript';
 

package/dist/providers/whatsapp-business/index.js

@@ -1,8 +1,9 @@
 import {
+  asPollOption,
   cloud,
   mergeStreams,
   stream
-} from "../../chunk-2Y5GBI6W.js";
+} from "../../chunk-PXX7ISZ6.js";
 import {
   UnsupportedError,
   asAttachment,
@@ -233,6 +234,31 @@ var resubscribableStream = (state, options) => {
 
 // src/providers/whatsapp-business/messages.ts
 import { extension as mimeExtension } from "mime-types";
+
+// src/providers/whatsapp-business/poll.ts
+import {
+  button,
+  buttons,
+  list
+} from "@photon-ai/whatsapp-business";
+var MAX_BUTTON_OPTIONS = 3;
+var LIST_BUTTON_TEXT = "View options";
+var LIST_SECTION_TITLE = "Options";
+var pollOptionId = (index) => `opt_${index}`;
+var pollToInteractive = (content) => {
+  if (content.options.length <= MAX_BUTTON_OPTIONS) {
+    return buttons(
+      content.title,
+      ...content.options.map((o, i) => button(pollOptionId(i), o.title))
+    );
+  }
+  return list(content.title, LIST_BUTTON_TEXT).section(
+    LIST_SECTION_TITLE,
+    content.options.map((o, i) => ({ id: pollOptionId(i), title: o.title }))
+  );
+};
+
+// src/providers/whatsapp-business/messages.ts
 var primary = (clients) => {
   const client = clients[0];
   if (!client) {
@@ -243,6 +269,40 @@ var primary = (clients) => {
 var toSendResult = (result) => ({
   id: result.messageId
 });
+var MAX_POLL_CACHE_SIZE = 1e3;
+var OPTION_ID_PREFIX = "opt_";
+var pollCaches = /* @__PURE__ */ new WeakMap();
+var getPollCache = (client) => {
+  let cache = pollCaches.get(client);
+  if (!cache) {
+    cache = /* @__PURE__ */ new Map();
+    pollCaches.set(client, cache);
+  }
+  return cache;
+};
+var cachePoll = (client, messageId, poll) => {
+  const cache = getPollCache(client);
+  if (cache.has(messageId)) {
+    cache.delete(messageId);
+  }
+  cache.set(messageId, poll);
+  if (cache.size > MAX_POLL_CACHE_SIZE) {
+    const first = cache.keys().next().value;
+    if (first !== void 0) {
+      cache.delete(first);
+    }
+  }
+};
+var optionIndexFromId = (id) => {
+  if (!id.startsWith(OPTION_ID_PREFIX)) {
+    return;
+  }
+  const index = Number(id.slice(OPTION_ID_PREFIX.length));
+  if (!Number.isInteger(index) || index < 0 || pollOptionId(index) !== id) {
+    return;
+  }
+  return index;
+};
 var mapWaPhoneType = (type) => {
   if (!type) {
     return void 0;
@@ -384,11 +444,12 @@ var toMessages = (client, msg) => {
     {
       ...base,
       id: msg.id,
-      content: mapContent(client, msg.content)
+      content: mapContent(client, msg)
     }
   ];
 };
-var mapContent = (client, content) => {
+var mapContent = (client, msg) => {
+  const { content } = msg;
   switch (content.type) {
     case "text":
       return asText(content.body);
@@ -411,8 +472,18 @@ var mapContent = (client, content) => {
         target: stubTarget
       });
     }
-    case "interactive":
-      return asCustom({ whatsapp_type: "interactive", ...content.interactive });
+    case "interactive": {
+      const inter = content.interactive;
+      if (inter.type === "button_reply" || inter.type === "list_reply") {
+        const poll = msg.context?.id === void 0 ? void 0 : getPollCache(client).get(msg.context.id);
+        const optionIndex = optionIndexFromId(inter.reply.id);
+        const option = optionIndex === void 0 ? void 0 : poll?.options[optionIndex];
+        if (poll && option) {
+          return asPollOption({ poll, option, selected: true });
+        }
+      }
+      return asCustom({ whatsapp_type: "interactive", ...inter });
+    }
     case "button":
       return asCustom({ whatsapp_type: "button", ...content.button });
     case "order":
@@ -589,6 +660,14 @@ var send = async (clients, spaceId, content) => {
         })
       );
     }
+    case "poll": {
+      const result = await client.messages.send({
+        to: spaceId,
+        interactive: pollToInteractive(content)
+      });
+      cachePoll(client, result.messageId, content);
+      return toSendResult(result);
+    }
     default:
       throw UnsupportedError.content(content.type);
   }
@@ -648,6 +727,15 @@ var replyToMessage = async (clients, spaceId, messageId, content) => {
         })
       );
     }
+    case "poll": {
+      const result = await client.messages.send({
+        to: spaceId,
+        replyTo: messageId,
+        interactive: pollToInteractive(content)
+      });
+      cachePoll(client, result.messageId, content);
+      return toSendResult(result);
+    }
     default:
       throw UnsupportedError.content(content.type);
   }

package/dist/{types-D5KhSXLy.d.ts → types-DJQLFwWW.d.ts}

@@ -95,6 +95,26 @@ declare const contentSchema: z__default.ZodDiscriminatedUnion<[z__default.ZodObj
 }, z__default.core.$strip>, z__default.ZodObject<{
     type: z__default.ZodLiteral<"group">;
     items: z__default.ZodArray<z__default.ZodCustom<Message, Message>>;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"poll">;
+    title: z__default.ZodString;
+    options: z__default.ZodArray<z__default.ZodObject<{
+        title: z__default.ZodString;
+    }, z__default.core.$strip>>;
+}, z__default.core.$strip>, z__default.ZodObject<{
+    type: z__default.ZodLiteral<"poll_option">;
+    option: z__default.ZodObject<{
+        title: z__default.ZodString;
+    }, z__default.core.$strip>;
+    poll: z__default.ZodObject<{
+        type: z__default.ZodLiteral<"poll">;
+        title: z__default.ZodString;
+        options: z__default.ZodArray<z__default.ZodObject<{
+            title: z__default.ZodString;
+        }, z__default.core.$strip>>;
+    }, z__default.core.$strip>;
+    selected: z__default.ZodBoolean;
+    title: z__default.ZodString;
 }, z__default.core.$strip>], "type">;
 type Content = z__default.infer<typeof contentSchema>;
 interface ContentBuilder {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "spectrum-ts",
-  "version": "1.0.1",
+  "version": "1.1.0",
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -19,7 +19,7 @@
     }
   },
   "dependencies": {
-    "@photon-ai/advanced-imessage": "^0.4.3",
+    "@photon-ai/advanced-imessage": "^0.5.1",
     "@photon-ai/imessage-kit": "^3.0.0",
     "@photon-ai/whatsapp-business": "^0.1.1",
     "@repeaterjs/repeater": "^3.0.6",