spectrum-ts 1.17.1 → 2.0.0

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;
@@ -373,8 +381,8 @@ declare function rename(displayName: string): ContentBuilder;
  * `message.reply(content)` is sugar that delegates here. Providers see
  * `reply` like any other content type and route to a threaded send.
  *
- * Reply cannot wrap `reply`, `edit`, `reaction`, `group`, `typing`, `rename`,
- * or `avatar` content.
+ * Reply cannot wrap `reply`, `edit`, `reaction`, `group`, `typing`,
+ * `rename`, or `avatar` content.
  */
 declare const replySchema: z__default.ZodObject<{
     type: z__default.ZodLiteral<"reply">;
@@ -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 };