poe-code 15.0.21 → 15.0.22

package/packages/safe-bash/dist/chunks/chunk-LR32SJ3D.js

@@ -0,0 +1,915 @@
+import {
+  init_platform
+} from "./chunk-2KL6W6NB.js";
+
+// packages/safe-bash/src/commands/llm/openai.ts
+init_platform();
+
+// packages/safe-bash/src/commands/llm/openai-http.ts
+init_platform();
+function openAiAbortable(pending, signal) {
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve(pending).then((value) => {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted) reject(signal.reason);
+      else resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.aborted ? signal.reason : error);
+    });
+    if (signal.aborted) abort();
+  });
+}
+async function* openAiBytes(source, signal, limit = 64 * 1024 * 1024) {
+  signal.throwIfAborted();
+  const iterator = source[Symbol.asyncIterator]();
+  let failed = false, finished = false;
+  let size = 0;
+  try {
+    while (true) {
+      signal.throwIfAborted();
+      const next = await openAiAbortable(iterator.next(), signal);
+      if (next.done) {
+        finished = true;
+        return;
+      }
+      if (!(next.value instanceof Uint8Array)) throw new Error("OpenAI returned a non-byte response chunk");
+      size += next.value.byteLength;
+      if (size > limit) throw new RangeError("Provider response byte limit exceeded");
+      yield Uint8Array.from(next.value);
+    }
+  } catch (error) {
+    failed = true;
+    throw signal.aborted ? signal.reason : error;
+  } finally {
+    if (!finished) {
+      const returned = Promise.resolve().then(() => iterator.return?.());
+      if (signal.aborted) void returned.catch(() => void 0);
+      else await openAiAbortable(returned, signal).catch((error) => {
+        if (!failed) throw error;
+      });
+    }
+  }
+}
+async function openAiJson(response, signal, maxBytes = 64 * 1024 * 1024) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let text = "", length = 0;
+  for await (const chunk of openAiBytes(response.body, signal, maxBytes)) {
+    length += chunk.byteLength;
+    if (length > maxBytes) throw new Error("OpenAI JSON response exceeds buffer limit");
+    text += decoder.decode(chunk, { stream: true });
+  }
+  text += decoder.decode();
+  let value;
+  try {
+    value = JSON.parse(text);
+  } catch {
+    throw new Error("OpenAI returned malformed JSON");
+  }
+  if (!openAiRecord(value)) throw new Error("OpenAI returned a non-object JSON response");
+  return value;
+}
+function openAiRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function openAiError(value) {
+  if (typeof value === "string" && value) return value.slice(0, 1024);
+  if (openAiRecord(value) && typeof value.message === "string") return value.message.slice(0, 1024);
+  return void 0;
+}
+async function* openAiResponse(transport, input) {
+  input.signal.throwIfAborted();
+  const cleanups = /* @__PURE__ */ new Map();
+  let closed = false, failed = false;
+  const run = (cleanup) => {
+    cleanup.pending ??= Promise.resolve().then(cleanup.run);
+    return cleanup.pending;
+  };
+  const register = (cleanup, receiver) => {
+    if (cleanups.has(cleanup)) return;
+    const entry = { run: () => cleanup.call(receiver) };
+    cleanups.set(cleanup, entry);
+    if (closed) void run(entry).catch(() => void 0);
+  };
+  const close = async () => {
+    closed = true;
+    const results = await Promise.allSettled([...cleanups.values()].map(run));
+    const rejected = results.find((result2) => result2.status === "rejected");
+    if (rejected?.status === "rejected") throw rejected.reason;
+  };
+  const abort = () => {
+    void close().catch(() => void 0);
+  };
+  input.signal.addEventListener("abort", abort, { once: true });
+  try {
+    const pending = Promise.resolve().then(() => {
+      input.signal.throwIfAborted();
+      return transport({ ...input, registerCleanup: register });
+    }).then((response2) => {
+      register(response2.dispose, response2);
+      return response2;
+    });
+    const response = await openAiAbortable(pending, input.signal);
+    if (!Number.isInteger(response.status) || response.status < 200 || response.status >= 300) {
+      let detail;
+      try {
+        detail = openAiError((await openAiJson(response, input.signal, 64 * 1024)).error);
+      } catch {
+        input.signal.throwIfAborted();
+      }
+      throw new Error(`OpenAI HTTP ${response.status}${detail ? `: ${detail}` : ""}`);
+    }
+    yield response;
+  } catch (error) {
+    failed = true;
+    throw input.signal.aborted ? input.signal.reason : error;
+  } finally {
+    input.signal.removeEventListener("abort", abort);
+    await close().catch((error) => {
+      if (!failed && !input.signal.aborted) throw error;
+    });
+    if (!failed) input.signal.throwIfAborted();
+  }
+}
+
+// packages/safe-bash/src/commands/llm/openai-sse.ts
+init_platform();
+async function* events(source, signal, limit, responseLimit) {
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let line = "", data = [], size = 0, afterCarriageReturn = false;
+  for await (const chunk of openAiBytes(source, signal, responseLimit)) {
+    const text = decoder.decode(chunk, { stream: true });
+    for (const character of text) {
+      if (afterCarriageReturn && character === "\n") {
+        afterCarriageReturn = false;
+        continue;
+      }
+      afterCarriageReturn = character === "\r";
+      const codePoint = character.codePointAt(0);
+      size += codePoint < 128 ? 1 : codePoint < 2048 ? 2 : codePoint < 65536 ? 3 : 4;
+      if (size > limit) throw new Error("OpenAI SSE event exceeds buffer limit: event byte limit exceeded");
+      if (character !== "\n" && character !== "\r") {
+        line += character;
+        continue;
+      }
+      if (line === "") {
+        if (data.length > 0) yield data.join("\n");
+        data = [];
+        size = 0;
+      } else if (line === "data" || line.startsWith("data:")) {
+        const value = line.slice(5);
+        data.push(value.startsWith(" ") ? value.slice(1) : value);
+      }
+      line = "";
+    }
+  }
+  decoder.decode();
+  throw new Error("OpenAI chat stream ended before [DONE]");
+}
+async function* openAiChat(source, signal, limit = 1024 * 1024, responseLimit = 64 * 1024 * 1024) {
+  for await (const data of events(source, signal, limit, responseLimit)) {
+    signal.throwIfAborted();
+    if (data.trim() === "[DONE]") return;
+    let parsed;
+    try {
+      parsed = JSON.parse(data);
+    } catch {
+      throw new Error("OpenAI returned malformed SSE JSON");
+    }
+    if (!openAiRecord(parsed)) throw new Error("OpenAI returned a non-object SSE event");
+    if (parsed.error != null) throw new Error(`OpenAI: ${openAiError(parsed.error) ?? "stream failed"}`);
+    if (!Array.isArray(parsed.choices)) throw new Error("OpenAI SSE event has no choices");
+    for (const choice of parsed.choices) {
+      signal.throwIfAborted();
+      if (!openAiRecord(choice) || !openAiRecord(choice.delta)) throw new Error("OpenAI SSE event has a malformed delta");
+      const content = choice.delta.content;
+      if (content != null && typeof content !== "string") throw new Error("OpenAI SSE delta.content is not text");
+      if (typeof content === "string" && content.length > 0) yield content;
+    }
+  }
+}
+
+// packages/safe-bash/src/commands/llm/mime.ts
+init_platform();
+
+// packages/safe-bash/src/commands/file/classify.ts
+init_platform();
+var binary = { description: "data", mime: "application/octet-stream", encoding: "binary" };
+function result(description, mime, encoding = "binary") {
+  return { description, mime, encoding };
+}
+function matches(bytes, signature, offset = 0) {
+  return bytes.length >= offset + signature.length && signature.every((value, index) => bytes[offset + index] === value);
+}
+function ascii(bytes, start, length) {
+  return String.fromCharCode(...bytes.subarray(start, start + length));
+}
+function magic(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (bytes.length >= 33 && matches(bytes, [137, 80, 78, 71, 13, 10, 26, 10]) && view.getUint32(8) === 13 && ascii(bytes, 12, 4) === "IHDR" && view.getUint32(16) > 0 && view.getUint32(20) > 0 && bytes[26] === 0 && bytes[27] === 0 && bytes[28] <= 1) {
+    const allowed = { 0: [1, 2, 4, 8, 16], 2: [8, 16], 3: [1, 2, 4, 8], 4: [8, 16], 6: [8, 16] };
+    if (allowed[bytes[25]]?.includes(bytes[24])) return result("PNG image data", "image/png");
+  }
+  if (bytes.length >= 13 && ["GIF87a", "GIF89a"].includes(ascii(bytes, 0, 6)) && view.getUint16(6, true) > 0 && view.getUint16(8, true) > 0) return result("GIF image data", "image/gif");
+  if (bytes.length >= 4 && matches(bytes, [255, 216, 255]) && bytes[3] >= 192 && bytes[3] <= 254) return result("JPEG image data", "image/jpeg");
+  if (bytes.length >= 20 && ascii(bytes, 0, 4) === "RIFF" && ascii(bytes, 8, 4) === "WEBP" && ["VP8 ", "VP8L", "VP8X"].includes(ascii(bytes, 12, 4)) && view.getUint32(4, true) >= 12) return result("WebP image data", "image/webp");
+  if (bytes.length >= 8 && (matches(bytes, [73, 73, 42, 0]) || matches(bytes, [77, 77, 0, 42]))) return result("TIFF image data", "image/tiff");
+  if (bytes.length >= 26 && ascii(bytes, 0, 2) === "BM" && [12, 40, 52, 56, 108, 124].includes(view.getUint32(14, true))) return result("PC bitmap image data", "image/bmp");
+  if (bytes.length >= 22 && matches(bytes, [0, 0, 1, 0]) && view.getUint16(4, true) > 0) return result("MS Windows icon resource", "image/vnd.microsoft.icon");
+  if (/^%PDF-[12]\.[0-9](?:\r|\n|\s)/u.test(ascii(bytes, 0, 16))) return result("PDF document", "application/pdf");
+  if (bytes.length >= 10 && matches(bytes, [31, 139, 8]) && (bytes[3] & 224) === 0) return result("gzip compressed data", "application/gzip");
+  if (bytes.length >= 10 && ascii(bytes, 0, 3) === "BZh" && bytes[3] >= 49 && bytes[3] <= 57 && (ascii(bytes, 4, 6) === "1AY&SY" || matches(bytes, [23, 114, 69, 56, 80, 144], 4))) return result("bzip2 compressed data", "application/x-bzip2");
+  if (bytes.length >= 12 && matches(bytes, [253, 55, 122, 88, 90, 0]) && bytes[6] === 0 && bytes[7] <= 15) return result("XZ compressed data", "application/x-xz");
+  if (bytes.length >= 6 && matches(bytes, [40, 181, 47, 253]) && (bytes[4] & 24) === 0) return result("Zstandard compressed data", "application/zstd");
+  if (bytes.length >= 30 && matches(bytes, [80, 75, 3, 4]) || bytes.length >= 22 && matches(bytes, [80, 75, 5, 6])) return result("Zip archive data", "application/zip");
+  if (bytes.length >= 32 && matches(bytes, [55, 122, 188, 175, 39, 28])) return result("7-zip archive data", "application/x-7z-compressed");
+  if (bytes.length >= 14 && matches(bytes, [82, 97, 114, 33, 26, 7, 0]) || bytes.length >= 16 && matches(bytes, [82, 97, 114, 33, 26, 7, 1, 0])) return result("RAR archive data", "application/x-rar");
+  if (bytes.length >= 512 && ascii(bytes, 257, 5) === "ustar") {
+    const checksum = ascii(bytes, 148, 8).replace(/\0.*$/u, "").trim();
+    if (/^[0-7]+$/u.test(checksum)) {
+      let total = 0;
+      for (let index = 0; index < 512; index++) total += index >= 148 && index < 156 ? 32 : bytes[index];
+      if (parseInt(checksum, 8) === total) return result("POSIX tar archive", "application/x-tar");
+    }
+  }
+  if (bytes.length >= 52 && matches(bytes, [127, 69, 76, 70]) && [1, 2].includes(bytes[4]) && [1, 2].includes(bytes[5]) && bytes[6] === 1 && (bytes[4] === 1 || bytes.length >= 64)) {
+    const type = view.getUint16(16, bytes[5] === 1);
+    const mime = type === 1 ? "application/x-object" : type === 2 ? "application/x-executable" : type === 3 ? "application/x-sharedlib" : "application/octet-stream";
+    return result(`ELF ${bytes[4] === 1 ? "32" : "64"}-bit ${type === 2 ? "executable" : type === 3 ? "shared object" : "object"}`, mime);
+  }
+  if (bytes.length >= 64 && ascii(bytes, 0, 2) === "MZ") {
+    const offset = view.getUint32(60, true);
+    if (offset >= 64 && offset <= bytes.length - 24 && matches(bytes, [80, 69, 0, 0], offset)) return result("PE executable", "application/vnd.microsoft.portable-executable");
+    return result("DOS executable", "application/x-dosexec");
+  }
+  if (bytes.length >= 8 && matches(bytes, [0, 97, 115, 109, 1, 0, 0, 0])) return result("WebAssembly binary module", "application/wasm");
+  if (bytes.length >= 100 && ascii(bytes, 0, 16) === "SQLite format 3\0") {
+    const size = view.getUint16(16);
+    if ((size === 1 || size >= 512 && size <= 32768 && (size & size - 1) === 0) && [1, 2].includes(bytes[18]) && [1, 2].includes(bytes[19]) && matches(bytes, [64, 32, 32], 21)) return result("SQLite 3.x database", "application/vnd.sqlite3");
+  }
+  if (bytes.length >= 512 && matches(bytes, [208, 207, 17, 224, 161, 177, 26, 225]) && matches(bytes, [254, 255], 28)) return result("OLE Compound Document", "application/x-ole-storage");
+  return void 0;
+}
+function classify(bytes, complete) {
+  if (!bytes.length) return complete ? result("empty", "inode/x-empty") : binary;
+  const recognized = magic(bytes);
+  if (recognized) return recognized;
+  if (matches(bytes, [255, 254, 0, 0]) || matches(bytes, [0, 0, 254, 255])) return binary;
+  let encoding = "utf-8";
+  let bom = 0;
+  if (matches(bytes, [239, 187, 191])) bom = 3;
+  else if (matches(bytes, [255, 254])) {
+    encoding = "utf-16le";
+    bom = 2;
+  } else if (matches(bytes, [254, 255])) {
+    encoding = "utf-16be";
+    bom = 2;
+  }
+  let text;
+  try {
+    text = new TextDecoder(encoding, { fatal: true }).decode(bytes, { stream: !complete });
+  } catch {
+    return binary;
+  }
+  if (!text.length && bytes.length > bom) return binary;
+  for (const character of text) {
+    const code = character.codePointAt(0);
+    if (code < 32 && ![8, 9, 10, 12, 13, 27].includes(code) || code >= 127 && code <= 159) return binary;
+  }
+  if (!bom && encoding === "utf-8" && bytes.every((value) => value < 128)) encoding = "us-ascii";
+  if (complete && /^[\x20\t\r\n]*(?:\{|\[)/u.test(text)) {
+    try {
+      JSON.parse(text);
+      return result("JSON text data", "application/json", encoding);
+    } catch {
+    }
+  }
+  const description = encoding === "us-ascii" ? "ASCII text" : encoding === "utf-8" ? "Unicode text, UTF-8" : `Unicode text, ${encoding === "utf-16le" ? "UTF-16, little-endian" : "UTF-16, big-endian"}`;
+  return result(description, "text/plain", encoding);
+}
+
+// packages/safe-bash/src/commands/llm/mime.ts
+var extensions = {
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  avif: "image/avif",
+  heic: "image/heic",
+  heif: "image/heif",
+  bmp: "image/bmp",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  svg: "image/svg+xml",
+  mp3: "audio/mpeg",
+  wav: "audio/wav",
+  ogg: "audio/ogg",
+  oga: "audio/ogg",
+  opus: "audio/ogg",
+  flac: "audio/flac",
+  aac: "audio/aac",
+  m4a: "audio/mp4",
+  aiff: "audio/aiff",
+  mp4: "video/mp4",
+  m4v: "video/mp4",
+  mov: "video/quicktime",
+  webm: "video/webm",
+  mkv: "video/x-matroska",
+  avi: "video/x-msvideo",
+  ogv: "video/ogg",
+  mpeg: "video/mpeg",
+  mpg: "video/mpeg",
+  pdf: "application/pdf",
+  json: "application/json",
+  zip: "application/zip",
+  gz: "application/gzip",
+  txt: "text/plain",
+  md: "text/markdown",
+  csv: "text/csv",
+  html: "text/html",
+  xml: "application/xml"
+};
+function ebmlInteger(bytes, offset, retainMarker = false) {
+  const first = bytes[offset];
+  if (!first) return void 0;
+  let marker = 128, width = 1;
+  while (!(first & marker)) {
+    marker >>= 1;
+    width++;
+  }
+  if (offset + width > bytes.length) return void 0;
+  let value = retainMarker ? first : first & marker - 1;
+  for (let index = 1; index < width; index++) value = value * 256 + bytes[offset + index];
+  if (!Number.isSafeInteger(value) || !retainMarker && value === 2 ** (7 * width) - 1) return void 0;
+  return { value, width };
+}
+function ebmlMimeType(bytes) {
+  const header = ebmlInteger(bytes, 4);
+  if (!header) return void 0;
+  let offset = 4 + header.width;
+  const end = Math.min(bytes.length, offset + header.value, 4096);
+  while (offset < end) {
+    const identifier = ebmlInteger(bytes, offset, true);
+    if (!identifier) return void 0;
+    offset += identifier.width;
+    const size = ebmlInteger(bytes, offset);
+    if (!size) return void 0;
+    offset += size.width;
+    if (size.value > end - offset) return void 0;
+    if (identifier.value === 17026) {
+      const docType = new TextDecoder().decode(bytes.subarray(offset, offset + size.value)).split("\0", 1)[0];
+      if (docType === "webm") return "video/webm";
+      if (docType === "matroska") return "video/x-matroska";
+      return void 0;
+    }
+    offset += size.value;
+  }
+  return void 0;
+}
+function sniffMimeType(path, bytes) {
+  const matches2 = (signature, offset = 0) => bytes.length >= offset + signature.length && signature.every((byte, index) => bytes[offset + index] === byte);
+  const ascii2 = (offset, text) => bytes.length >= offset + text.length && [...text].every((character, index) => bytes[offset + index] === character.charCodeAt(0));
+  if (matches2([137, 80, 78, 71, 13, 10, 26, 10])) return "image/png";
+  if (matches2([255, 216, 255])) return "image/jpeg";
+  if (ascii2(0, "GIF87a") || ascii2(0, "GIF89a")) return "image/gif";
+  if (ascii2(0, "RIFF")) {
+    if (ascii2(8, "WEBP")) return "image/webp";
+    if (ascii2(8, "WAVE")) return "audio/wav";
+    if (ascii2(8, "AVI ")) return "video/x-msvideo";
+  }
+  if (ascii2(0, "fLaC")) return "audio/flac";
+  if (ascii2(0, "OggS")) {
+    const packet = 27 + (bytes[26] ?? 0);
+    if (bytes[26] && bytes[packet] === 128 && ascii2(packet + 1, "theora")) return "video/ogg";
+    return "audio/ogg";
+  }
+  if (ascii2(0, "ID3") || bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 224) === 224 && (bytes[1] & 6) !== 0) return "audio/mpeg";
+  if (bytes.length >= 2 && bytes[0] === 255 && (bytes[1] & 246) === 240) return "audio/aac";
+  if (ascii2(0, "FORM") && (ascii2(8, "AIFF") || ascii2(8, "AIFC"))) return "audio/aiff";
+  if (ascii2(4, "ftyp")) {
+    if (ascii2(8, "avif") || ascii2(8, "avis")) return "image/avif";
+    if (ascii2(8, "heic") || ascii2(8, "heix")) return "image/heic";
+    if (ascii2(8, "mif1") || ascii2(8, "msf1")) return "image/heif";
+    if (ascii2(8, "M4A ") || ascii2(8, "M4B ")) return "audio/mp4";
+    if (ascii2(8, "qt  ")) return "video/quicktime";
+    return "video/mp4";
+  }
+  if (matches2([26, 69, 223, 163])) {
+    const mimeType = ebmlMimeType(bytes);
+    if (mimeType) return mimeType;
+  }
+  if (ascii2(0, "%PDF-")) return "application/pdf";
+  if (matches2([80, 75, 3, 4]) || matches2([80, 75, 5, 6])) return "application/zip";
+  if (matches2([31, 139])) return "application/gzip";
+  if (matches2([73, 73, 42, 0]) || matches2([77, 77, 0, 42])) return "image/tiff";
+  if (ascii2(0, "BM")) return "image/bmp";
+  const prefix = bytes.subarray(0, 512);
+  const classified = classify(prefix, bytes.length <= prefix.length).mime;
+  if (!["application/octet-stream", "text/plain", "inode/x-empty"].includes(classified)) return classified;
+  const filename = path.slice(path.lastIndexOf("/") + 1);
+  const dot = filename.lastIndexOf(".");
+  const extension = dot < 0 ? "" : filename.slice(dot + 1).toLowerCase();
+  return Object.hasOwn(extensions, extension) ? extensions[extension] : classified === "inode/x-empty" ? "application/octet-stream" : classified;
+}
+function acceptsMimeType(types, mimeType) {
+  if ([...mimeType].some((character) => character.charCodeAt(0) < 32 || character.charCodeAt(0) === 127)) return false;
+  const mime = mimeType.split(";", 1)[0].trim().toLowerCase();
+  const parts = mime.split("/");
+  if (parts.length !== 2 || parts.some((part) => !part || [...part].some((character) => !(character >= "a" && character <= "z" || character >= "0" && character <= "9" || "!#$%&'+-.^_`|~".includes(character))))) return false;
+  return types.some((type) => {
+    const accepted = type.toLowerCase();
+    return accepted === mime || accepted.endsWith("/*") && accepted.slice(0, -2) === parts[0];
+  });
+}
+
+// packages/safe-bash/src/commands/llm/providers/shared.ts
+init_platform();
+function providerLimits(input = {}) {
+  const limits = { maxRequestBytes: 64 * 1024 * 1024, maxResponseBytes: 64 * 1024 * 1024, maxEventBytes: 1024 * 1024, maxPolls: 120, pollIntervalMs: 1e3, ...input };
+  for (const [name, value] of Object.entries(limits)) {
+    if (!Number.isSafeInteger(value) || value < (name === "maxPolls" || name === "pollIntervalMs" ? 0 : 1)) throw new RangeError(`Invalid provider limit: ${name}`);
+  }
+  return Object.freeze(limits);
+}
+function credential(value) {
+  if (typeof value !== "string" || value.length === 0 || [...value].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) === 127)) throw new TypeError("Invalid provider apiKey");
+  return value;
+}
+function jsonBody(value, limit) {
+  const text = JSON.stringify(value);
+  if (text.length > limit) throw new RangeError("Provider request byte limit exceeded");
+  const bytes = new TextEncoder().encode(text);
+  if (bytes.length > limit) throw new RangeError("Provider request byte limit exceeded");
+  return { body: (async function* () {
+    yield bytes;
+  })(), headers: [["content-type", "application/json"]] };
+}
+function multipart(options, files, limit) {
+  const encoder = new TextEncoder();
+  const parts = [];
+  const entries = Object.entries(options).map(([name, value]) => {
+    if (![...name].every((char) => "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-".includes(char))) throw new TypeError("Invalid multipart option name");
+    return [name, String(value)];
+  });
+  let size = files.reduce((sum, file) => sum + file.bytes.length, 0);
+  for (const [, value] of entries) {
+    if (value.length > limit) throw new RangeError("Provider request byte limit exceeded");
+    size += encoder.encode(value).length;
+  }
+  if (size > limit) throw new RangeError("Provider request byte limit exceeded");
+  let boundary = "safe-bash-llm-boundary";
+  const contains = (bytes, needle) => {
+    outer: for (let start = 0; start <= bytes.length - needle.length; start++) {
+      for (let index = 0; index < needle.length; index++) if (bytes[start + index] !== needle[index]) continue outer;
+      return true;
+    }
+    return false;
+  };
+  let attempts = 0;
+  while (entries.some(([, value]) => value.includes(boundary)) || files.some((file) => contains(file.bytes, encoder.encode(boundary)))) {
+    if (attempts++ === 32) throw new RangeError("Provider multipart boundary collision limit exceeded");
+    boundary += "x";
+  }
+  for (const [name, value] of entries) parts.push(encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${name}"\r
+\r
+${value}\r
+`));
+  for (const [index, file] of files.entries()) {
+    if ([...file.mimeType].some((char) => char.charCodeAt(0) < 32 || char.charCodeAt(0) > 126)) throw new TypeError("Invalid attachment MIME type");
+    parts.push(encoder.encode(`--${boundary}\r
+Content-Disposition: form-data; name="${file.field}"; filename="attachment-${index}"\r
+Content-Type: ${file.mimeType}\r
+\r
+`), Uint8Array.from(file.bytes), encoder.encode("\r\n"));
+  }
+  parts.push(encoder.encode(`--${boundary}--\r
+`));
+  if (parts.reduce((sum, part) => sum + part.length, 0) > limit) throw new RangeError("Provider request byte limit exceeded");
+  return { body: (async function* () {
+    yield* parts;
+  })(), headers: [["content-type", `multipart/form-data; boundary=${boundary}`]] };
+}
+
+// packages/safe-bash/src/commands/llm/openai.ts
+var numericOptions = {
+  chat: /* @__PURE__ */ new Map([
+    ["temperature", "number"],
+    ["top_p", "number"],
+    ["frequency_penalty", "number"],
+    ["presence_penalty", "number"],
+    ["max_tokens", "integer"],
+    ["max_completion_tokens", "integer"],
+    ["n", "integer"],
+    ["seed", "integer"],
+    ["top_logprobs", "integer"]
+  ]),
+  images: /* @__PURE__ */ new Map([
+    ["n", "integer"],
+    ["output_compression", "integer"],
+    ["partial_images", "integer"]
+  ])
+};
+function jsonOptions(options, endpoint) {
+  return Object.fromEntries(Object.entries(options).map(([key, value]) => {
+    if ((endpoint === "chat" ? ["store", "parallel_tool_calls", "logprobs"] : ["stream"]).includes(key)) {
+      if (value !== "true" && value !== "false") throw new Error(`Invalid OpenAI option ${key}: expected boolean`);
+      return [key, value === "true"];
+    }
+    const type = numericOptions[endpoint].get(key);
+    if (!type) return [key, value];
+    const number = value.trim() ? Number(value) : NaN;
+    if (!Number.isFinite(number) || type === "integer" && !Number.isSafeInteger(number)) {
+      throw new Error(`Invalid OpenAI option ${key}: expected a finite ${type === "integer" ? "safe integer" : "number"}`);
+    }
+    return [key, number];
+  }));
+}
+function base64(bytes) {
+  let binary2 = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192) {
+    binary2 += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  }
+  return btoa(binary2);
+}
+function imageBytes(value) {
+  if (typeof value !== "string" || value.length === 0) throw new Error("OpenAI image response has no b64_json");
+  let decoded;
+  try {
+    decoded = atob(value);
+  } catch {
+    throw new Error("OpenAI image response contains invalid base64");
+  }
+  if (btoa(decoded) !== value) throw new Error("OpenAI image response contains non-canonical base64");
+  return Uint8Array.from(decoded, (character) => character.charCodeAt(0));
+}
+function waitForPoll(signal, interval) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      clearTimeout(timer);
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    const timer = setTimeout(() => {
+      signal.removeEventListener("abort", abort);
+      resolve();
+    }, interval);
+    signal.addEventListener("abort", abort, { once: true });
+    if (signal.aborted) abort();
+  });
+}
+function job(value, expectedId) {
+  if (value.error != null) throw new Error(`OpenAI video failed: ${openAiError(value.error) ?? "unknown error"}`);
+  if (typeof value.id !== "string" || value.id.length === 0 || value.id === "." || value.id === ".." || expectedId !== void 0 && value.id !== expectedId) {
+    throw new Error("OpenAI video response has an invalid job id");
+  }
+  if (value.status !== "queued" && value.status !== "in_progress" && value.status !== "completed") {
+    throw new Error(`OpenAI video failed: ${typeof value.status === "string" ? value.status : "invalid status"}`);
+  }
+  return { id: value.id, status: value.status };
+}
+function createOpenAiProvider(options) {
+  const { transport, apiKey } = options;
+  const limits = providerLimits(options.limits);
+  if (typeof transport !== "function") throw new TypeError("OpenAI requires an injected HTTP transport");
+  if (typeof apiKey !== "string" || !apiKey.trim() || apiKey.includes("\r") || apiKey.includes("\n")) throw new TypeError("OpenAI requires a valid API key");
+  credential(apiKey);
+  const base = new URL(options.baseUrl ?? "https://api.openai.com/v1");
+  if (base.protocol !== "https:" && base.protocol !== "http:" || base.username || base.password || base.search || base.hash) {
+    throw new TypeError("OpenAI baseUrl must be an HTTP(S) URL without credentials, query or fragment");
+  }
+  const baseUrl = base.href.endsWith("/") ? base.href.slice(0, -1) : base.href;
+  const configured = options.models.map((model) => Object.freeze({
+    ...model,
+    ...model.aliases === void 0 ? {} : { aliases: Object.freeze([...model.aliases]) },
+    ...model.attachmentTypes === void 0 ? {} : { attachmentTypes: Object.freeze([...model.attachmentTypes]) }
+  }));
+  const byId = /* @__PURE__ */ new Map();
+  for (const model of configured) {
+    if (!model.id || byId.has(model.id)) throw new TypeError(`OpenAI duplicate or empty model id: ${model.id}`);
+    if (!["chat", "images", "videos"].includes(model.endpoint)) throw new TypeError(`OpenAI invalid endpoint for model: ${model.id}`);
+    if (model.endpoint === "images" && !acceptsMimeType(["image/png", "image/jpeg", "image/webp"], model.outputType ?? "")) throw new TypeError("Image models require outputType image/png, image/jpeg or image/webp");
+    if (model.endpoint === "videos" && !acceptsMimeType(["video/mp4"], model.outputType ?? "")) throw new TypeError("Video models require outputType video/mp4");
+    if (model.endpoint === "chat" && model.outputType !== void 0 && !acceptsMimeType(["text/*"], model.outputType)) throw new TypeError("Chat models require a text outputType");
+    byId.set(model.id, model);
+  }
+  return {
+    name: "openai",
+    models: Object.freeze(configured),
+    async *complete(request) {
+      request.signal.throwIfAborted();
+      const model = byId.get(request.model);
+      if (!model) throw new Error(`Unknown model: ${request.model}`);
+      if (request.attachments.some((attachment) => !acceptsMimeType(["image/*"], attachment.mimeType))) {
+        throw new Error(`OpenAI ${model.endpoint} endpoint only supports image attachments`);
+      }
+      if (model.endpoint === "videos" && request.attachments.length > 1) throw new Error("OpenAI videos accepts only one input_reference image");
+      if (request.attachments.reduce((size, file) => size + file.bytes.byteLength, 0) > limits.maxRequestBytes) throw new RangeError("Provider request byte limit exceeded");
+      if (model.endpoint !== "chat" && request.system !== void 0) throw new TypeError("System prompts are supported only by chat models");
+      const reserved = model.endpoint === "chat" ? ["model", "messages", "stream"] : model.endpoint === "images" ? ["model", "prompt", "image", "image[]"] : ["model", "prompt", "input_reference"];
+      for (const key of Object.keys(request.options)) {
+        if (reserved.includes(key)) throw new Error(`OpenAI option ${key} is controlled by the provider`);
+      }
+      const send = (path, method, body) => openAiResponse(transport, {
+        url: `${baseUrl}${path}`,
+        method,
+        signal: request.signal,
+        ...body,
+        headers: [["authorization", `Bearer ${apiKey}`], ...body?.headers ?? []]
+      });
+      if (model.endpoint === "chat") {
+        const messages = [];
+        if (request.system !== void 0) messages.push({ role: "system", content: request.system });
+        messages.push({ role: "user", content: request.attachments.length === 0 ? request.prompt : [
+          { type: "text", text: request.prompt },
+          ...request.attachments.map((attachment) => ({ type: "image_url", image_url: { url: `data:${attachment.mimeType};base64,${base64(attachment.bytes)}` } }))
+        ] });
+        for await (const response of send("/chat/completions", "POST", jsonBody({ ...jsonOptions(request.options, "chat"), model: request.model, messages, stream: true }, limits.maxRequestBytes))) {
+          yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes);
+        }
+      } else if (model.endpoint === "images") {
+        const editing = request.attachments.length > 0;
+        const outputFormat = model.outputType.split(";", 1)[0].trim().toLowerCase().slice("image/".length);
+        if (request.options.output_format !== void 0 && request.options.output_format !== outputFormat) throw new TypeError("output_format conflicts with model outputType");
+        const values = { ...jsonOptions(request.options, "images"), output_format: outputFormat, model: request.model, prompt: request.prompt };
+        if (values.stream === true) throw new TypeError("Image event streaming is not supported by this reference provider");
+        const body = editing ? multipart({ ...values, ...request.options }, request.attachments.map((file) => ({ ...file, field: "image[]" })), limits.maxRequestBytes) : jsonBody(values, limits.maxRequestBytes);
+        for await (const response of send(editing ? "/images/edits" : "/images/generations", "POST", body)) {
+          const value = await openAiJson(response, request.signal, limits.maxResponseBytes);
+          if (value.error != null) throw new Error(`OpenAI: ${openAiError(value.error) ?? "image generation failed"}`);
+          if (!Array.isArray(value.data) || value.data.length === 0) throw new Error("OpenAI image response has no images");
+          for (const item of value.data) {
+            request.signal.throwIfAborted();
+            if (!openAiRecord(item)) throw new Error("OpenAI image response contains a malformed image");
+            yield imageBytes(item.b64_json);
+          }
+        }
+      } else {
+        let current;
+        for await (const response of send("/videos", "POST", multipart({ ...request.options, model: request.model, prompt: request.prompt }, request.attachments.map((file) => ({ ...file, field: "input_reference" })), limits.maxRequestBytes))) {
+          current = job(await openAiJson(response, request.signal, limits.maxResponseBytes));
+        }
+        if (!current) throw new Error("OpenAI video creation returned no job");
+        const path = `/videos/${encodeURIComponent(current.id)}`;
+        let polls = 0;
+        while (current.status !== "completed") {
+          if (polls++ >= limits.maxPolls) throw new RangeError("Provider video polling limit exceeded");
+          await waitForPoll(request.signal, limits.pollIntervalMs);
+          for await (const response of send(path, "GET")) current = job(await openAiJson(response, request.signal, limits.maxResponseBytes), current.id);
+        }
+        for await (const response of send(`${path}/content`, "GET")) {
+          const contentType = response.headers.find(([name]) => name.toLowerCase() === "content-type")?.[1].split(";")[0]?.trim().toLowerCase();
+          if (contentType && contentType !== "application/octet-stream" && !contentType.startsWith("video/")) {
+            throw new Error(`OpenAI video download has unexpected content type: ${contentType}`);
+          }
+          let received = false;
+          for await (const chunk of openAiBytes(response.body, request.signal, limits.maxResponseBytes)) {
+            if (chunk.byteLength === 0) continue;
+            received = true;
+            yield chunk;
+          }
+          if (!received) throw new Error("OpenAI video download is empty");
+        }
+      }
+    }
+  };
+}
+
+// packages/safe-bash/src/commands/llm/elevenlabs.ts
+init_platform();
+
+// packages/safe-bash/src/commands/llm/elevenlabs-stream.ts
+init_platform();
+async function abortable(operation, signal) {
+  signal.throwIfAborted();
+  let onAbort;
+  const aborted = new Promise((_resolve, reject) => {
+    onAbort = () => reject(signal.reason);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+  try {
+    return await Promise.race([Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return operation();
+    }), aborted]);
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+  }
+}
+async function* streamElevenLabs(transport, request, limit = 64 * 1024 * 1024) {
+  const { signal } = request;
+  signal.throwIfAborted();
+  let iterator;
+  let finished = false;
+  let failed = false;
+  let closed = false;
+  let size = 0;
+  const cleanups = /* @__PURE__ */ new Map();
+  const runCleanup = (entry) => {
+    return entry.pending ??= Promise.resolve().then(entry.run);
+  };
+  const register = (cleanup, receiver) => {
+    if (cleanups.has(cleanup)) return;
+    const entry = { run: () => cleanup.call(receiver) };
+    cleanups.set(cleanup, entry);
+    if (closed) void runCleanup(entry).catch(() => {
+    });
+  };
+  const dispose = async () => {
+    closed = true;
+    let seen = 0;
+    const failures = [];
+    while (seen < cleanups.size) {
+      const entries = [...cleanups.values()].slice(seen);
+      seen = cleanups.size;
+      const results = await Promise.allSettled(entries.map(runCleanup));
+      for (const result2 of results) if (result2.status === "rejected") failures.push(result2.reason);
+    }
+    if (failures.length) throw failures[0];
+  };
+  const close = async () => {
+    const failures = [];
+    try {
+      await dispose();
+    } catch (error) {
+      failures.push(error);
+    }
+    if (!finished && iterator?.return) {
+      const closing = Promise.resolve().then(() => iterator.return());
+      if (signal.aborted) void closing.catch(() => {
+      });
+      else {
+        try {
+          await closing;
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+    }
+    if (!failed) {
+      signal.throwIfAborted();
+      if (failures.length) throw failures[0];
+    }
+  };
+  const onAbort = () => {
+    void dispose().catch(() => {
+    });
+  };
+  signal.addEventListener("abort", onAbort, { once: true });
+  try {
+    const acquired = await abortable(async () => {
+      signal.throwIfAborted();
+      const response = await transport({ ...request, registerCleanup: register });
+      register(response.dispose, response);
+      if (signal.aborted) {
+        await dispose();
+        signal.throwIfAborted();
+      }
+      return response;
+    }, signal);
+    signal.throwIfAborted();
+    if (acquired.status < 200 || acquired.status >= 300) throw new Error(`ElevenLabs HTTP ${acquired.status}: ${acquired.statusText}`);
+    iterator = acquired.body[Symbol.asyncIterator]();
+    while (true) {
+      const next = await abortable(() => iterator.next(), signal);
+      signal.throwIfAborted();
+      if (next.done) {
+        finished = true;
+        return;
+      }
+      if (!(next.value instanceof Uint8Array)) throw new TypeError("ElevenLabs audio stream must yield Uint8Array chunks");
+      size += next.value.byteLength;
+      if (size > limit) throw new RangeError("Provider response byte limit exceeded");
+      yield Uint8Array.from(next.value);
+    }
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    signal.removeEventListener("abort", onAbort);
+    await close();
+  }
+}
+
+// packages/safe-bash/src/commands/llm/elevenlabs.ts
+var outputFormats = /* @__PURE__ */ new Map([
+  ["audio/mpeg", "mp3_44100_128"],
+  ["audio/wav", "wav_44100"],
+  ["audio/x-wav", "wav_44100"],
+  ["audio/pcm", "pcm_44100"],
+  ["audio/basic", "ulaw_8000"],
+  ["audio/opus", "opus_48000_128"],
+  ["audio/ogg", "opus_48000_128"]
+]);
+var optionTypes = {
+  tts: /* @__PURE__ */ new Map([
+    ["stability", "number"],
+    ["similarity_boost", "number"],
+    ["style", "number"],
+    ["speed", "number"],
+    ["use_speaker_boost", "boolean"]
+  ]),
+  music: /* @__PURE__ */ new Map([
+    ["music_length_ms", "integer"],
+    ["seed", "integer"],
+    ["force_instrumental", "boolean"],
+    ["respect_sections_durations", "boolean"],
+    ["store_for_inpainting", "boolean"],
+    ["sign_with_c2pa", "boolean"]
+  ])
+};
+function parseOptions(options, endpoint) {
+  return Object.fromEntries(Object.entries(options).map(([key, value]) => {
+    const type = optionTypes[endpoint].get(key);
+    if (!type) return [key, value];
+    if (type === "boolean") {
+      if (value === "true" || value === "false") return [key, value === "true"];
+    } else {
+      const number = value.trim() ? Number(value) : NaN;
+      if (Number.isFinite(number) && (type !== "integer" || Number.isSafeInteger(number))) return [key, number];
+    }
+    throw new Error(`Invalid ElevenLabs option ${key}: expected ${type}`);
+  }));
+}
+function createElevenLabsProvider(options) {
+  const transport = options.transport;
+  if (typeof transport !== "function") throw new TypeError("Provider transport is required");
+  const apiKey = credential(options.apiKey);
+  const limits = providerLimits(options.limits);
+  const baseUrl = new URL(options.baseUrl ?? "https://api.elevenlabs.io");
+  if (!["https:", "http:"].includes(baseUrl.protocol) || baseUrl.username || baseUrl.password || baseUrl.search || baseUrl.hash) {
+    throw new Error("Invalid ElevenLabs baseUrl: expected an HTTP(S) URL without credentials, query, or fragment");
+  }
+  if (!baseUrl.pathname.endsWith("/")) baseUrl.pathname += "/";
+  const models = options.models.map((model) => Object.freeze({
+    ...model,
+    ...model.aliases === void 0 ? {} : { aliases: Object.freeze([...model.aliases]) },
+    ...model.attachmentTypes === void 0 ? {} : { attachmentTypes: Object.freeze([...model.attachmentTypes]) }
+  }));
+  const byId = /* @__PURE__ */ new Map();
+  for (const model of models) {
+    if (model.endpoint !== "tts" && model.endpoint !== "music") throw new Error(`Invalid ElevenLabs endpoint: ${model.endpoint}`);
+    if (!model.outputType) throw new TypeError("ElevenLabs models require an audio outputType");
+    const mimeType = model.outputType.split(";", 1)[0].trim().toLowerCase();
+    const format = outputFormats.get(mimeType);
+    if (!format || !acceptsMimeType([mimeType], model.outputType) || model.endpoint === "music" && format.startsWith("wav_")) {
+      throw new Error(`Unsupported ElevenLabs outputType for ${model.endpoint}: ${model.outputType}`);
+    }
+    if (model.attachmentTypes?.length) throw new Error(`ElevenLabs model ${model.id} does not accept attachments`);
+    if (!model.id || byId.has(model.id)) throw new Error(`Duplicate or empty ElevenLabs model: ${model.id}`);
+    byId.set(model.id, { model, format });
+  }
+  return {
+    name: "elevenlabs",
+    models: Object.freeze(models),
+    async *complete(request) {
+      request.signal.throwIfAborted();
+      const entry = byId.get(request.model);
+      if (!entry) throw new Error(`Unknown model: ${request.model}`);
+      const { model, format } = entry;
+      if (request.attachments.length) throw new Error(`Model ${model.id} does not accept ${request.attachments[0].mimeType} attachments`);
+      if (request.system !== void 0) throw new TypeError("ElevenLabs reference endpoints do not accept system prompts");
+      const { output_format: requestedFormat, ...requestOptions } = request.options;
+      if (requestedFormat !== void 0 && requestedFormat !== format) throw new TypeError("output_format conflicts with model outputType");
+      let path;
+      let body;
+      if (model.endpoint === "tts") {
+        const { voice_id: suppliedVoice, ...settings } = requestOptions;
+        const voice = suppliedVoice ?? model.defaultVoiceId;
+        if (!voice?.trim()) throw new Error(`ElevenLabs model ${model.id} requires voice_id or a configured defaultVoiceId`);
+        if (voice === "." || voice === "..") throw new Error("Invalid ElevenLabs voice_id: dot segments are not allowed");
+        path = `v1/text-to-speech/${encodeURIComponent(voice)}`;
+        body = { text: request.prompt, model_id: model.id, voice_settings: parseOptions(settings, model.endpoint) };
+      } else {
+        path = "v1/music";
+        body = { ...parseOptions(requestOptions, model.endpoint), prompt: request.prompt, model_id: model.id };
+      }
+      const url = new URL(path, baseUrl);
+      url.searchParams.set("output_format", format);
+      const payload = jsonBody(body, limits.maxRequestBytes);
+      yield* streamElevenLabs(transport, {
+        url: url.href,
+        method: "POST",
+        headers: [["xi-api-key", apiKey], ...payload.headers, ["accept", model.outputType]],
+        body: payload.body,
+        signal: request.signal
+      }, limits.maxResponseBytes);
+    }
+  };
+}
+
+export {
+  classify,
+  sniffMimeType,
+  acceptsMimeType,
+  createOpenAiProvider,
+  createElevenLabsProvider
+};
+//# sourceMappingURL=chunk-LR32SJ3D.js.map