spectrum-ts 1.18.0 → 2.0.0

package/dist/{chunk-MC6ZKFSG.js → chunk-5XEFJBN2.js}

@@ -1,83 +1,5 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 
-// src/utils/cloud.ts
-var SPECTRUM_CLOUD_URL = process.env.SPECTRUM_CLOUD_URL ?? "https://spectrum.photon.codes";
-var SpectrumCloudError = class extends Error {
-  status;
-  code;
-  constructor(status, code, message) {
-    super(message);
-    this.name = "SpectrumCloudError";
-    this.status = status;
-    this.code = code;
-  }
-};
-var request = async (path, init) => {
-  const response = await fetch(`${SPECTRUM_CLOUD_URL}${path}`, init);
-  if (!response.ok) {
-    const body = await response.text().catch(() => "");
-    try {
-      const parsed = JSON.parse(body);
-      throw new SpectrumCloudError(
-        response.status,
-        parsed.code,
-        parsed.message
-      );
-    } catch (error) {
-      if (error instanceof SpectrumCloudError) {
-        throw error;
-      }
-      throw new SpectrumCloudError(
-        response.status,
-        "UNKNOWN",
-        body || response.statusText
-      );
-    }
-  }
-  const json = await response.json();
-  if (!json.succeed) {
-    throw new SpectrumCloudError(
-      response.status,
-      "UNKNOWN",
-      "Server returned succeed=false"
-    );
-  }
-  return json.data;
-};
-var basicAuth = (projectId, projectSecret) => `Basic ${btoa(`${projectId}:${projectSecret}`)}`;
-var cloud = {
-  getProject: (projectId, projectSecret) => request(`/projects/${projectId}/`, {
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getSubscription: (projectId) => request(`/projects/${projectId}/billing/subscription`),
-  issueImessageTokens: (projectId, projectSecret) => request(`/projects/${projectId}/imessage/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getImessageInfo: (projectId) => request(`/projects/${projectId}/imessage/`),
-  issueWhatsappBusinessTokens: (projectId, projectSecret) => request(`/projects/${projectId}/whatsapp-business/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  issueSlackTokens: (projectId, projectSecret) => request(`/projects/${projectId}/slack/tokens`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  issueFusorToken: (projectId, projectSecret) => request(`/projects/${projectId}/fusor/token`, {
-    method: "POST",
-    headers: { Authorization: basicAuth(projectId, projectSecret) }
-  }),
-  getPlatforms: (projectId) => request(`/projects/${projectId}/platforms/`),
-  togglePlatform: (projectId, projectSecret, platform, enabled) => request(`/projects/${projectId}/platforms/`, {
-    method: "PATCH",
-    headers: {
-      Authorization: basicAuth(projectId, projectSecret),
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({ platform, enabled })
-  })
-};
-
 // src/utils/stream.ts
 import { Repeater } from "@repeaterjs/repeater";
 function createAsyncQueue() {
@@ -190,6 +112,16 @@ function broadcast(source) {
   let terminalError;
   let pumpPromise;
   let closed = false;
+  const closeConsumers = (error) => {
+    if (consumers.size === 0) {
+      return;
+    }
+    const current = Array.from(consumers);
+    consumers.clear();
+    for (const consumer of current) {
+      consumer.end(error);
+    }
+  };
   const startPump = () => {
     if (pumping || terminated) {
       return;
@@ -198,35 +130,35 @@ function broadcast(source) {
     pumpPromise = (async () => {
       try {
         for await (const value of source) {
-          for (const consumer of consumers) {
+          if (terminated) {
+            break;
+          }
+          for (const consumer of Array.from(consumers)) {
             consumer.deliveries = consumer.deliveries.then(
               () => consumer.emit(value).catch(() => {
               })
             );
           }
         }
+        if (terminated) {
+          return;
+        }
         terminated = true;
         await Promise.allSettled(
           Array.from(consumers, (consumer) => consumer.deliveries)
         );
-        for (const consumer of consumers) {
-          consumer.end();
-        }
-        consumers.clear();
+        closeConsumers();
       } catch (error) {
         terminated = true;
         terminalError = error;
-        for (const consumer of consumers) {
-          consumer.end(error);
-        }
-        consumers.clear();
+        closeConsumers(error);
       }
     })();
   };
   return {
     subscribe() {
       return stream((emit, end) => {
-        if (terminated) {
+        if (terminated || closed) {
           end(terminalError);
           return;
         }
@@ -247,27 +179,17 @@ function broadcast(source) {
         return;
       }
       closed = true;
-      try {
-        await source.close();
-        if (pumpPromise) {
-          await pumpPromise.catch(ignoreCleanupError);
-        }
-      } finally {
-        if (!terminated) {
-          terminated = true;
-          for (const consumer of consumers) {
-            consumer.end();
-          }
-          consumers.clear();
-        }
+      terminated = true;
+      closeConsumers();
+      await source.close().catch(ignoreCleanupError);
+      if (pumpPromise) {
+        await pumpPromise.catch(ignoreCleanupError);
       }
     }
   };
 }
 
 export {
-  SpectrumCloudError,
-  cloud,
   createAsyncQueue,
   stream,
   mergeStreams,

package/dist/{chunk-JQN6CRSC.js → chunk-6BI4PFTP.js}

@@ -3,37 +3,11 @@ import {
   bufferToStream,
   fetchUrlBytes,
   readSchema,
-  resolveContents,
   streamSchema
 } from "./chunk-2ILTJC35.js";
 
-// src/content/group.ts
-import z from "zod";
-var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var groupSchema = z.object({
-  type: z.literal("group"),
-  items: z.array(z.custom(isMessage)).min(2)
-});
-var asGroup = (input) => groupSchema.parse({ type: "group", items: input.items });
-var stubOutboundMessage = (content) => ({ id: "", content });
-function group(...items) {
-  return {
-    build: async () => {
-      const resolved = await resolveContents(items);
-      const members = [];
-      for (const item of resolved) {
-        if (item.type === "group" || item.type === "reaction") {
-          throw new Error(`group() cannot contain "${item.type}" items`);
-        }
-        members.push(stubOutboundMessage(item));
-      }
-      return asGroup({ items: members });
-    }
-  };
-}
-
 // src/content/richlink.ts
-import z2 from "zod";
+import z from "zod";
 
 // src/utils/link-metadata.ts
 import ogs from "open-graph-scraper";
@@ -90,22 +64,22 @@ var fetchImage = (url) => fetchUrlBytes(new URL(url), {
 });
 
 // src/content/richlink.ts
-var richlinkCoverSchema = z2.object({
-  mimeType: z2.string().min(1).optional(),
+var richlinkCoverSchema = z.object({
+  mimeType: z.string().min(1).optional(),
   read: readSchema,
   stream: streamSchema
 });
-var optionalStringAccessor = z2.function({
+var optionalStringAccessor = z.function({
   input: [],
-  output: z2.promise(z2.string().min(1).optional())
+  output: z.promise(z.string().min(1).optional())
 });
-var coverAccessor = z2.function({
+var coverAccessor = z.function({
   input: [],
-  output: z2.promise(richlinkCoverSchema.optional())
+  output: z.promise(richlinkCoverSchema.optional())
 });
-var richlinkSchema = z2.object({
-  type: z2.literal("richlink"),
-  url: z2.url(),
+var richlinkSchema = z.object({
+  type: z.literal("richlink"),
+  url: z.url(),
   title: optionalStringAccessor,
   summary: optionalStringAccessor,
   cover: coverAccessor
@@ -150,9 +124,6 @@ function richlink(url) {
 }
 
 export {
-  groupSchema,
-  asGroup,
-  group,
   asRichlink,
   richlink
 };

package/dist/{chunk-QGJFZMD5.js → chunk-6UZFVXQF.js}

@@ -1,7 +1,4 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-import {
-  readSchema
-} from "./chunk-2ILTJC35.js";
 
 // src/utils/vcard.ts
 import vCard from "vcf";
@@ -350,109 +347,28 @@ var writePhoto = async (card, photo) => {
     type: photoTypeParam(photo.mimeType)
   });
 };
-var toVCard = async (contact2) => {
-  if (typeof contact2.raw === "string" && contact2.raw.startsWith("BEGIN:VCARD")) {
-    return contact2.raw;
+var toVCard = async (contact) => {
+  if (typeof contact.raw === "string" && contact.raw.startsWith("BEGIN:VCARD")) {
+    return contact.raw;
   }
   const card = new vCard();
-  writeName(card, contact2.name);
-  writePhones(card, contact2.phones);
-  writeEmails(card, contact2.emails);
-  writeAddresses(card, contact2.addresses);
-  writeOrg(card, contact2.org);
-  writeUrls(card, contact2.urls);
-  if (contact2.birthday) {
-    card.set("bday", contact2.birthday);
-  }
-  if (contact2.note) {
-    card.set("note", contact2.note);
-  }
-  await writePhoto(card, contact2.photo);
+  writeName(card, contact.name);
+  writePhones(card, contact.phones);
+  writeEmails(card, contact.emails);
+  writeAddresses(card, contact.addresses);
+  writeOrg(card, contact.org);
+  writeUrls(card, contact.urls);
+  if (contact.birthday) {
+    card.set("bday", contact.birthday);
+  }
+  if (contact.note) {
+    card.set("note", contact.note);
+  }
+  await writePhoto(card, contact.photo);
   return card.toString();
 };
 
-// src/content/contact.ts
-import vCard2 from "vcf";
-import z from "zod";
-var userRefSchema = z.object({
-  __platform: z.string(),
-  id: z.string()
-});
-var nameSchema = z.object({
-  formatted: z.string().optional(),
-  first: z.string().optional(),
-  last: z.string().optional(),
-  middle: z.string().optional(),
-  prefix: z.string().optional(),
-  suffix: z.string().optional()
-});
-var phoneTypeSchema = z.enum(["mobile", "home", "work", "other"]);
-var emailTypeSchema = z.enum(["home", "work", "other"]);
-var addressTypeSchema = z.enum(["home", "work", "other"]);
-var phoneSchema = z.object({
-  value: z.string(),
-  type: phoneTypeSchema.optional()
-});
-var emailSchema = z.object({
-  value: z.string(),
-  type: emailTypeSchema.optional()
-});
-var addressSchema = z.object({
-  street: z.string().optional(),
-  city: z.string().optional(),
-  region: z.string().optional(),
-  postalCode: z.string().optional(),
-  country: z.string().optional(),
-  type: addressTypeSchema.optional()
-});
-var orgSchema = z.object({
-  name: z.string().optional(),
-  title: z.string().optional(),
-  department: z.string().optional()
-});
-var photoSchema = z.object({
-  mimeType: z.string(),
-  read: readSchema
-});
-var contactSchema = z.object({
-  type: z.literal("contact"),
-  user: userRefSchema.optional(),
-  name: nameSchema.optional(),
-  phones: z.array(phoneSchema).optional(),
-  emails: z.array(emailSchema).optional(),
-  addresses: z.array(addressSchema).optional(),
-  org: orgSchema.optional(),
-  urls: z.array(z.string()).optional(),
-  birthday: z.string().optional(),
-  note: z.string().optional(),
-  photo: photoSchema.optional(),
-  raw: z.unknown().optional()
-});
-var asContact = (input) => contactSchema.parse({ type: "contact", ...input });
-var isUser = (value) => typeof value === "object" && value !== null && "__platform" in value && "id" in value && typeof value.__platform === "string" && typeof value.id === "string";
-function contact(input, details) {
-  return {
-    build: async () => {
-      if (typeof input === "string") {
-        return asContact(fromVCard(input));
-      }
-      if (input instanceof vCard2) {
-        return asContact(fromVCard(input.toString()));
-      }
-      if (isUser(input)) {
-        return asContact({
-          user: { __platform: input.__platform, id: input.id },
-          ...details
-        });
-      }
-      return asContact(input);
-    }
-  };
-}
-
 export {
   fromVCard,
-  toVCard,
-  asContact,
-  contact
+  toVCard
 };

package/dist/{chunk-YN6WOTBF.js → chunk-ATNAE7OR.js}

@@ -1,29 +1,35 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+import {
+  asRichlink
+} from "./chunk-6BI4PFTP.js";
 import {
   asGroup,
-  asRichlink,
   groupSchema
-} from "./chunk-JQN6CRSC.js";
+} from "./chunk-3B4QH4JG.js";
 import {
   asPoll,
   asPollOption
 } from "./chunk-2D27WW5B.js";
 import {
-  cloud,
+  cloud
+} from "./chunk-3GEJYGZK.js";
+import {
+  asContact
+} from "./chunk-U7AWXDH6.js";
+import {
   mergeStreams,
   stream
-} from "./chunk-MC6ZKFSG.js";
+} from "./chunk-5XEFJBN2.js";
 import {
-  asContact,
   fromVCard,
   toVCard
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-6UZFVXQF.js";
 import {
   UnsupportedError,
   buildPhotoAction,
   definePlatform,
   photoActionSchema
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-NGC4DJIX.js";
 import {
   asAttachment,
   asCustom,
@@ -2039,6 +2045,55 @@ var messages3 = (clients, projectConfig) => {
   );
 };
 
+// src/providers/imessage/remote/stream-text.ts
+var INITIAL_THROTTLE_MS = 1e3;
+var BACKOFF_FACTOR = 2;
+var MAX_EDITS = 5;
+var sendStreamText = async (remote, spaceId, content) => {
+  const chat = toChatGuid(spaceId);
+  let sent;
+  let full = "";
+  let lastSentText = "";
+  let lastEditAt = 0;
+  let editCount = 0;
+  const flushEdit = async (text2) => {
+    if (!sent || text2 === lastSentText) {
+      return;
+    }
+    await remote.messages.edit(chat, toMessageGuid(sent.guid), text2);
+    lastSentText = text2;
+    lastEditAt = Date.now();
+    editCount += 1;
+  };
+  for await (const delta of content.stream()) {
+    full += delta;
+    if (!sent) {
+      sent = await remote.messages.sendText(chat, full);
+      lastSentText = full;
+      lastEditAt = Date.now();
+      continue;
+    }
+    const hasBudgetForInterimEdit = editCount < MAX_EDITS - 1;
+    const requiredGap = INITIAL_THROTTLE_MS * BACKOFF_FACTOR ** editCount;
+    if (hasBudgetForInterimEdit && Date.now() - lastEditAt >= requiredGap) {
+      await flushEdit(full);
+    }
+  }
+  if (!sent) {
+    throw unsupportedRemoteContent(
+      "streamText",
+      "stream produced no text \u2014 nothing to send"
+    );
+  }
+  await flushEdit(full);
+  return {
+    id: sent.guid,
+    content: asText(full),
+    space: { id: spaceId },
+    timestamp: sent.dateCreated
+  };
+};
+
 // src/providers/imessage/remote/typing.ts
 var startTyping = async (remote, spaceId) => {
   await remote.chats.setTyping(toChatGuid(spaceId), true);
@@ -2063,6 +2118,7 @@ var stopTyping2 = async (remote, spaceId) => {
   await stopTyping(remote, spaceId);
 };
 var send4 = async (remote, spaceId, content) => send3(remote, spaceId, content);
+var sendStreamText2 = async (remote, spaceId, content) => sendStreamText(remote, spaceId, content);
 var replyToMessage2 = async (remote, spaceId, msgId, content) => replyToMessage(remote, spaceId, msgId, content);
 var editMessage2 = async (remote, spaceId, msgId, content) => editMessage(remote, spaceId, msgId, content);
 var reactToMessage2 = async (remote, spaceId, target, reaction) => {
@@ -2120,6 +2176,17 @@ var handleEdit = async (client, space, content) => {
   const remote = clientForPhone(client, space.phone);
   await editMessage2(remote, space.id, content.target.id, content.content);
 };
+var handleStreamText = async (client, space, content) => {
+  if (isLocal(client)) {
+    throw UnsupportedError.action(
+      "streamText",
+      "iMessage (local mode)",
+      "streaming text responses require remote iMessage"
+    );
+  }
+  const remote = clientForPhone(client, space.phone);
+  return await sendStreamText2(remote, space.id, content);
+};
 var handleBackground = async (client, space, content) => {
   if (isLocal(client)) {
     throw UnsupportedError.action(
@@ -2350,6 +2417,9 @@ var imessage = definePlatform("iMessage", {
       await handleEdit(client, space, content);
       return;
     }
+    if (content.type === "streamText") {
+      return await handleStreamText(client, space, content);
+    }
     if (content.type === "rename") {
       await handleRename(client, space, content);
       return;

package/dist/{chunk-IPOFBAIM.js → chunk-NGC4DJIX.js}

@@ -216,7 +216,7 @@ var UnsupportedError = class _UnsupportedError extends Error {
 };
 
 // src/platform/define.ts
-import { withSpan as withSpan2 } from "@photon-ai/otel";
+import { createLogger as createLogger2, withSpan as withSpan2 } from "@photon-ai/otel";
 
 // src/utils/identifier.ts
 import { sanitizeEmail, sanitizePhone } from "@photon-ai/otel";
@@ -747,6 +747,7 @@ function buildMessage(params) {
 }
 
 // src/platform/define.ts
+var platformLog2 = createLogger2("spectrum.platform");
 function classifySpaceIdentifier(args) {
   const stringArgs = args.filter((a) => typeof a === "string");
   if (stringArgs.length > 1) {
@@ -910,13 +911,20 @@ function createPlatformInstance(def, runtime) {
   const eventProperties = {};
   const customEvents = def.events ?? {};
   for (const eventName of Object.keys(customEvents)) {
-    const producer = customEvents[eventName];
-    if (producer) {
+    const declared = customEvents[eventName];
+    if (typeof declared === "function") {
+      const producer = declared;
       eventProperties[eventName] = producer({
         client: runtime.client,
         config: runtime.config,
+        projectConfig: runtime.projectConfig,
         store: runtime.store
       });
+      continue;
+    }
+    const fusorEvents = runtime.subscribeEvent?.(eventName);
+    if (fusorEvents) {
+      eventProperties[eventName] = fusorEvents;
     }
   }
   let messagesIterable;
@@ -948,8 +956,9 @@ function createPlatformInstance(def, runtime) {
     eventProperties
   );
 }
-function definePlatform(name, def) {
-  const fullDef = { name, ...def };
+function definePlatform(name, rawDef) {
+  const def = rawDef;
+  const fullDef = { ...def, name };
   const platformCache = /* @__PURE__ */ new WeakMap();
   const narrowSpectrum = (spectrum) => {
     const cached = platformCache.get(spectrum);
@@ -969,17 +978,19 @@ function definePlatform(name, def) {
   };
   const narrowSpace = (input) => {
     if (input.__platform !== name) {
-      throw new Error(
-        `Expected space from "${name}", got "${input.__platform}"`
-      );
+      platformLog2.warn("space platform mismatch; narrowing skipped", {
+        expected: name,
+        actual: input.__platform
+      });
     }
     return input;
   };
   const narrowMessage = (input) => {
     if (input.platform !== name) {
-      throw new Error(
-        `Expected message from "${name}", got "${input.platform}"`
-      );
+      platformLog2.warn("message platform mismatch; narrowing skipped", {
+        expected: name,
+        actual: input.platform
+      });
     }
     return input;
   };
@@ -1022,12 +1033,6 @@ function definePlatform(name, def) {
   }
   return narrower;
 }
-function defineFusorPlatform(name, def) {
-  return definePlatform(
-    name,
-    def
-  );
-}
 
 export {
   photoActionSchema,
@@ -1042,6 +1047,5 @@ export {
   senderAttrs,
   wrapProviderMessage,
   buildSpace,
-  definePlatform,
-  defineFusorPlatform
+  definePlatform
 };

package/dist/{chunk-5TIF3FIE.js → chunk-Q537JPTG.js}

@@ -3,17 +3,19 @@ import {
   asPollOption
 } from "./chunk-2D27WW5B.js";
 import {
-  cloud,
-  mergeStreams,
-  stream
-} from "./chunk-MC6ZKFSG.js";
+  cloud
+} from "./chunk-3GEJYGZK.js";
 import {
   asContact
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-U7AWXDH6.js";
+import {
+  mergeStreams,
+  stream
+} from "./chunk-5XEFJBN2.js";
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-NGC4DJIX.js";
 import {
   asAttachment,
   asCustom,