@poe-platform/safe-bash 0.1.788 → 0.1.790

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

@@ -0,0 +1,91 @@
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/providers/shared.js
+init_buffer();
+function providerLimits(input = {}) {
+  const limits = { maxRequestBytes: Infinity, maxResponseBytes: Infinity, maxEventBytes: Infinity, maxPolls: Infinity, pollIntervalMs: 1e3, ...input };
+  for (const [name, value] of Object.entries(limits)) {
+    if (name !== "pollIntervalMs" && value === Infinity)
+      continue;
+    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;
+  };
+  while (entries.some(([, value]) => value.includes(boundary)) || files.some((file) => contains(file.bytes, encoder.encode(boundary)))) {
+    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}`]] };
+}
+
+export {
+  providerLimits,
+  credential,
+  jsonBody,
+  multipart
+};

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

@@ -0,0 +1,90 @@
+import {
+  openAiBytes,
+  openAiError,
+  openAiRecord
+} from "./chunk-H4LWTITX.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/openai-sse.js
+init_buffer();
+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 = Infinity, responseLimit = Infinity) {
+  let usage;
+  const metadata = {};
+  for await (const data of events(source, signal, limit, responseLimit)) {
+    signal.throwIfAborted();
+    if (data.trim() === "[DONE]")
+      return { ...usage ? { usage } : {}, ...Object.keys(metadata).length ? { metadata } : {} };
+    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 (parsed.usage !== void 0 && parsed.usage !== null) {
+      if (!openAiRecord(parsed.usage))
+        throw new Error("OpenAI SSE event has invalid usage");
+      usage = parsed.usage;
+    }
+    for (const key of ["id", "model", "created", "system_fingerprint"]) {
+      if (parsed[key] !== void 0)
+        metadata[key] = parsed[key];
+    }
+    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;
+    }
+  }
+  throw new Error("OpenAI chat stream ended before [DONE]");
+}
+
+export {
+  openAiChat
+};

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

@@ -0,0 +1,314 @@
+import {
+  parseLlmNumericOption
+} from "./chunk-VMK4XVKO.js";
+import {
+  acceptsMimeType
+} from "./chunk-AKDMCNX4.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/service.js
+init_buffer();
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-llm/dist/model-options.js
+init_buffer();
+function validateModelOptions(model, values) {
+  if (model.options === void 0)
+    return { ...values };
+  const result = {};
+  for (const [name, input] of Object.entries(values)) {
+    const fail = (message) => {
+      throw new Error(`${name}
+  ${message}`);
+    };
+    const rule = Object.hasOwn(model.options, name) ? model.options[name] : void 0;
+    if (!rule)
+      return fail("Extra inputs are not permitted");
+    let value = input;
+    if (input === null && rule.nullable) {
+      result[name] = null;
+      continue;
+    }
+    switch (rule.type) {
+      case "number":
+      case "integer": {
+        const parsed = parseLlmNumericOption(input, rule.type);
+        if (parsed === void 0)
+          return fail(rule.type === "integer" ? "Input should be a valid integer, unable to parse string as an integer" : "Input should be a valid number, unable to parse string as a number");
+        value = parsed;
+        if (rule.type === "integer" && !Number.isSafeInteger(value))
+          fail("Input should be a valid integer");
+        if (rule.maximum !== void 0 && !(value <= rule.maximum))
+          fail(`Input should be less than or equal to ${rule.maximum}`);
+        if (rule.minimum !== void 0 && !(value >= rule.minimum))
+          fail(`Input should be greater than or equal to ${rule.minimum}`);
+        if (!Number.isFinite(value))
+          fail("Input should be a valid number, unable to parse string as a number");
+        break;
+      }
+      case "boolean": {
+        const text = String(input).toLowerCase();
+        if (["true", "1", "yes", "on", "y", "t"].includes(text))
+          value = true;
+        else if (["false", "0", "no", "off", "n", "f"].includes(text))
+          value = false;
+        else
+          fail("Input should be a valid boolean");
+        break;
+      }
+      case "string":
+        if (typeof input !== "string")
+          fail("Input should be a valid string");
+        break;
+    }
+    Object.defineProperty(result, name, { value, enumerable: true, configurable: true, writable: true });
+  }
+  return result;
+}
+
+// packages/safe-bash-command-llm/dist/service.js
+function abortable(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 textByteLength(text, signal, maxBytes) {
+  let size = 0, checkpoint = 0;
+  signal.throwIfAborted();
+  for (let index = 0; index < text.length; index++) {
+    if (index - checkpoint >= 65536) {
+      await yieldTurn(signal);
+      checkpoint = index;
+    }
+    const code = text.charCodeAt(index);
+    if (code < 128)
+      size++;
+    else if (code < 2048)
+      size += 2;
+    else if (code >= 55296 && code <= 56319 && index + 1 < text.length && text.charCodeAt(index + 1) >= 56320 && text.charCodeAt(index + 1) <= 57343) {
+      size += 4;
+      index++;
+    } else
+      size += 3;
+    if (size > maxBytes)
+      throw new RangeError("LLM output byte limit exceeded");
+  }
+  signal.throwIfAborted();
+  return size;
+}
+function validateMetadata(value) {
+  for (const field of [value.usage, value.metadata]) {
+    if (field !== void 0 && (!field || typeof field !== "object" || Array.isArray(field)))
+      throw new TypeError("Invalid LLM response metadata");
+  }
+}
+function validateOptions(options) {
+  for (const [key, value] of Object.entries(options)) {
+    if (!key || value !== null && !["string", "number", "boolean"].includes(typeof value) || typeof value === "number" && !Number.isFinite(value)) {
+      throw new TypeError(`Invalid model option ${key}: expected a finite scalar`);
+    }
+  }
+}
+async function* streamResult(completion, model, request) {
+  const limit = request.maxOutputBytes ?? Infinity;
+  if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0))
+    throw new RangeError("Invalid LLM output limit");
+  const iterator = completion()[Symbol.asyncIterator]();
+  let ended = false;
+  let size = 0;
+  try {
+    while (true) {
+      request.signal.throwIfAborted();
+      const result = await abortable(() => iterator.next(), request.signal);
+      request.signal.throwIfAborted();
+      if (result.done) {
+        ended = true;
+        const metadata = result.value;
+        if (metadata !== void 0 && (!metadata || typeof metadata !== "object" || Array.isArray(metadata)))
+          throw new TypeError("Invalid LLM response metadata");
+        const details = metadata;
+        if (details)
+          validateMetadata(details);
+        yield { type: "response", response: { model: model.id, ...details?.usage ? { usage: details.usage } : {}, ...details?.metadata ? { metadata: details.metadata } : {} } };
+        return;
+      }
+      const chunk = result.value;
+      const text = (model.outputType ?? "text/plain").toLowerCase().startsWith("text/");
+      if (text ? typeof chunk !== "string" : !(chunk instanceof Uint8Array))
+        throw new TypeError("Provider returned an incompatible LLM output chunk");
+      size += typeof chunk === "string" ? await textByteLength(chunk, request.signal, limit - size) : chunk.byteLength;
+      request.signal.throwIfAborted();
+      if (size > limit)
+        throw new RangeError("LLM output byte limit exceeded");
+      yield typeof chunk === "string" ? { type: "text", text: chunk } : { type: "bytes", data: new Uint8Array(chunk) };
+    }
+  } finally {
+    if (!ended) {
+      const closing = Promise.resolve().then(() => iterator.return?.());
+      if (request.signal.aborted)
+        void closing.catch(() => void 0);
+      else
+        await abortable(() => closing, request.signal);
+    }
+  }
+}
+function createLlmService(options) {
+  const models = [];
+  const lookup = /* @__PURE__ */ new Map();
+  const defaultModel = options.defaultModel;
+  for (const provider of options.providers) {
+    if (!provider.name || typeof provider.complete !== "function")
+      throw new TypeError("Providers require a name and complete function");
+    for (const declared of provider.models) {
+      if (!declared.id)
+        throw new TypeError("Models require a nonempty id");
+      const model = Object.freeze({
+        ...declared,
+        ...declared.options ? { options: Object.freeze(Object.fromEntries(Object.entries(declared.options).map(([name, rule]) => [name, Object.freeze({ ...rule })]))) } : {},
+        ...declared.capabilities ? { capabilities: Object.freeze([...declared.capabilities]) } : {},
+        ...declared.aliases ? { aliases: Object.freeze([...declared.aliases]) } : {},
+        ...declared.attachmentTypes ? { attachmentTypes: Object.freeze([...declared.attachmentTypes]) } : {}
+      });
+      const entry = Object.freeze({ provider, model });
+      for (const name of /* @__PURE__ */ new Set([model.id, `${provider.name}/${model.id}`, ...model.aliases ?? []])) {
+        if (!name)
+          throw new TypeError("Model aliases must not be empty");
+        if (lookup.has(name))
+          throw new Error(`Duplicate model id or alias: ${name}`);
+        lookup.set(name, entry);
+      }
+      models.push(entry);
+    }
+  }
+  return Object.freeze({
+    version: 1,
+    models: Object.freeze(models),
+    resolve(model) {
+      const selected = model ?? defaultModel;
+      if (selected === void 0)
+        throw new Error("No model selected; use --model or configure defaultModel");
+      const entry = lookup.get(selected);
+      if (!entry)
+        throw new Error(`Unknown model: ${selected}`);
+      return entry;
+    },
+    complete(request) {
+      request.signal.throwIfAborted();
+      validateOptions(request.options);
+      if (typeof request.prompt !== "string" || request.system !== void 0 && typeof request.system !== "string")
+        throw new TypeError("Invalid LLM prompt");
+      const entry = this.resolve(request.model);
+      if (request.messages?.length && !entry.model.capabilities?.includes("messages"))
+        throw new Error(`Model ${entry.model.id} does not support messages`);
+      if (request.messages?.some((message) => !["system", "user", "assistant"].includes(message.role) || typeof message.content !== "string"))
+        throw new TypeError("Invalid LLM message");
+      if (request.schema !== void 0) {
+        if (!entry.model.capabilities?.includes("schema"))
+          throw new Error(`Model ${entry.model.id} does not support schema`);
+        if (!request.schema || typeof request.schema !== "object" || Array.isArray(request.schema))
+          throw new TypeError("Invalid LLM schema");
+      }
+      for (const attachment of request.attachments) {
+        if (!acceptsMimeType(entry.model.attachmentTypes ?? [], attachment.mimeType)) {
+          throw new Error(`Model ${entry.model.id} does not accept ${attachment.mimeType}`);
+        }
+      }
+      const { maxOutputBytes: ignoredMaxOutputBytes, ...input } = request;
+      return entry.provider.complete({ ...input, model: entry.model.id, options: validateModelOptions(entry.model, request.options) });
+    },
+    async *stream(request) {
+      const entry = this.resolve(request.model);
+      yield* streamResult(() => this.complete(request), entry.model, request);
+    },
+    async *streamSources(request) {
+      const sources = /* @__PURE__ */ new Set([request.prompt, ...request.system === void 0 ? [] : [request.system], ...request.messages?.map((message) => message.content) ?? [], ...request.attachments.map((attachment) => attachment.source)]);
+      let closing, failed = false;
+      const close = () => closing ??= Promise.allSettled([...sources].map((source) => Promise.resolve().then(() => source.dispose()))).then((results) => {
+        const rejected = results.find((result) => result.status === "rejected");
+        if (rejected?.status === "rejected")
+          throw rejected.reason;
+      });
+      const abort = () => {
+        void close().catch(() => void 0);
+      };
+      request.signal.addEventListener("abort", abort, { once: true });
+      try {
+        request.signal.throwIfAborted();
+        validateOptions(request.options);
+        const entry = this.resolve(request.model);
+        if (!entry.provider.completeSources || entry.model.inputSources === false)
+          throw new Error(`Model ${entry.model.id} does not support streamed inputs`);
+        for (const source of sources)
+          if (!source || typeof source.dispose !== "function" || typeof source.bytes?.[Symbol.asyncIterator] !== "function")
+            throw new TypeError("Invalid LLM input source");
+        if (request.messages?.length && !entry.model.capabilities?.includes("messages"))
+          throw new Error(`Model ${entry.model.id} does not support messages`);
+        if (request.messages?.some((message) => !["system", "user", "assistant"].includes(message.role)))
+          throw new TypeError("Invalid LLM message");
+        if (request.schema !== void 0) {
+          if (!entry.model.capabilities?.includes("schema"))
+            throw new Error(`Model ${entry.model.id} does not support schema`);
+          if (!request.schema || typeof request.schema !== "object" || Array.isArray(request.schema))
+            throw new TypeError("Invalid LLM schema");
+        }
+        for (const attachment of request.attachments)
+          if (!acceptsMimeType(entry.model.attachmentTypes ?? [], attachment.mimeType))
+            throw new Error(`Model ${entry.model.id} does not accept ${attachment.mimeType}`);
+        const { maxOutputBytes: ignoredMaxOutputBytes, ...input } = request;
+        yield* streamResult(() => entry.provider.completeSources({ ...input, model: entry.model.id, options: validateModelOptions(entry.model, request.options) }), entry.model, request);
+      } catch (error) {
+        failed = true;
+        throw request.signal.aborted ? request.signal.reason : error;
+      } finally {
+        request.signal.removeEventListener("abort", abort);
+        await close().catch((error) => {
+          if (!failed)
+            throw error;
+        });
+      }
+    },
+    async embed(request) {
+      request.signal.throwIfAborted();
+      validateOptions(request.options);
+      if (!Array.isArray(request.inputs) || Array.from(request.inputs).some((input) => typeof input !== "string"))
+        throw new TypeError("Embedding inputs must be strings");
+      const entry = this.resolve(request.model);
+      if (!entry.model.capabilities?.includes("embed") || !entry.provider.embed)
+        throw new Error(`Model ${entry.model.id} does not support embeddings`);
+      const embed = entry.provider.embed.bind(entry.provider);
+      const result = await abortable(() => embed({ ...request, model: entry.model.id, options: validateModelOptions(entry.model, request.options) }), request.signal);
+      request.signal.throwIfAborted();
+      if (result.model !== entry.model.id || !Array.isArray(result.vectors) || result.vectors.length !== request.inputs.length || Array.from(result.vectors).some((vector) => !Array.isArray(vector) || !vector.length || Array.from(vector).some((value) => typeof value !== "number" || !Number.isFinite(value)) || vector.length !== result.vectors[0]?.length))
+        throw new TypeError("Invalid embedding response");
+      validateMetadata(result);
+      return result;
+    }
+  });
+}
+
+export {
+  validateModelOptions,
+  createLlmService
+};