spectrum-ts 2.0.0 → 3.0.0

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

@@ -4,7 +4,7 @@ import {
   fetchUrlBytes,
   readSchema,
   streamSchema
-} from "./chunk-2ILTJC35.js";
+} from "./chunk-LQMDV75O.js";
 
 // src/content/richlink.ts
 import z from "zod";

package/dist/{chunk-U3LXXT3W.js → chunk-EZ5SNNFS.js}

@@ -1,10 +1,10 @@
 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-U7AWXDH6.js";
+} from "./chunk-NZ5WCMTY.js";
 import {
   stream
 } from "./chunk-5XEFJBN2.js";
@@ -15,12 +15,12 @@ import {
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-NGC4DJIX.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";
@@ -781,12 +781,18 @@ 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 };
     }
   },
   // Return a ManagedStream (not a native async generator): a native generator
@@ -857,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-WXY5QP3M.js → chunk-FULEQIRQ.js}

@@ -9,13 +9,13 @@ import {
 import {
   UnsupportedError,
   definePlatform
-} from "./chunk-NGC4DJIX.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";
@@ -340,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;
@@ -388,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);
 
@@ -424,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({
@@ -475,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];
@@ -503,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,