@poe-platform/safe-bash 0.1.789 → 0.1.790

package/dist/safe-bash/command-chunks/chunk-TB7IFMUZ.js

@@ -0,0 +1,802 @@
+import {
+  openAiChat
+} from "./chunk-SNK7K3XW.js";
+import {
+  credential,
+  jsonBody,
+  multipart,
+  providerLimits
+} from "./chunk-QTYZAWSB.js";
+import {
+  parseLlmNumericOption
+} from "./chunk-VMK4XVKO.js";
+import {
+  openAiBytes,
+  openAiError,
+  openAiJson,
+  openAiRecord,
+  openAiResponse
+} from "./chunk-H4LWTITX.js";
+import {
+  acceptsMimeType
+} from "./chunk-AKDMCNX4.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/openai.js
+init_buffer();
+
+// packages/safe-bash-command-llm/dist/openai-chat-options.js
+init_buffer();
+
+// packages/safe-bash-command-llm/dist/token-integer.js
+init_buffer();
+var decimalZeroes = [
+  48,
+  1632,
+  1776,
+  1984,
+  2406,
+  2534,
+  2662,
+  2790,
+  2918,
+  3046,
+  3174,
+  3302,
+  3430,
+  3558,
+  3664,
+  3792,
+  3872,
+  4160,
+  4240,
+  6112,
+  6160,
+  6470,
+  6608,
+  6784,
+  6800,
+  6992,
+  7088,
+  7232,
+  7248,
+  42528,
+  43216,
+  43264,
+  43472,
+  43504,
+  43600,
+  44016,
+  65296,
+  66720,
+  68912,
+  69734,
+  69872,
+  69942,
+  70096,
+  70384,
+  70736,
+  70864,
+  71248,
+  71360,
+  71472,
+  71904,
+  72016,
+  72784,
+  73040,
+  73120,
+  92768,
+  93008,
+  120782,
+  120792,
+  120802,
+  120812,
+  120822,
+  123200,
+  123632,
+  125264,
+  130032
+];
+function digit(code) {
+  if (code === void 0)
+    return void 0;
+  if (code >= 48 && code <= 57)
+    return code - 48;
+  for (const zero of decimalZeroes)
+    if (code >= zero && code < zero + 10)
+      return code - zero;
+  return void 0;
+}
+function whitespace(code) {
+  return code >= 9 && code <= 13 || code === 32 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+}
+function tokenInteger(input) {
+  let start = 0, end = input.length;
+  while (start < end && whitespace(input.charCodeAt(start)))
+    start++;
+  while (end > start && whitespace(input.charCodeAt(end - 1)))
+    end--;
+  let normalized = "", previousDigit = false, digits = 0;
+  if (input[start] === "+" || input[start] === "-")
+    normalized = input[start++];
+  for (let index = start; index < end; ) {
+    const code = input.codePointAt(index);
+    const value = digit(code);
+    if (value !== void 0) {
+      normalized += String(value);
+      digits++;
+      previousDigit = true;
+    } else if (code === 95 && previousDigit && digit(input.codePointAt(index + 1)) !== void 0)
+      previousDigit = false;
+    else
+      return void 0;
+    index += code > 65535 ? 2 : 1;
+  }
+  return digits ? BigInt(normalized).toString() : void 0;
+}
+
+// packages/safe-bash-command-llm/dist/openai-chat-options.js
+function biasInteger(value) {
+  if (typeof value === "boolean")
+    return Number(value);
+  if (typeof value === "number")
+    return Number.isFinite(value) ? Math.trunc(value) : void 0;
+  if (typeof value !== "string")
+    return void 0;
+  const integer = tokenInteger(value);
+  return integer === void 0 ? void 0 : Number(integer);
+}
+function dictionaryKeys(json) {
+  const keys = /* @__PURE__ */ new Set();
+  let depth = 0;
+  let expectingKey = false;
+  for (let index = 0; index < json.length; index++) {
+    const char = json[index];
+    if (char === '"') {
+      const start = index;
+      while (++index < json.length) {
+        if (json[index] === "\\")
+          index++;
+        else if (json[index] === '"')
+          break;
+      }
+      if (depth === 1 && expectingKey) {
+        keys.add(JSON.parse(json.slice(start, index + 1)));
+        expectingKey = false;
+      }
+    } else if (char === "{" || char === "[") {
+      depth++;
+      if (depth === 1)
+        expectingKey = true;
+    } else if (char === "}" || char === "]")
+      depth--;
+    else if (char === "," && depth === 1)
+      expectingKey = true;
+  }
+  return [...keys];
+}
+function logitBias(input) {
+  if (typeof input !== "string")
+    throw new TypeError("Invalid OpenAI logit_bias: expected a JSON dictionary");
+  let parsed;
+  try {
+    parsed = JSON.parse(input);
+  } catch {
+    throw new TypeError("Invalid OpenAI logit_bias: Invalid JSON in logit_bias string");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new TypeError("Invalid OpenAI logit_bias: expected a JSON dictionary");
+  const result = {};
+  for (const key of dictionaryKeys(input)) {
+    const value = parsed[key];
+    const token = tokenInteger(key);
+    const bias = biasInteger(value);
+    if (token === void 0 || bias === void 0 || !Number.isSafeInteger(bias) || bias < -100 || bias > 100)
+      throw new TypeError("Invalid OpenAI logit_bias: Invalid key-value pair in logit_bias dictionary");
+    Object.defineProperty(result, token, { value: bias, enumerable: true, configurable: true, writable: true });
+  }
+  return result;
+}
+function openAiChatOptions(options) {
+  const { json_object: jsonObject, logit_bias: bias, ...values } = options;
+  const result = { ...values };
+  if (bias !== void 0 && bias !== null)
+    result.logit_bias = logitBias(bias);
+  if (jsonObject !== void 0 && jsonObject !== null) {
+    const text = String(jsonObject).toLowerCase();
+    if (!["true", "false", "1", "0", "yes", "no", "on", "off", "y", "n", "t", "f"].includes(text))
+      throw new TypeError("Invalid OpenAI json_object: expected boolean");
+    if (["true", "1", "yes", "on", "y", "t"].includes(text)) {
+      if (Object.hasOwn(values, "response_format"))
+        throw new TypeError("OpenAI json_object conflicts with response_format");
+      result.response_format = { type: "json_object" };
+    }
+  }
+  return result;
+}
+
+// packages/safe-bash-command-llm/dist/chat-json.js
+init_buffer();
+
+// packages/safe-bash-command-llm/dist/json-string.js
+init_buffer();
+
+// packages/safe-bash-command-llm/dist/request-source.js
+init_buffer();
+function wait(start, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return start();
+    }).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* sourceBytes(source, signal) {
+  signal.throwIfAborted();
+  const iterator = source[Symbol.asyncIterator]();
+  let ended = false, failed = false;
+  try {
+    while (true) {
+      const next = await wait(() => iterator.next(), signal);
+      if (next.done) {
+        ended = true;
+        return;
+      }
+      if (!(next.value instanceof Uint8Array))
+        throw new TypeError("LLM input must yield byte chunks");
+      yield next.value;
+    }
+  } catch (error) {
+    failed = true;
+    throw signal.aborted ? signal.reason : error;
+  } finally {
+    if (!ended) {
+      const returned = Promise.resolve().then(() => iterator.return?.());
+      if (signal.aborted)
+        void returned.catch(() => void 0);
+      else
+        await wait(() => returned, signal).catch((error) => {
+          if (!failed)
+            throw error;
+        });
+    }
+  }
+}
+
+// packages/safe-bash-command-llm/dist/json-string.js
+async function* jsonString(source, signal) {
+  const encoder = new TextEncoder();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  signal.throwIfAborted();
+  yield encoder.encode('"');
+  for await (const input of sourceBytes(source, signal)) {
+    signal.throwIfAborted();
+    for (let position = 0; position < input.byteLength; position += 2048) {
+      signal.throwIfAborted();
+      const text = decoder.decode(input.subarray(position, position + 2048), { stream: true });
+      if (text)
+        yield encoder.encode(JSON.stringify(text).slice(1, -1));
+    }
+  }
+  signal.throwIfAborted();
+  const final = decoder.decode();
+  if (final)
+    yield encoder.encode(JSON.stringify(final).slice(1, -1));
+  yield encoder.encode('"');
+}
+
+// packages/safe-bash-command-llm/dist/base64-stream.js
+init_buffer();
+async function* base64Stream(source, signal) {
+  let remainder = new Uint8Array(0);
+  for await (const input of sourceBytes(source, signal)) {
+    signal.throwIfAborted();
+    for (let position = 0; position < input.length; position += 8190) {
+      signal.throwIfAborted();
+      const next = input.subarray(position, position + 8190);
+      const bytes = new Uint8Array(remainder.length + next.length);
+      bytes.set(remainder);
+      bytes.set(next, remainder.length);
+      const length = bytes.length - bytes.length % 3;
+      if (length)
+        yield btoa(String.fromCharCode(...bytes.subarray(0, length)));
+      remainder = bytes.slice(length);
+    }
+  }
+  signal.throwIfAborted();
+  if (remainder.length)
+    yield btoa(String.fromCharCode(...remainder));
+}
+
+// packages/safe-bash-command-llm/dist/json-value.js
+init_buffer();
+function jsonValue(value, signal) {
+  const ancestors = /* @__PURE__ */ new Set();
+  const normalize = (input, key) => {
+    if (input && (typeof input === "object" || typeof input === "function")) {
+      const hook = input.toJSON;
+      if (typeof hook === "function")
+        input = hook.call(input, key);
+      if (input instanceof Number || input instanceof String || input instanceof Boolean)
+        return input.valueOf();
+      if (input && typeof input === "object" && Object.getPrototypeOf(input) === BigInt.prototype)
+        return BigInt.prototype.valueOf.call(input);
+    }
+    return input;
+  };
+  function validate(input, key = "") {
+    input = normalize(input, key);
+    signal.throwIfAborted();
+    if (typeof input === "bigint")
+      throw new TypeError("Do not know how to serialize a BigInt");
+    if (!input || typeof input !== "object")
+      return;
+    if (ancestors.has(input))
+      throw new TypeError("Converting circular structure to JSON");
+    ancestors.add(input);
+    try {
+      if (Array.isArray(input)) {
+        for (let i = 0; i < input.length; i++)
+          validate(input[i], String(i));
+      } else
+        for (const key2 in input)
+          if (Object.hasOwn(input, key2))
+            validate(input[key2], key2);
+    } finally {
+      ancestors.delete(input);
+    }
+  }
+  validate(value);
+  const encoder = new TextEncoder();
+  const ignored = (input) => input === void 0 || typeof input === "function" || typeof input === "symbol";
+  async function* string(input) {
+    yield encoder.encode('"');
+    for (let offset = 0; offset < input.length; ) {
+      signal.throwIfAborted();
+      let end = Math.min(offset + 1024, input.length);
+      const last = input.charCodeAt(end - 1);
+      if (end < input.length && last >= 55296 && last <= 56319 && input.charCodeAt(end) >= 56320 && input.charCodeAt(end) <= 57343)
+        end--;
+      yield encoder.encode(JSON.stringify(input.slice(offset, end)).slice(1, -1));
+      offset = end;
+    }
+    yield encoder.encode('"');
+  }
+  async function* encode(input) {
+    signal.throwIfAborted();
+    if (typeof input === "string") {
+      yield* string(input);
+      return;
+    }
+    if (!input || typeof input !== "object") {
+      yield encoder.encode(JSON.stringify(input) ?? "null");
+      return;
+    }
+    if (Array.isArray(input)) {
+      yield encoder.encode("[");
+      for (let i = 0; i < input.length; i++) {
+        if (i)
+          yield encoder.encode(",");
+        yield* encode(normalize(input[i], String(i)));
+      }
+      yield encoder.encode("]");
+      return;
+    }
+    yield encoder.encode("{");
+    let first = true;
+    for (const key in input)
+      if (Object.hasOwn(input, key)) {
+        const item = normalize(input[key], key);
+        if (ignored(item))
+          continue;
+        if (!first)
+          yield encoder.encode(",");
+        first = false;
+        yield* string(key);
+        yield encoder.encode(":");
+        yield* encode(item);
+      }
+    yield encoder.encode("}");
+  }
+  return encode(normalize(value, ""));
+}
+
+// packages/safe-bash-command-llm/dist/chat-json.js
+function chatJson(request, limit) {
+  request.signal.throwIfAborted();
+  for (const field of ["model", "messages", "stream"])
+    if (Object.hasOwn(request.options, field))
+      throw new TypeError(`${field} is controlled by the provider`);
+  if (request.schema && Object.hasOwn(request.options, "response_format"))
+    throw new TypeError("schema conflicts with response_format");
+  for (const attachment of request.attachments)
+    if (!acceptsMimeType(["image/*"], attachment.mimeType))
+      throw new TypeError("Only image attachments are supported");
+  const controls = jsonValue({ ...request.options, ...request.schema ? { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } } : {}, model: request.model }, request.signal);
+  const encoder = new TextEncoder();
+  async function* body() {
+    const text = (value) => encoder.encode(value);
+    let pending;
+    for await (const chunk of controls) {
+      if (pending)
+        yield pending;
+      pending = chunk;
+    }
+    yield text(',"messages":[');
+    let first = true;
+    for (const message of [...request.system === void 0 ? [] : [{ role: "system", content: request.system }], ...request.messages ?? []]) {
+      request.signal.throwIfAborted();
+      yield text((first ? "" : ",") + '{"role":' + JSON.stringify(message.role) + ',"content":');
+      first = false;
+      yield* jsonString(message.content.bytes, request.signal);
+      yield text("}");
+    }
+    yield text((first ? "" : ",") + '{"role":"user","content":');
+    if (request.attachments.length)
+      yield text('[{"type":"text","text":');
+    yield* jsonString(request.prompt.bytes, request.signal);
+    if (request.attachments.length) {
+      yield text("}");
+      for (const attachment of request.attachments) {
+        request.signal.throwIfAborted();
+        yield text(',{"type":"image_url","image_url":{"url":' + JSON.stringify(`data:${attachment.mimeType};base64,`).slice(0, -1));
+        for await (const part of base64Stream(attachment.source.bytes, request.signal))
+          yield text(part);
+        yield text('"}}');
+      }
+      yield text("]");
+    }
+    request.signal.throwIfAborted();
+    yield text('}],"stream":true}');
+  }
+  async function* limited() {
+    let size = 0;
+    for await (const chunk of body()) {
+      request.signal.throwIfAborted();
+      size += chunk.byteLength;
+      if (size > limit)
+        throw new RangeError("Provider request byte limit exceeded");
+      yield chunk;
+    }
+  }
+  return limited();
+}
+
+// packages/safe-bash-command-llm/dist/openai.js
+var numericOptions = {
+  chat: /* @__PURE__ */ new Map([
+    ["temperature", ["number", 0, 2]],
+    ["top_p", ["number", 0, 1]],
+    ["frequency_penalty", ["number", -2, 2]],
+    ["presence_penalty", ["number", -2, 2]],
+    ["max_tokens", ["integer", 1, Number.MAX_SAFE_INTEGER]],
+    ["max_completion_tokens", ["integer", 1, Number.MAX_SAFE_INTEGER]],
+    ["n", ["integer", 1, Number.MAX_SAFE_INTEGER]],
+    ["seed", ["integer", Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]],
+    ["top_logprobs", ["integer", 0, 20]]
+  ]),
+  images: /* @__PURE__ */ new Map([
+    ["n", ["integer", 1, 10]],
+    ["output_compression", ["integer", 0, 100]],
+    ["partial_images", ["integer", 0, 3]]
+  ])
+};
+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" && typeof value !== "boolean")
+        throw new Error(`Invalid OpenAI option ${key}: expected boolean`);
+      return [key, value === true || value === "true"];
+    }
+    const numeric = numericOptions[endpoint].get(key);
+    if (!numeric)
+      return [key, value];
+    const [type, minimum, maximum] = numeric;
+    const number = parseLlmNumericOption(value, type);
+    if (number === void 0 || !Number.isFinite(number) || type === "integer" && !Number.isSafeInteger(number)) {
+      throw new Error(`Invalid OpenAI option ${key}: expected a finite ${type === "integer" ? "safe integer" : "number"}`);
+    }
+    if (number < minimum || number > maximum)
+      throw new RangeError(`Invalid OpenAI option ${key}: expected ${minimum}..${maximum}`);
+    return [key, number];
+  }));
+}
+function base64(bytes) {
+  let binary = "";
+  for (let offset = 0; offset < bytes.length; offset += 8192) {
+    binary += String.fromCharCode(...bytes.subarray(offset, offset + 8192));
+  }
+  return btoa(binary);
+}
+function imageSize(value) {
+  if (typeof value !== "string" || value.length === 0)
+    throw new Error("OpenAI image response has no b64_json");
+  if (value.length % 4 !== 0)
+    throw new Error("OpenAI image response contains non-canonical base64");
+  return value.length / 4 * 3 - (value.endsWith("==") ? 2 : value.endsWith("=") ? 1 : 0);
+}
+function imageSlab(value) {
+  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 decoded;
+}
+function* imageBytes(value, signal) {
+  for (let offset = 0; offset < value.length; offset += 8192) {
+    signal.throwIfAborted();
+    const decoded = imageSlab(value.slice(offset, offset + 8192));
+    const bytes = new Uint8Array(decoded.length);
+    for (let index = 0; index < decoded.length; index++)
+      bytes[index] = decoded.charCodeAt(index);
+    yield bytes;
+  }
+}
+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,
+    inputSources: model.endpoint === "chat",
+    capabilities: Object.freeze(model.capabilities ?? (model.endpoint === "chat" ? ["messages"] : model.endpoint === "embeddings" ? ["embed"] : [])),
+    ...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", "embeddings"].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 embed(request) {
+      request.signal.throwIfAborted();
+      const model = byId.get(request.model);
+      if (!model || model.endpoint !== "embeddings")
+        throw new Error(`Model ${request.model} does not support embeddings`);
+      const values = {};
+      for (const [key, value] of Object.entries(request.options)) {
+        if (key === "dimensions") {
+          const number = parseLlmNumericOption(value, "integer");
+          if (number === void 0 || !Number.isSafeInteger(number) || number < 1)
+            throw new TypeError("Invalid OpenAI dimensions: expected a positive integer");
+          values[key] = number;
+        } else if (key === "user" && typeof value === "string")
+          values[key] = value;
+        else
+          throw new TypeError(`Unsupported OpenAI embedding option: ${key}`);
+      }
+      for await (const response of openAiResponse(transport, {
+        url: `${baseUrl}/embeddings`,
+        method: "POST",
+        signal: request.signal,
+        ...jsonBody({ ...values, model: request.model, input: request.inputs }, limits.maxRequestBytes),
+        headers: [["authorization", `Bearer ${apiKey}`], ["content-type", "application/json"]]
+      }, limits.maxResponseBytes)) {
+        const body = await openAiJson(response, request.signal, limits.maxResponseBytes);
+        if (!Array.isArray(body.data) || body.data.length !== request.inputs.length)
+          throw new TypeError("Invalid OpenAI embedding response");
+        const vectors = new Array(request.inputs.length);
+        for (const item of body.data) {
+          if (!openAiRecord(item) || !Number.isSafeInteger(item.index) || item.index < 0 || item.index >= vectors.length || vectors[item.index] !== void 0 || !Array.isArray(item.embedding) || !item.embedding.length || item.embedding.some((value) => typeof value !== "number" || !Number.isFinite(value)))
+            throw new TypeError("Invalid OpenAI embedding response");
+          vectors[item.index] = item.embedding;
+        }
+        if (vectors.some((vector) => vector.length !== vectors[0]?.length))
+          throw new TypeError("Invalid OpenAI embedding dimensions");
+        return { model: request.model, vectors, ...openAiRecord(body.usage) ? { usage: body.usage } : {} };
+      }
+      throw new Error("OpenAI returned no embedding response");
+    },
+    async *completeSources(request) {
+      request.signal.throwIfAborted();
+      const model = byId.get(request.model);
+      if (!model || model.endpoint !== "chat")
+        throw new Error(`Model ${request.model} does not support streamed inputs`);
+      const body = chatJson({ ...request, options: openAiChatOptions(jsonOptions(request.options, "chat")) }, limits.maxRequestBytes);
+      let details;
+      for await (const response of openAiResponse(transport, {
+        url: `${baseUrl}/chat/completions`,
+        method: "POST",
+        signal: request.signal,
+        headers: [["authorization", `Bearer ${apiKey}`], ["content-type", "application/json"]],
+        body
+      }, limits.maxResponseBytes)) {
+        details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes);
+      }
+      return details;
+    },
+    async *complete(request) {
+      request.signal.throwIfAborted();
+      const model = byId.get(request.model);
+      if (!model)
+        throw new Error(`Unknown model: ${request.model}`);
+      if (model.endpoint === "embeddings")
+        throw new TypeError("Embedding models require embed()");
+      if (model.endpoint !== "chat" && (request.messages?.length || request.schema !== void 0))
+        throw new TypeError("Messages and schemas require a chat 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");
+      if (request.schema !== void 0 && request.options.response_format !== void 0)
+        throw new TypeError("OpenAI option response_format conflicts with request schema");
+      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 ?? []]
+      }, limits.maxResponseBytes);
+      if (model.endpoint === "chat") {
+        const messages = [];
+        if (request.system !== void 0)
+          messages.push({ role: "system", content: request.system });
+        messages.push(...request.messages ?? []);
+        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)}` } }))
+        ] });
+        let details;
+        for await (const response of send("/chat/completions", "POST", jsonBody({ ...openAiChatOptions(jsonOptions(request.options, "chat")), ...request.schema === void 0 ? {} : { response_format: { type: "json_schema", json_schema: { name: "response", schema: request.schema } } }, model: request.model, messages, stream: true }, limits.maxRequestBytes))) {
+          details = yield* openAiChat(response.body, request.signal, limits.maxEventBytes, limits.maxResponseBytes);
+        }
+        return details;
+      } 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");
+          let size = 0;
+          const images = [];
+          for (const item of value.data) {
+            request.signal.throwIfAborted();
+            if (!openAiRecord(item))
+              throw new Error("OpenAI image response contains a malformed image");
+            size += imageSize(item.b64_json);
+            if (size > limits.maxResponseBytes)
+              throw new RangeError("Provider image byte limit exceeded");
+            images.push(item.b64_json);
+          }
+          for (const image of images) {
+            for (let offset = 0; offset < image.length; offset += 8192) {
+              request.signal.throwIfAborted();
+              const slab = image.slice(offset, offset + 8192);
+              if (offset + 8192 < image.length && slab.includes("="))
+                throw new Error("OpenAI image response contains non-canonical base64");
+              imageSlab(slab);
+            }
+          }
+          for (const image of images)
+            yield* imageBytes(image, request.signal);
+        }
+      } 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");
+        }
+      }
+    }
+  };
+}
+
+export {
+  createOpenAiProvider
+};