spectrum-ts 1.18.0 → 3.0.0

package/dist/{chunk-JQN6CRSC.js → chunk-CHY5YLLV.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 });
-    }
-  };
-}
+} from "./chunk-LQMDV75O.js";
 
 // 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-5BKZJMZV.js → chunk-EZ5SNNFS.js}

@@ -1,21 +1,26 @@
 import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
 import {
   asVoice
-} from "./chunk-NNY6LMSC.js";
+} from "./chunk-77U6SH5A.js";
+import {
+  asContact
+} from "./chunk-NZ5WCMTY.js";
+import {
+  stream
+} from "./chunk-5XEFJBN2.js";
 import {
-  asContact,
   fromVCard,
   toVCard
-} from "./chunk-QGJFZMD5.js";
+} from "./chunk-6UZFVXQF.js";
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-IPOFBAIM.js";
+} from "./chunk-LX437ZTY.js";
 import {
   asAttachment,
   asCustom,
   reactionSchema
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // src/providers/terminal/index.ts
 import { spawn } from "child_process";
@@ -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") {
@@ -776,41 +781,71 @@ var terminal = definePlatform("Terminal", {
     })
   },
   space: {
-    params: z.object({ id: z.string().optional() }),
-    resolve: async ({ client, input }) => {
-      const id = input.params?.id ?? generateChatId(client);
+    create: async ({ client }) => {
+      const id = generateChatId(client);
       client.knownChats.add(id);
       await client.session.request("ensureSpace", { id });
       return { id };
+    },
+    // Explicit (not the framework default) so targeting a known id still
+    // materializes the chat in the TUI via `ensureSpace`.
+    get: async ({ client, input }) => {
+      client.knownChats.add(input.id);
+      await client.session.request("ensureSpace", { id: input.id });
+      return { id: input.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") {
@@ -828,7 +863,13 @@ var terminal = definePlatform("Terminal", {
         messageId: content.target.id,
         reaction: content.emoji
       });
-      return;
+      const timestamp = /* @__PURE__ */ new Date();
+      return {
+        id: `reaction:${content.target.id}:${content.emoji}:${timestamp.toISOString()}`,
+        content,
+        space: { id: space.id },
+        timestamp
+      };
     }
     if (content.type === "typing") {
       const method = content.state === "start" ? "startTyping" : "stopTyping";

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

@@ -1,19 +1,21 @@
 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-LX437ZTY.js";
 import {
   asAttachment,
   asCustom,
   asReaction,
   asText
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // src/providers/slack/index.ts
 import { createClient as createClient2, staticTokens } from "@photon-ai/slack";
@@ -338,13 +340,12 @@ var send = async (client, space, content) => {
     );
   }
   if (content.type === "reaction") {
-    await reactToMessage(
+    return await reactToMessage(
       client,
       space,
       content.target.ts ?? content.target.id,
-      content.emoji
+      content
     );
-    return;
   }
   if (content.type === "typing") {
     return;
@@ -386,15 +387,23 @@ var sendContent = async (client, space, content, threadTs) => {
       throw UnsupportedError.content(content.type);
   }
 };
-var reactToMessage = async (client, space, targetTs, emoji) => {
+var reactToMessage = async (client, space, targetTs, content) => {
   await client.team(space.teamId).messages.send({
     channel: space.id,
     reaction: {
-      emoji,
+      emoji: content.emoji,
       itemChannel: space.id,
       itemTs: targetTs
     }
   });
+  return {
+    id: `${targetTs}:reaction:self:${content.emoji}`,
+    content,
+    space: { id: space.id, teamId: space.teamId },
+    timestamp: /* @__PURE__ */ new Date(),
+    ts: targetTs,
+    isFromMe: true
+  };
 };
 var replyToMessage = async (client, space, targetTs, content) => await sendContent(client, space, content, targetTs);
 
@@ -422,7 +431,6 @@ var spaceSchema = z.object({
   teamId: z.string()
 });
 var spaceParamsSchema = z.object({
-  channel: z.string().optional(),
   teamId: z.string()
 });
 var messageSchema = z.object({
@@ -473,27 +481,18 @@ var slack = definePlatform("Slack", {
   space: {
     schema: spaceSchema,
     params: spaceParamsSchema,
-    resolve: async ({ input }) => {
+    create: async ({ input }) => {
       const teamId = input.params?.teamId;
       if (!teamId) {
         throw new Error(
-          "Slack space creation requires a teamId param. Pass it via slack.space({ channel, teamId }) or slack.space([user], { teamId })."
-        );
-      }
-      const channel = input.params?.channel;
-      if (channel) {
-        return { id: channel, teamId };
-      }
-      if (input.users.length === 0) {
-        throw new Error(
-          "Slack space creation requires either a channel param or at least one user"
+          "Slack space creation requires a teamId param. Pass it via space.create(user, { teamId })."
         );
       }
       if (input.users.length > 1) {
         throw UnsupportedError.action(
-          "createSpace",
+          "space.create",
           "Slack",
-          "group DMs require an explicit channel id (Slack's conversations.open is not exposed); pass `channel` in params"
+          "group DMs require an explicit channel id (Slack's conversations.open is not exposed); use space.get(channelId, { teamId })"
         );
       }
       const user = input.users[0];
@@ -501,6 +500,15 @@ var slack = definePlatform("Slack", {
         throw new Error("Slack space creation requires a user");
       }
       return { id: user.id, teamId };
+    },
+    get: async ({ input }) => {
+      const teamId = input.params?.teamId;
+      if (!teamId) {
+        throw new Error(
+          "Slack spaces require a teamId param. Pass it via space.get(channelId, { teamId })."
+        );
+      }
+      return { id: input.id, teamId };
     }
   },
   message: {

package/dist/{chunk-2ILTJC35.js → chunk-LQMDV75O.js}

@@ -195,16 +195,202 @@ function custom(raw) {
 }
 
 // src/content/text.ts
+import z5 from "zod";
+
+// src/content/stream-text.ts
 import z4 from "zod";
-var textSchema = z4.object({
-  type: z4.literal("text"),
-  text: z4.string().nonempty()
+var streamTextSchema = z4.object({
+  type: z4.literal("streamText"),
+  // A single-consumption producer of normalized text deltas. The builder
+  // closes over the normalized source; the platform driver calls it once.
+  // Kept opaque to Zod via `z.custom` (same approach as `attachment.read`).
+  stream: z4.custom(
+    (v) => typeof v === "function",
+    {
+      message: "streamText.stream must be a function returning AsyncIterable<string>"
+    }
+  ),
+  // How platforms should interpret the accumulated text; absent = plain.
+  format: z4.enum(["plain", "markdown"]).optional()
 });
-var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
-function text(text2) {
+var asRecord = (value) => typeof value === "object" && value !== null ? value : void 0;
+var SKIP_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "message_start",
+  "message_delta",
+  "message_stop",
+  "content_block_start",
+  "content_block_stop",
+  "ping"
+]);
+var fromOpenAIResponses = (obj) => {
+  const type = obj.type;
+  if (typeof type !== "string" || !type.startsWith("response.")) {
+    return;
+  }
+  if (type === "response.output_text.delta" && typeof obj.delta === "string") {
+    return obj.delta;
+  }
+  return null;
+};
+var fromAnthropicDelta = (obj) => {
+  if (obj.type !== "content_block_delta") {
+    return;
+  }
+  const delta = asRecord(obj.delta);
+  if (delta?.type === "text_delta" && typeof delta.text === "string") {
+    return delta.text;
+  }
+  return null;
+};
+var fromAiSdkPart = (obj) => {
+  if (obj.type !== "text-delta") {
+    return;
+  }
+  if (typeof obj.textDelta === "string") {
+    return obj.textDelta;
+  }
+  return typeof obj.text === "string" ? obj.text : null;
+};
+var fromOpenAIChat = (obj) => {
+  if (!Array.isArray(obj.choices)) {
+    return;
+  }
+  const delta = asRecord(asRecord(obj.choices[0])?.delta);
+  const content = delta?.content;
+  return typeof content === "string" ? content : null;
+};
+var fromControlEvent = (obj) => typeof obj.type === "string" && SKIP_EVENT_TYPES.has(obj.type) ? null : void 0;
+var OBJECT_EXTRACTORS = [
+  fromOpenAIResponses,
+  fromAnthropicDelta,
+  fromAiSdkPart,
+  fromOpenAIChat,
+  fromControlEvent
+];
+var defaultExtract = (chunk) => {
+  if (typeof chunk === "string") {
+    return chunk;
+  }
+  const record = asRecord(chunk);
+  if (!record) {
+    throw new Error(
+      `text stream: cannot extract a text delta from a ${typeof chunk} chunk. Pass { extract } to map your stream's chunks to text.`
+    );
+  }
+  for (const extractor of OBJECT_EXTRACTORS) {
+    const result = extractor(record);
+    if (result !== void 0) {
+      return result;
+    }
+  }
+  throw new Error(
+    `text stream: unrecognized chunk shape (type=${String(record.type)}). Pass an { extract } function to map your provider's chunk to a text delta.`
+  );
+};
+var isReadableStream = (value) => typeof value?.getReader === "function";
+var isAsyncIterable = (value) => typeof value?.[Symbol.asyncIterator] === "function";
+async function* readableToAsync(source) {
+  if (isAsyncIterable(source)) {
+    yield* source;
+    return;
+  }
+  const reader = source.getReader();
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) {
+        return;
+      }
+      yield value;
+    }
+  } finally {
+    reader.releaseLock();
+  }
+}
+var resolveChunkIterable = (source) => {
+  const textStream = source.textStream;
+  if (textStream != null) {
+    if (isReadableStream(textStream)) {
+      return readableToAsync(textStream);
+    }
+    if (isAsyncIterable(textStream)) {
+      return textStream;
+    }
+    throw new Error(
+      "text stream: `.textStream` must be an AsyncIterable or a ReadableStream."
+    );
+  }
+  if (isReadableStream(source)) {
+    return readableToAsync(source);
+  }
+  if (isAsyncIterable(source)) {
+    return source;
+  }
+  throw new Error(
+    "text stream: source must be an AsyncIterable, a ReadableStream, or an object with a `.textStream` (e.g. the AI SDK streamText() result)."
+  );
+};
+var StreamConsumedError = class extends Error {
+  constructor() {
+    super(
+      "text stream: this source has already been consumed \u2014 a stream can only be sent once."
+    );
+    this.name = "StreamConsumedError";
+  }
+};
+var normalize = (source, options) => {
+  const extract = options?.extract ? options.extract : defaultExtract;
+  let consumed = false;
+  return async function* normalized() {
+    if (consumed) {
+      throw new StreamConsumedError();
+    }
+    consumed = true;
+    for await (const chunk of resolveChunkIterable(source)) {
+      const delta = extract(chunk);
+      if (delta) {
+        yield delta;
+      }
+    }
+  };
+};
+var asStreamText = (input) => streamTextSchema.parse({
+  type: "streamText",
+  stream: input.stream,
+  ...input.format ? { format: input.format } : {}
+});
+var drainStreamText = async (content) => {
+  let full = "";
+  for await (const delta of content.stream()) {
+    full += delta;
+  }
+  return full;
+};
+var streamTextBuilder = (kind, source, options) => {
+  if (typeof source.build === "function") {
+    throw new Error(
+      `${kind}(): pass the stream source itself (an AsyncIterable, a ReadableStream, or an SDK result with .textStream), not another content builder.`
+    );
+  }
   return {
-    build: async () => asText(text2)
+    build: async () => asStreamText({
+      stream: normalize(source, options),
+      format: kind === "markdown" ? "markdown" : void 0
+    })
   };
+};
+
+// src/content/text.ts
+var textSchema = z5.object({
+  type: z5.literal("text"),
+  text: z5.string().nonempty()
+});
+var asText = (text2) => textSchema.parse({ type: "text", text: text2 });
+function text(source, options) {
+  if (typeof source === "string") {
+    return { build: async () => asText(source) };
+  }
+  return streamTextBuilder("text", source, options);
 }
 
 // src/content/resolve.ts
@@ -213,12 +399,12 @@ var resolveContents = (items) => Promise.all(
 );
 
 // src/content/reaction.ts
-import z5 from "zod";
+import z6 from "zod";
 var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var reactionSchema = z5.object({
-  type: z5.literal("reaction"),
-  emoji: z5.string().min(1),
-  target: z5.custom(isMessage, {
+var reactionSchema = z6.object({
+  type: z6.literal("reaction"),
+  emoji: z6.string().min(1),
+  target: z6.custom(isMessage, {
     message: "reaction target must be a Message"
   })
 });
@@ -226,6 +412,11 @@ var asReaction = (input) => reactionSchema.parse({ type: "reaction", ...input })
 function reaction(emoji, target) {
   return {
     build: async () => {
+      if (!target) {
+        throw new Error(
+          "reaction() target is undefined \u2014 the targeted message was never sent (space.send resolves undefined when a platform skips unsupported content)"
+        );
+      }
       if (target.content.type === "reaction") {
         throw new Error('reaction() cannot target "reaction" content');
       }
@@ -250,6 +441,9 @@ export {
   attachment,
   asCustom,
   custom,
+  StreamConsumedError,
+  drainStreamText,
+  streamTextBuilder,
   textSchema,
   asText,
   text,