spectrum-ts 1.18.0 → 3.0.0

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

@@ -3,23 +3,25 @@ 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-NZ5WCMTY.js";
+import {
+  mergeStreams,
+  stream
+} from "./chunk-5XEFJBN2.js";
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-LX437ZTY.js";
 import {
   asAttachment,
   asCustom,
   asReaction,
   asText
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // src/providers/whatsapp-business/index.ts
 import { createClient as createClient2 } from "@photon-ai/whatsapp-business";
@@ -637,8 +639,7 @@ var send = async (clients, spaceId, content) => {
     );
   }
   if (content.type === "reaction") {
-    await reactToMessage(clients, spaceId, content.target.id, content.emoji);
-    return;
+    return await reactToMessage(clients, spaceId, content);
   }
   if (content.type === "typing") {
     return;
@@ -704,11 +705,12 @@ var send = async (clients, spaceId, content) => {
       throw UnsupportedError.content(content.type);
   }
 };
-var reactToMessage = async (clients, spaceId, messageId, reaction) => {
-  await primary(clients).messages.send({
+var reactToMessage = async (clients, spaceId, content) => {
+  const result = await primary(clients).messages.send({
     to: spaceId,
-    reaction: { messageId, emoji: reaction }
+    reaction: { messageId: content.target.id, emoji: content.emoji }
   });
+  return toRecord(result, spaceId, content);
 };
 var replyToMessage = async (clients, spaceId, messageId, content) => {
   const client = primary(clients);
@@ -831,13 +833,13 @@ var whatsappBusiness = definePlatform("WhatsApp Business", {
   },
   space: {
     schema: spaceSchema,
-    resolve: async ({ input }) => {
+    create: async ({ input }) => {
       if (input.users.length === 0) {
         throw new Error("WhatsApp space creation requires at least one user");
       }
       if (input.users.length > 1) {
         throw UnsupportedError.action(
-          "createSpace",
+          "space.create",
           "WhatsApp Business",
           "only 1:1 conversations are supported"
         );

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-WePAHfcH.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-YqCNUDIt.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, R as Reaction, H as ReactionBuilder, S as SchemaMessage, J as SharedTokenData, K as SlackTeamMeta, L as SlackTokenData, N as SpaceNamespace, O as SpectrumCloudError, Q as SubscriptionData, T as SubscriptionStatus, V as TokenData, W as broadcast, X as cloud, Y as mergeStreams, Z as reaction, _ as stream } from './types-YqCNUDIt.js';
+import { S as StreamTextSource, T as TextStreamOptions, C as ContactInput, a as Contact } from './authoring-DDh3muGT.js';
+export { b as ContactAddress, c as ContactDetails, d as ContactEmail, e as ContactName, f as ContactOrg, g as ContactPhone, D as DeltaExtractor, G as Group, P as Poll, h as PollChoice, i as PollChoiceInput, j as PollOption, R as Richlink, k as StreamText, V as Voice, l as contact, m as custom, n as group, o as option, p as poll, r as richlink, t as text, v as voice } from './authoring-DDh3muGT.js';
+import { a as FusorVerify, F as FusorClient, b as FusorMessages, W as WebhookHandler, c as WebhookRawRequest, d as WebhookRawResult } from './types-BujGKBin.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-BujGKBin.js';
 import 'hotscript';
 import 'vcf';
 
@@ -65,7 +67,7 @@ declare function avatar(input: Buffer, options: {
  * (no new message id is produced; the existing message mutates in place).
  *
  * Edit cannot wrap `edit`, `reply`, `reaction`, `group`, `typing`, `rename`,
- * or `avatar` content.
+ * `avatar`, or `unsend` content.
  */
 declare const editSchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"edit">;
@@ -81,6 +83,9 @@ declare const editSchema: z__default.ZodObject<{
     } | {
         type: "text";
         text: string;
+    } | {
+        type: "markdown";
+        markdown: string;
     } | {
         type: "attachment";
         id: string;
@@ -89,6 +94,10 @@ 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>;
+        format?: "markdown" | "plain" | undefined;
     } | {
         type: "custom";
         raw: unknown;
@@ -185,6 +194,9 @@ declare const editSchema: z__default.ZodObject<{
         content: {
             type: "text";
             text: string;
+        } | {
+            type: "markdown";
+            markdown: string;
         } | {
             type: "attachment";
             id: string;
@@ -213,6 +225,9 @@ declare const editSchema: z__default.ZodObject<{
     } | {
         type: "text";
         text: string;
+    } | {
+        type: "markdown";
+        markdown: string;
     } | {
         type: "attachment";
         id: string;
@@ -221,6 +236,10 @@ 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>;
+        format?: "markdown" | "plain" | undefined;
     } | {
         type: "custom";
         raw: unknown;
@@ -317,6 +336,9 @@ declare const editSchema: z__default.ZodObject<{
         content: {
             type: "text";
             text: string;
+        } | {
+            type: "markdown";
+            markdown: string;
         } | {
             type: "attachment";
             id: string;
@@ -344,7 +366,38 @@ type Edit = z__default.infer<typeof editSchema>;
  * this with an inbound target throws at build time so the misuse surfaces
  * before the send pipeline runs.
  */
-declare function edit(content: ContentInput, target: Message): ContentBuilder;
+declare function edit(content: ContentInput, target: Message | undefined): ContentBuilder;
+
+/**
+ * Styled text written in standard markdown (CommonMark plus GFM tables and
+ * strikethrough). Outbound-only by design: inbound messages always surface as
+ * `text` content — no provider maps platform formatting back to markdown.
+ * Each platform renders the markdown to its native format (Telegram: HTML via
+ * `parse_mode`; remote iMessage: styled text via UTF-16 formatting ranges);
+ * platforms without native support receive readable plain text via the send
+ * pipeline's markdown fallback.
+ */
+declare const markdownSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"markdown">;
+    markdown: z__default.ZodString;
+}, z__default.core.$strip>;
+type Markdown = z__default.infer<typeof markdownSchema>;
+/**
+ * Send styled text written in standard markdown — a static string or a
+ * streaming LLM response.
+ *
+ * - `markdown("**hi**")` sends the markdown as one message.
+ * - `markdown(source)` marks a text stream as markdown: platforms with native
+ *   support stream it styled (Telegram renders drafts and the final message
+ *   via `parse_mode`), and everywhere else the accumulated text falls back
+ *   through the markdown chain instead of surfacing raw `**` markers.
+ *
+ * Stream sources and options work exactly as in `text()` — any SDK streaming
+ * result or `AsyncIterable` / `ReadableStream`, with `options.extract` for
+ * unrecognized chunk shapes.
+ */
+declare function markdown(source: string): ContentBuilder;
+declare function markdown<T = unknown>(source: StreamTextSource<T>, options?: TextStreamOptions<T>): ContentBuilder;
 
 /**
  * Rename the current chat. Universal content — providers dispatch by
@@ -374,7 +427,7 @@ declare function rename(displayName: string): ContentBuilder;
  * `reply` like any other content type and route to a threaded send.
  *
  * Reply cannot wrap `reply`, `edit`, `reaction`, `group`, `typing`,
- * `rename`, or `avatar` content.
+ * `rename`, `avatar`, or `unsend` content.
  */
 declare const replySchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"reply">;
@@ -390,6 +443,9 @@ declare const replySchema: z__default.ZodObject<{
     } | {
         type: "text";
         text: string;
+    } | {
+        type: "markdown";
+        markdown: string;
     } | {
         type: "attachment";
         id: string;
@@ -398,6 +454,10 @@ 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>;
+        format?: "markdown" | "plain" | undefined;
     } | {
         type: "custom";
         raw: unknown;
@@ -494,6 +554,9 @@ declare const replySchema: z__default.ZodObject<{
         content: {
             type: "text";
             text: string;
+        } | {
+            type: "markdown";
+            markdown: string;
         } | {
             type: "attachment";
             id: string;
@@ -522,6 +585,9 @@ declare const replySchema: z__default.ZodObject<{
     } | {
         type: "text";
         text: string;
+    } | {
+        type: "markdown";
+        markdown: string;
     } | {
         type: "attachment";
         id: string;
@@ -530,6 +596,10 @@ 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>;
+        format?: "markdown" | "plain" | undefined;
     } | {
         type: "custom";
         raw: unknown;
@@ -626,6 +696,9 @@ declare const replySchema: z__default.ZodObject<{
         content: {
             type: "text";
             text: string;
+        } | {
+            type: "markdown";
+            markdown: string;
         } | {
             type: "attachment";
             id: string;
@@ -646,13 +719,13 @@ declare const replySchema: z__default.ZodObject<{
     target: z__default.ZodCustom<Message<string, User, Space<unknown>>, Message<string, User, Space<unknown>>>;
 }, z__default.core.$strip>;
 type Reply = z__default.infer<typeof replySchema>;
-declare function reply(content: ContentInput, target: Message): ContentBuilder;
+declare function reply(content: ContentInput, target: Message | undefined): ContentBuilder;
 
 declare const resolveContents: (items: readonly ContentInput[]) => Promise<Content[]>;
 
 /**
  * A `typing` content value carries a typing-indicator signal — either
- * `"start"` or `"stop"`. Like `reaction`, it's fire-and-forget: providers
+ * `"start"` or `"stop"`. Like `edit`, it's fire-and-forget: providers
  * dispatch on `content.type === "typing"` inside their `send()` action and
  * `space.send(typing(...))` resolves to `undefined`.
  *
@@ -677,6 +750,41 @@ type Typing = z__default.infer<typeof typingSchema>;
  */
 declare function typing(state?: "start" | "stop"): ContentBuilder;
 
+/**
+ * An `unsend` retracts a previously-sent outbound message.
+ *
+ * `space.send(unsend(message))` is the canonical outbound API;
+ * `message.unsend()` and `space.unsend(message)` are sugar that delegate
+ * here. Unsends are fire-and-forget — providers handle them inside their
+ * `send` action and the resolved value is `undefined` (no new message id is
+ * produced; the existing message is retracted in place).
+ *
+ * Platform constraints surface from the provider at send time — e.g.
+ * iMessage enforces Apple's ~2-minute unsend window for regular messages
+ * (reaction removal is not time-limited), and a late or repeated unsend
+ * rejects with the provider's error. `space.getMessage(id)` results are
+ * wrapped as inbound, so a message cannot be unsent from a refetched id
+ * after a restart — keep the Message returned by `send` (same limitation
+ * as `edit`).
+ */
+declare const unsendSchema: z__default.ZodObject<{
+    type: z__default.ZodLiteral<"unsend">;
+    target: z__default.ZodCustom<Message<string, User, Space<unknown>>, Message<string, User, Space<unknown>>>;
+}, z__default.core.$strip>;
+type Unsend = z__default.infer<typeof unsendSchema>;
+/**
+ * Construct an `unsend` content value retracting `target`.
+ *
+ * Only outbound messages (those sent by the agent) can be unsent; calling
+ * this with an inbound target throws at build time so the misuse surfaces
+ * before the send pipeline runs.
+ *
+ * Accepts `Message | undefined` so `space.send` results chain without
+ * narrowing (`send` resolves `undefined` when a platform skips unsupported
+ * content); an undefined target throws at build time.
+ */
+declare function unsend(target: Message | undefined): ContentBuilder;
+
 declare const Emoji: {
     readonly love: "❤️";
     readonly like: "👍";
@@ -2601,66 +2709,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 +2730,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 +2744,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 +2833,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 Edit, Emoji, type EmojiKey, EventProducer, FusorClient, FusorMessages, FusorVerify, type Markdown, Message, Platform, PlatformDef, PlatformProviderConfig, ProjectData, ProviderMessage, type Rename, type Reply, Space, Spectrum, type SpectrumInstance, StreamTextSource, TextStreamOptions, type Typing, type Unsend, UnsupportedError, type UnsupportedKind, User, WebhookHandler, WebhookRawRequest, WebhookRawResult, avatar, definePlatform, edit, fromVCard, fusor, isFusorClient, markdown, rename, reply, resolveContents, toVCard, typing, unsend };