spectrum-ts 1.18.0 → 2.0.0

package/dist/{chunk-5BKZJMZV.js → chunk-U3LXXT3W.js}

@@ -3,14 +3,19 @@ import {
   asVoice
 } from "./chunk-NNY6LMSC.js";
 import {
-  asContact,
+  asContact
+} from "./chunk-U7AWXDH6.js";
+import {
+  stream
+} from "./chunk-5XEFJBN2.js";
+import {
   fromVCard,
   toVCard
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-6UZFVXQF.js";
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-NGC4DJIX.js";
 import {
   asAttachment,
   asCustom,
@@ -694,7 +699,7 @@ function protocolToSpectrum(p) {
       }
       return cached;
     };
-    const stream = async () => {
+    const stream2 = async () => {
       if (path) {
         const [{ createReadStream }, { Readable }] = await Promise.all([
           import("fs"),
@@ -718,7 +723,7 @@ function protocolToSpectrum(p) {
         mimeType: p.mimeType,
         size: p.size,
         read: readBytes,
-        stream
+        stream: stream2
       });
     }
     return asVoice({
@@ -726,7 +731,7 @@ function protocolToSpectrum(p) {
       mimeType: p.mimeType,
       size: p.size,
       read: readBytes,
-      stream
+      stream: stream2
     });
   }
   if (p.type === "contact") {
@@ -784,33 +789,57 @@ var terminal = definePlatform("Terminal", {
       return { id };
     }
   },
-  async *messages({ client }) {
-    for await (const evt of client.events) {
-      if (evt.kind === "message") {
-        const msg = evt.value;
-        client.knownChats.add(msg.spaceId);
-        yield {
-          id: msg.id,
-          content: protocolToSpectrum(msg.content),
-          sender: { id: msg.senderId },
-          space: { id: msg.spaceId },
-          timestamp: parseTimestamp(msg.timestamp),
-          // replyTo is a terminal-specific extra — agents inspect via a
-          // cast until Spectrum's message model grows first-class support.
-          ...msg.replyTo ? { replyTo: msg.replyTo } : {}
-        };
-        continue;
-      }
-      const r = evt.value;
-      client.knownChats.add(r.spaceId);
-      yield {
-        id: `reaction:${r.messageId}:${r.reaction}:${r.timestamp}`,
-        content: reactionContentFromProtocol(r),
-        sender: { id: r.senderId },
-        space: { id: r.spaceId },
-        timestamp: parseTimestamp(r.timestamp)
+  // Return a ManagedStream (not a native async generator): a native generator
+  // parked on an in-flight `client.events.next()` cannot be force-cancelled —
+  // a `.return()` queues behind the pending `next()` and never reaches the
+  // event queue, which would deadlock `Spectrum.stop()`. Driving the queue with
+  // an explicit pump lets cleanup call the queue iterator's `return()` directly
+  // (synchronous close + drain), so the stream tears down promptly on stop()
+  // without waiting for destroyClient.
+  messages({ client }) {
+    return stream((emit, end) => {
+      const iterator = client.events[Symbol.asyncIterator]();
+      const pump = (async () => {
+        try {
+          let result = await iterator.next();
+          while (!result.done) {
+            const evt = result.value;
+            if (evt.kind === "message") {
+              const msg = evt.value;
+              client.knownChats.add(msg.spaceId);
+              await emit({
+                id: msg.id,
+                content: protocolToSpectrum(msg.content),
+                sender: { id: msg.senderId },
+                space: { id: msg.spaceId },
+                timestamp: parseTimestamp(msg.timestamp),
+                // replyTo is a terminal-specific extra — agents inspect via a
+                // cast until Spectrum's message model grows first-class support.
+                ...msg.replyTo ? { replyTo: msg.replyTo } : {}
+              });
+            } else {
+              const r = evt.value;
+              client.knownChats.add(r.spaceId);
+              await emit({
+                id: `reaction:${r.messageId}:${r.reaction}:${r.timestamp}`,
+                content: reactionContentFromProtocol(r),
+                sender: { id: r.senderId },
+                space: { id: r.spaceId },
+                timestamp: parseTimestamp(r.timestamp)
+              });
+            }
+            result = await iterator.next();
+          }
+          end();
+        } catch (error) {
+          end(error);
+        }
+      })();
+      return async () => {
+        await iterator.return?.();
+        await pump.catch(() => void 0);
       };
-    }
+    });
   },
   send: async ({ client, content, space }) => {
     if (content.type === "reply") {

package/dist/chunk-U7AWXDH6.js

@@ -0,0 +1,91 @@
+import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
+import {
+  fromVCard
+} from "./chunk-6UZFVXQF.js";
+import {
+  readSchema
+} from "./chunk-2ILTJC35.js";
+
+// src/content/contact.ts
+import vCard 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 vCard) {
+        return asContact(fromVCard(input.toString()));
+      }
+      if (isUser(input)) {
+        return asContact({
+          user: { __platform: input.__platform, id: input.id },
+          ...details
+        });
+      }
+      return asContact(input);
+    }
+  };
+}
+
+export {
+  asContact,
+  contact
+};

package/dist/{chunk-3OTECDNH.js → chunk-WXY5QP3M.js}

@@ -1,13 +1,15 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 import {
-  cloud,
+  cloud
+} from "./chunk-3GEJYGZK.js";
+import {
   mergeStreams,
   stream
-} from "./chunk-MC6ZKFSG.js";
+} from "./chunk-5XEFJBN2.js";
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-NGC4DJIX.js";
 import {
   asAttachment,
   asCustom,

package/dist/index.d.ts

@@ -1,10 +1,12 @@
-export { A as Attachment, a as AttachmentInput, b as attachment } from './attachment-DfWSZS5L.js';
+export { A as Attachment, a as AttachmentInput, b as attachment } from './attachment-B4nSrKVd.js';
 import z__default from 'zod';
 import { P as PhotoInput } from './photo-content-BJKnqgN-.js';
-import { C as ContentBuilder, M as Message, U as User, b as Space, c as ContentInput, e as Content, f as ProviderMessageRecord, g as SpaceActionFn, h as MessageActionFn, i as CreateClientContext, d as Store, P as Platform, a as PlatformDef, j as ProviderMessage, E as EventProducer, I as InstanceActionFn, k as PlatformProviderConfig, l as SpectrumLike, m as CustomEventStreams, A as AgentSender, n as ProjectData } from './types-DcQ5a7PK.js';
-export { o as AnyPlatformDef, B as Broadcaster, p as CloudPlatform, D as DedicatedTokenData, F as FusorTokenData, q as ImessageInfoData, r as ManagedStream, s as PlatformInstance, t as PlatformMessage, u as PlatformRuntime, v as PlatformSpace, w as PlatformStatus, x as PlatformUser, y as PlatformsData, z as ProjectProfile, S as SchemaMessage, G as SharedTokenData, H as SlackTeamMeta, J as SlackTokenData, K as SpectrumCloudError, L as SubscriptionData, N as SubscriptionStatus, T as TokenData, O as broadcast, Q as cloud, R as mergeStreams, V as stream } from './types-DcQ5a7PK.js';
-import { C as ContactInput, a as Contact } from './authoring-C9uDdZ2F.js';
-export { b as ContactAddress, c as ContactDetails, d as ContactEmail, e as ContactName, f as ContactOrg, g as ContactPhone, G as Group, P as Poll, h as PollChoice, i as PollChoiceInput, j as PollOption, R as Reaction, k as Richlink, V as Voice, l as contact, m as custom, n as group, o as option, p as poll, r as reaction, q as richlink, t as text, v as voice } from './authoring-C9uDdZ2F.js';
+import { C as ContentBuilder, M as Message, U as User, e as Space, h as ContentInput, i as Content, g as ProviderMessage, E as EventProducer, j as SpaceActionFn, k as MessageActionFn, I as InstanceActionFn, l as CreateClientContext, c as Store, a as PlatformDef, P as Platform, m as PlatformProviderConfig, n as SpectrumLike, o as CustomEventStreams, A as AgentSender, b as ProjectData } from './types-Bje8aq1k.js';
+export { p as AnyPlatformDef, B as Broadcaster, q as CloudPlatform, D as DedicatedTokenData, F as FusorTokenData, r as ImessageInfoData, s as ManagedStream, t as PlatformInstance, u as PlatformMessage, v as PlatformRuntime, w as PlatformSpace, x as PlatformStatus, y as PlatformUser, z as PlatformsData, G as ProjectProfile, S as SchemaMessage, H as SharedTokenData, J as SlackTeamMeta, K as SlackTokenData, L as SpectrumCloudError, N as SubscriptionData, O as SubscriptionStatus, T as TokenData, Q as broadcast, R as cloud, V as mergeStreams, W as stream } from './types-Bje8aq1k.js';
+import { C as ContactInput, a as Contact } from './authoring-BjE5BvlO.js';
+export { b as ContactAddress, c as ContactDetails, d as ContactEmail, e as ContactName, f as ContactOrg, g as ContactPhone, G as Group, P as Poll, h as PollChoice, i as PollChoiceInput, j as PollOption, R as Reaction, k as Richlink, V as Voice, l as contact, m as custom, n as group, o as option, p as poll, r as reaction, q as richlink, t as text, v as voice } from './authoring-BjE5BvlO.js';
+import { a as FusorVerify, F as FusorClient, b as FusorMessages, W as WebhookHandler, c as WebhookRawRequest, d as WebhookRawResult } from './types-BD0-kKyv.js';
+export { e as FusorEvent, f as FusorMessagesCtx, g as FusorMessagesReturn, h as FusorReply, i as FusorRespond, j as FusorVerifyRequest, k as fusorEvent, l as isFusorEvent } from './types-BD0-kKyv.js';
 import 'hotscript';
 import 'vcf';
 
@@ -89,6 +91,9 @@ declare const editSchema: z__default.ZodObject<{
         read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
         stream: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
         size?: number | undefined;
+    } | {
+        type: "streamText";
+        stream: () => AsyncIterable<string>;
     } | {
         type: "custom";
         raw: unknown;
@@ -221,6 +226,9 @@ declare const editSchema: z__default.ZodObject<{
         read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
         stream: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
         size?: number | undefined;
+    } | {
+        type: "streamText";
+        stream: () => AsyncIterable<string>;
     } | {
         type: "custom";
         raw: unknown;
@@ -398,6 +406,9 @@ declare const replySchema: z__default.ZodObject<{
         read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
         stream: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
         size?: number | undefined;
+    } | {
+        type: "streamText";
+        stream: () => AsyncIterable<string>;
     } | {
         type: "custom";
         raw: unknown;
@@ -530,6 +541,9 @@ declare const replySchema: z__default.ZodObject<{
         read: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>>;
         stream: z__default.core.$InferOuterFunctionType<z__default.ZodTuple<readonly [], null>, z__default.ZodPromise<z__default.ZodCustom<ReadableStream<unknown>, ReadableStream<unknown>>>>;
         size?: number | undefined;
+    } | {
+        type: "streamText";
+        stream: () => AsyncIterable<string>;
     } | {
         type: "custom";
         raw: unknown;
@@ -650,6 +664,49 @@ declare function reply(content: ContentInput, target: Message): ContentBuilder;
 
 declare const resolveContents: (items: readonly ContentInput[]) => Promise<Content[]>;
 
+/**
+ * Maps one chunk emitted by a stream to the incremental text it carries.
+ * Return a string to emit, or `null`/`undefined` to skip the chunk (e.g. for
+ * control events that carry no text).
+ */
+type DeltaExtractor<T> = (chunk: T) => string | null | undefined;
+/**
+ * Anything `streamText()` accepts as a source. The builder normalizes all of
+ * these to an internal `AsyncIterable<string>` of text deltas:
+ *
+ * - the Vercel AI SDK `streamText()` result (its `.textStream` is picked up
+ *   automatically — pass either the whole result or `.textStream` directly),
+ * - a raw `AsyncIterable<T>` (e.g. an OpenAI / Anthropic streaming response),
+ * - a raw `ReadableStream<T>` of chunks.
+ */
+type StreamTextSource<T = unknown> = {
+    textStream: AsyncIterable<string> | ReadableStream<string>;
+} | AsyncIterable<T> | ReadableStream<T>;
+interface StreamTextOptions<T = unknown> {
+    /**
+     * Map each chunk to its incremental text. Omit to rely on built-in
+     * auto-detection of the common SDK shapes (OpenAI chat/responses, Anthropic
+     * messages, AI SDK text streams, and plain strings).
+     */
+    extract?: DeltaExtractor<T>;
+}
+declare const streamTextSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"streamText">;
+    stream: z__default.ZodCustom<() => AsyncIterable<string>, () => AsyncIterable<string>>;
+}, z__default.core.$strip>;
+type StreamText = z__default.infer<typeof streamTextSchema>;
+/**
+ * Wrap a streaming LLM text response so it can be sent like any other content.
+ *
+ * Delivery is platform-specific — iMessage (remote) sends the first chunk as a
+ * real message and then edits it in place as more text arrives. Platforms that
+ * can't stream reject it (the send is warn-and-skipped).
+ *
+ * Accepts whatever the popular SDKs return; pass `options.extract` for any
+ * chunk shape the built-in detection doesn't recognize.
+ */
+declare function streamText<T = unknown>(source: StreamTextSource<T>, options?: StreamTextOptions<T>): ContentBuilder;
+
 /**
  * A `typing` content value carries a typing-indicator signal — either
  * `"start"` or `"stop"`. Like `reaction`, it's fire-and-forget: providers
@@ -2601,66 +2658,6 @@ declare const Emoji: {
 };
 type EmojiKey = keyof typeof Emoji;
 
-interface FusorVerifyRequest {
-    headers: Record<string, string>;
-    method: string;
-    path: string;
-    rawBody: Uint8Array;
-}
-type FusorVerify<TPayload = unknown> = (req: FusorVerifyRequest) => TPayload | Promise<TPayload>;
-interface FusorReply {
-    body?: string | Uint8Array;
-    headers?: Record<string, string>;
-    status?: number;
-}
-type FusorRespond = (reply: FusorReply) => void;
-interface FusorMessagesCtx<TPayload> {
-    payload: TPayload;
-    respond: FusorRespond;
-}
-type FusorMessagesReturn = ProviderMessageRecord | ProviderMessageRecord[] | undefined;
-type FusorMessages<TPayload> = (ctx: FusorMessagesCtx<TPayload>) => FusorMessagesReturn | Promise<FusorMessagesReturn>;
-declare const FUSOR_BRAND: unique symbol;
-interface FusorClient<TPayload = unknown> {
-    readonly platform: string;
-    readonly verify: FusorVerify<TPayload>;
-    readonly [FUSOR_BRAND]: true;
-}
-/**
- * Request-scoped handler invoked once per inbound message that
- * `spectrum.webhook()` resolves. Receives the same fully-built `[space,
- * message]` pair that `spectrum.messages` yields.
- *
- * Runs **fire-and-forget**: it is dispatched after the HTTP response (the
- * platform's `respond()` reply) has already been computed, so its outcome never
- * affects the response, and a throw is caught + logged rather than surfaced —
- * mirroring the body of a `for await (… of spectrum.messages)` loop.
- *
- * On a long-running server the event loop keeps the handler alive. On
- * serverless/edge runtimes the function may be frozen once the response is
- * returned, so keeping background work alive is the caller's responsibility —
- * the usual pattern is to enqueue the work and process it in a separate worker.
- */
-type WebhookHandler = (space: Space, message: Message) => void | Promise<void>;
-/**
- * Raw webhook input for HTTP servers without Web `Request`/`Response` (Express,
- * raw Node). `body` MUST be the exact bytes fusor POSTed — never a re-encoded
- * JSON/text body — so the protobuf decode works. `headers` are accepted (so the
- * natural `{ headers: req.headers, body: req.body }` shape keeps working) but are
- * not read: inbound authenticity is established by the per-platform `verify()`,
- * which reads the inner request reconstructed from the envelope.
- */
-interface WebhookRawRequest {
-    body: Uint8Array | ArrayBuffer;
-    headers?: Record<string, string>;
-}
-/** Raw webhook result, written back by the caller as the HTTP response. */
-interface WebhookRawResult {
-    body: Uint8Array;
-    headers: Record<string, string>;
-    status: number;
-}
-
 declare function fusor<TPayload>(platform: string, verify: FusorVerify<TPayload>): FusorClient<TPayload>;
 declare function isFusorClient(value: unknown): value is FusorClient;
 
@@ -2682,12 +2679,13 @@ declare function definePlatform<_Name extends string, _ConfigSchema extends z__d
 } & Omit<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, _Client, _ResolvedUser, _ResolvedSpace, _MessageSchema, _MessageType, _Events, _SpaceActions, _MessageActions, _Actions>, "lifecycle" | "name"> & {
     static?: _Static;
 }): Platform<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, _Client, _ResolvedUser, _ResolvedSpace, _MessageSchema, _MessageType, _Events, _SpaceActions, _MessageActions, _Actions>> & Readonly<_Static>;
-declare function defineFusorPlatform<_Name extends string, _ConfigSchema extends z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined, _SpaceSchema extends z__default.ZodType<object> | undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined, _TPayload, _ResolvedUser extends {
+declare function definePlatform<_Name extends string, _ConfigSchema extends z__default.ZodType<object>, _UserSchema extends z__default.ZodType<object> | undefined, _SpaceSchema extends z__default.ZodType<object> | undefined, _SpaceParamsSchema extends z__default.ZodType<object> | undefined, _TPayload, _ResolvedUser extends {
     id: string;
 }, _ResolvedSpace extends {
     id: string;
-}, _MessageSchema extends z__default.ZodType<object> | undefined = undefined, _Static extends Record<string, unknown> = Record<never, never>, _SpaceActions extends Record<string, SpaceActionFn> = Record<never, never>, _MessageActions extends Record<string, MessageActionFn> = Record<never, never>>(name: _Name, def: {
-    config: _ConfigSchema;
+}, _MessageSchema extends z__default.ZodType<object> | undefined = undefined, _FusorEvents extends (Record<string, z__default.ZodType<object>> & {
+    messages?: never;
+}) | undefined = undefined, _Static extends Record<string, unknown> = Record<never, never>, _SpaceActions extends Record<string, SpaceActionFn> = Record<never, never>, _MessageActions extends Record<string, MessageActionFn> = Record<never, never>>(name: _Name, def: Omit<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, FusorClient<_TPayload>, _ResolvedUser, _ResolvedSpace, _MessageSchema, ProviderMessage<_ResolvedUser, _ResolvedSpace, _MessageSchema extends z__default.ZodType<object> ? z__default.infer<_MessageSchema> : Record<never, never>>, _FusorEvents, _SpaceActions, _MessageActions>, "lifecycle" | "name" | "messages"> & {
     lifecycle: {
         createClient: (ctx: CreateClientContext<_ConfigSchema>) => Promise<FusorClient<_TPayload>>;
         destroyClient?: (ctx: {
@@ -2695,62 +2693,9 @@ declare function defineFusorPlatform<_Name extends string, _ConfigSchema extends
             store: Store;
         }) => Promise<void>;
     };
-    user: {
-        schema?: _UserSchema;
-        resolve: (_: {
-            input: {
-                userID: string;
-            };
-            client: FusorClient<_TPayload>;
-            config: z__default.infer<_ConfigSchema>;
-            store: Store;
-        }) => Promise<_ResolvedUser>;
-    };
-    space: {
-        schema?: _SpaceSchema;
-        params?: _SpaceParamsSchema;
-        resolve: (_: {
-            input: {
-                users: (_ResolvedUser & {
-                    __platform: _Name;
-                })[];
-                params?: _SpaceParamsSchema extends z__default.ZodType<object> ? z__default.infer<_SpaceParamsSchema> : undefined;
-            };
-            client: FusorClient<_TPayload>;
-            config: z__default.infer<_ConfigSchema>;
-            store: Store;
-        }) => Promise<_ResolvedSpace>;
-        actions?: _SpaceActions;
-    };
-    message?: {
-        schema?: _MessageSchema;
-        actions?: _MessageActions;
-    };
-    messages: FusorMessages<_TPayload>;
-    send: (_: {
-        space: _ResolvedSpace & {
-            id: string;
-            __platform: _Name;
-        };
-        content: Content;
-        client: FusorClient<_TPayload>;
-        config: z__default.infer<_ConfigSchema>;
-        store: Store;
-    }) => Promise<ProviderMessageRecord | undefined>;
-    actions?: {
-        getMessage?: (_: {
-            space: _ResolvedSpace & {
-                id: string;
-                __platform: _Name;
-            };
-            messageId: string;
-            client: FusorClient<_TPayload>;
-            config: z__default.infer<_ConfigSchema>;
-            store: Store;
-        }) => Promise<unknown>;
-    };
+    messages: FusorMessages<_TPayload, z__default.infer<_ConfigSchema>>;
     static?: _Static;
-}): Platform<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, FusorClient<_TPayload>, _ResolvedUser, _ResolvedSpace, _MessageSchema, ProviderMessage<_ResolvedUser, _ResolvedSpace, _MessageSchema extends z__default.ZodType<object> ? z__default.infer<_MessageSchema> : Record<never, never>>, undefined, _SpaceActions, _MessageActions>> & Readonly<_Static>;
+}): Platform<PlatformDef<_Name, _ConfigSchema, _UserSchema, _SpaceSchema, _SpaceParamsSchema, FusorClient<_TPayload>, _ResolvedUser, _ResolvedSpace, _MessageSchema, ProviderMessage<_ResolvedUser, _ResolvedSpace, _MessageSchema extends z__default.ZodType<object> ? z__default.infer<_MessageSchema> : Record<never, never>>, _FusorEvents, _SpaceActions, _MessageActions>> & Readonly<_Static>;
 
 type SpectrumInstance<Providers extends PlatformProviderConfig[] = PlatformProviderConfig[]> = SpectrumLike<Providers> & CustomEventStreams<Providers> & {
     readonly messages: AsyncIterable<[Space, Message]>;
@@ -2837,4 +2782,4 @@ declare class UnsupportedError extends Error {
 declare const fromVCard: (vcf: string) => ContactInput;
 declare const toVCard: (contact: Contact) => Promise<string>;
 
-export { AgentSender, type Avatar, type AvatarInput, Contact, ContactInput, Content, ContentBuilder, ContentInput, type Edit, Emoji, type EmojiKey, EventProducer, type FusorClient, type FusorMessages, type FusorMessagesCtx, type FusorMessagesReturn, type FusorReply, type FusorRespond, type FusorVerify, type FusorVerifyRequest, Message, Platform, PlatformDef, PlatformProviderConfig, ProjectData, ProviderMessage, type Rename, type Reply, Space, Spectrum, type SpectrumInstance, type Typing, UnsupportedError, type UnsupportedKind, User, type WebhookHandler, type WebhookRawRequest, type WebhookRawResult, avatar, defineFusorPlatform, definePlatform, edit, fromVCard, fusor, isFusorClient, rename, reply, resolveContents, toVCard, typing };
+export { AgentSender, type Avatar, type AvatarInput, Contact, ContactInput, Content, ContentBuilder, ContentInput, type DeltaExtractor, type Edit, Emoji, type EmojiKey, EventProducer, FusorClient, FusorMessages, FusorVerify, Message, Platform, PlatformDef, PlatformProviderConfig, ProjectData, ProviderMessage, type Rename, type Reply, Space, Spectrum, type SpectrumInstance, type StreamText, type StreamTextOptions, type StreamTextSource, type Typing, UnsupportedError, type UnsupportedKind, User, WebhookHandler, WebhookRawRequest, WebhookRawResult, avatar, definePlatform, edit, fromVCard, fusor, isFusorClient, rename, reply, resolveContents, streamText, toVCard, typing };