spectrum-ts 4.1.0 → 5.0.0

package/dist/chunk-UXAKIXVM.js

@@ -1,409 +0,0 @@
-import { createRequire as __spectrumCreateRequire } from "node:module"; const require = __spectrumCreateRequire(import.meta.url);
-
-// src/content/attachment.ts
-import { randomUUID } from "crypto";
-import { createReadStream } from "fs";
-import { readFile, stat } from "fs/promises";
-import { basename } from "path";
-import { Readable } from "stream";
-import { lookup as lookupMimeType } from "mime-types";
-import z2 from "zod";
-
-// src/utils/io.ts
-import z from "zod";
-var readSchema = z.function({
-  input: [],
-  output: z.promise(z.instanceof(Buffer))
-});
-var streamSchema = z.function({
-  input: [],
-  output: z.promise(z.instanceof(ReadableStream))
-});
-var bufferToStream = (buf) => new ReadableStream({
-  start(controller) {
-    controller.enqueue(buf);
-    controller.close();
-  }
-});
-var DEFAULT_FETCH_TIMEOUT_MS = 1e4;
-var fetchUrlBytes = async (url, options) => {
-  const controller = new AbortController();
-  const timer = setTimeout(
-    () => controller.abort(),
-    options?.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS
-  );
-  try {
-    const res = await fetch(url, {
-      signal: controller.signal,
-      headers: options?.headers
-    });
-    if (!res.ok) {
-      throw new Error(`URL fetch ${url.toString()} returned ${res.status}`);
-    }
-    const data = Buffer.from(await res.arrayBuffer());
-    const mimeType = res.headers.get("content-type") ?? void 0;
-    return { data, mimeType };
-  } finally {
-    clearTimeout(timer);
-  }
-};
-
-// src/content/attachment.ts
-var DEFAULT_ATTACHMENT_NAME = "attachment";
-var attachmentSchema = z2.object({
-  type: z2.literal("attachment"),
-  id: z2.string().nonempty(),
-  name: z2.string().nonempty(),
-  mimeType: z2.string().nonempty(),
-  size: z2.number().int().nonnegative().optional(),
-  read: readSchema,
-  stream: streamSchema
-});
-var resolveAttachmentName = (input, name) => {
-  if (name) {
-    return name;
-  }
-  if (input instanceof URL) {
-    return basename(input.pathname) || DEFAULT_ATTACHMENT_NAME;
-  }
-  if (typeof input === "string") {
-    return basename(input);
-  }
-  return DEFAULT_ATTACHMENT_NAME;
-};
-var resolveAttachmentMimeType = (name, mimeType) => {
-  if (mimeType) {
-    return mimeType;
-  }
-  const resolvedMimeType = lookupMimeType(name);
-  if (!resolvedMimeType) {
-    throw new Error(
-      `Unable to resolve MIME type for attachment "${name}". Pass options.mimeType explicitly.`
-    );
-  }
-  return resolvedMimeType;
-};
-var asAttachment = (input) => {
-  let cached;
-  const read = () => {
-    cached ??= input.read().catch((err) => {
-      cached = void 0;
-      throw err;
-    });
-    return cached;
-  };
-  const stream = input.stream ?? (async () => bufferToStream(await read()));
-  return attachmentSchema.parse({
-    type: "attachment",
-    id: input.id ?? randomUUID(),
-    name: input.name,
-    mimeType: input.mimeType,
-    size: input.size,
-    read,
-    stream
-  });
-};
-function attachment(input, options) {
-  return {
-    build: async () => {
-      const id = options?.id;
-      const name = resolveAttachmentName(input, options?.name);
-      const mimeType = resolveAttachmentMimeType(name, options?.mimeType);
-      if (input instanceof URL) {
-        return asAttachment({
-          id,
-          name,
-          mimeType,
-          read: async () => (await fetchUrlBytes(input)).data
-        });
-      }
-      if (typeof input === "string") {
-        const stats = await stat(input);
-        return asAttachment({
-          id,
-          name,
-          mimeType,
-          size: stats.size,
-          read: () => readFile(input),
-          stream: async () => Readable.toWeb(
-            createReadStream(input)
-          )
-        });
-      }
-      return asAttachment({
-        id,
-        name,
-        mimeType,
-        size: input.byteLength,
-        read: async () => input,
-        stream: async () => bufferToStream(input)
-      });
-    }
-  };
-}
-
-// src/content/custom.ts
-import z3 from "zod";
-var customSchema = z3.object({
-  type: z3.literal("custom"),
-  raw: z3.unknown()
-});
-var asCustom = (raw) => customSchema.parse({ type: "custom", raw });
-function custom(raw) {
-  return {
-    build: async () => asCustom(raw)
-  };
-}
-
-// src/content/text.ts
-import z5 from "zod";
-
-// src/content/stream-text.ts
-import z4 from "zod";
-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 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 () => 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
-var resolveContents = (items) => Promise.all(
-  items.map((c) => typeof c === "string" ? text(c).build() : c.build())
-);
-
-// src/content/reaction.ts
-import z6 from "zod";
-var isMessage = (v) => typeof v === "object" && v !== null && "id" in v && "content" in v;
-var reactionSchema = z6.object({
-  type: z6.literal("reaction"),
-  emoji: z6.string().min(1),
-  target: z6.custom(isMessage, {
-    message: "reaction target must be a Message"
-  })
-});
-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');
-      }
-      return asReaction({ emoji, target });
-    }
-  };
-}
-
-export {
-  readSchema,
-  streamSchema,
-  bufferToStream,
-  fetchUrlBytes,
-  attachmentSchema,
-  asAttachment,
-  attachment,
-  asCustom,
-  custom,
-  StreamConsumedError,
-  drainStreamText,
-  streamTextBuilder,
-  textSchema,
-  asText,
-  text,
-  resolveContents,
-  reactionSchema,
-  asReaction,
-  reaction
-};