@poe-platform/safe-bash 0.1.806 → 0.1.807

package/dist/safe-bash-command-llm/collections.js

@@ -0,0 +1,423 @@
+import {
+  createLlmSpool
+} from "../safe-bash/command-chunks/chunk-V3RGA5PS.js";
+import {
+  jsonValue,
+  sourceBytes
+} from "../safe-bash/command-chunks/chunk-PXL4NBYP.js";
+import "../safe-bash/command-chunks/chunk-65DS4IOB.js";
+
+// packages/safe-bash-command-llm/src/collections.ts
+import { FsError as FsError2 } from "../safe-bash-contracts/index.js";
+import { transactSqlite, withSqliteStatement as withSqliteStatement3 } from "../safe-bash-sqlite-engine/storage.js";
+
+// packages/safe-bash-command-llm/src/collections-migrations.ts
+import { md5 } from "../safe-bash-checksum-engine/md5.js";
+import { readSqliteRecord, sqliteRecord, withSqliteStatement } from "../safe-bash-sqlite-engine/storage.js";
+var empty = { async *[Symbol.asyncIterator]() {
+  yield new Uint8Array();
+} };
+var blob = (size) => ({ type: "blob", size, bytes: empty });
+var bytesValue = (bytes) => ({ type: "blob", size: bytes.length, bytes: { async *[Symbol.asyncIterator]() {
+  yield bytes;
+} } });
+async function binding(value) {
+  if (value === null || typeof value !== "object") return value;
+  if (value.size > 65536) throw new RangeError("SQLite collection key exceeds scalar binding budget");
+  const bytes = new Uint8Array(value.size);
+  let offset = 0;
+  for await (const chunk of value.bytes) {
+    bytes.set(chunk, offset);
+    offset += chunk.length;
+  }
+  if (offset !== bytes.length) throw new Error("SQLite collection key length mismatch");
+  return value.type === "text" ? new TextDecoder("utf-8", { fatal: true }).decode(bytes) : bytes;
+}
+function placeholder(values, size) {
+  for (let pad = 0; pad <= 9; pad++) {
+    const base = [values[0], values[1], null, blob(pad), null, values[5], null];
+    const minimum = sqliteRecord([...base, blob(0)]).size;
+    for (let extra = 0; extra <= 9; extra++) {
+      const tail = size - minimum - extra;
+      if (tail >= 0 && sqliteRecord([...base, blob(tail)]).size === size) return { pad, tail };
+    }
+  }
+  throw new Error("Unable to represent SQLite migration placeholder");
+}
+async function migrateLlmCollections(session, signal, now, columns, schema2, migrations2) {
+  const applied = [];
+  await withSqliteStatement(session.module, { ...session, signal, sql: "SELECT name FROM _sqlite_migrations WHERE migration_set='llm.embeddings' ORDER BY name LIMIT 6" }, async (query) => {
+    for await (const [name] of query.rows([], ["text"])) applied.push(name);
+  });
+  const version = applied.length;
+  if (version < 1 || version > 4 || applied.some((name, index) => name !== migrations2[index])) throw new Error("Unrecognized embedding migration ledger");
+  const expected = ["collection_id", "id", "embedding", "content", ...version >= 4 ? ["content_hash"] : [], "metadata", ...version >= 3 ? ["updated"] : []];
+  if (columns.join(",") !== expected.join(",")) throw new Error("Embedding schema does not match its migration ledger");
+  let sourceRoot = 0;
+  await withSqliteStatement(session.module, { ...session, signal, sql: "SELECT rootpage FROM sqlite_schema WHERE name='embeddings' AND type='table'" }, async (query) => {
+    for await (const [root] of query.rows([], ["integer"])) sourceRoot = Number(root);
+  });
+  if (!sourceRoot) throw new Error("Missing embedding table root");
+  const updated = BigInt(Math.floor(now().getTime() / 1e3));
+  const seconds = now().getTime() / 1e3;
+  const nullHash = md5(new TextEncoder().encode(Number.isInteger(seconds) ? `${seconds}.0` : String(seconds)));
+  const mapRecord = async (source, rowid) => {
+    const record = await source.findRecord(sourceRoot, rowid, "at-or-after");
+    if (!record) return void 0;
+    const fields = await readSqliteRecord(record, { signal, maxColumns: 8 });
+    if (fields.length > columns.length) throw new Error("Unexpected embedding record width");
+    const values = Object.fromEntries(columns.map((name, index) => [name, fields[index] ?? null]));
+    let hash = values.content_hash ?? null;
+    if (version < 4) {
+      const digest = md5.create();
+      try {
+        if (values.content === null) {
+          hash = bytesValue(nullHash);
+        } else {
+          if (!values.content || typeof values.content !== "object" || values.content.type !== "text") throw new TypeError("Embedding content must be TEXT");
+          for await (const bytes of values.content.bytes) {
+            signal.throwIfAborted();
+            digest.update(bytes);
+          }
+        }
+        if (values.content !== null) hash = bytesValue(digest.digest());
+      } finally {
+        digest.destroy();
+      }
+    }
+    const target = [values.collection_id, values.id, values.embedding, values.content, null, hash, values.metadata, version < 3 ? updated : values.updated];
+    return { rowid: record.rowid, values: target, record: sqliteRecord(target) };
+  };
+  return async (editor) => editor.withSnapshot(async (source, target) => {
+    let targetRoot = 0;
+    await target.withSession(async (connection) => {
+      await connection.execute("BEGIN IMMEDIATE");
+      await connection.execute("CREATE TABLE llm_embedding_schema AS SELECT sql FROM sqlite_schema WHERE tbl_name='embeddings' AND sql IS NOT NULL AND type IN ('index','trigger')");
+      await connection.execute(schema2.replace('"embeddings"', '"llm_embeddings_migrating"'));
+      await withSqliteStatement(connection.module, { ...connection, signal, sql: "INSERT INTO llm_embeddings_migrating(rowid,collection_id,id,embedding,content,content_blob,content_hash,metadata,updated) VALUES(?,?,?,NULL,zeroblob(?),NULL,?,NULL,zeroblob(?))" }, async (query) => {
+        for (let next = -(1n << 63n); ; ) {
+          const row = await mapRecord(source, next);
+          if (!row) break;
+          const { pad, tail } = placeholder(row.values, row.record.size);
+          for await (const result of query.rows([row.rowid, await binding(row.values[0]), await binding(row.values[1]), pad, await binding(row.values[5]), tail], [])) void result;
+          if (row.rowid === (1n << 63n) - 1n) break;
+          next = row.rowid + 1n;
+        }
+      });
+      await withSqliteStatement(connection.module, { ...connection, signal, sql: "SELECT rootpage FROM sqlite_schema WHERE name='llm_embeddings_migrating'" }, async (query) => {
+        for await (const [root] of query.rows([], ["integer"])) targetRoot = Number(root);
+      });
+      await connection.execute("COMMIT");
+    });
+    await target.rewriteRecords({ async *[Symbol.asyncIterator]() {
+      for (let next = -(1n << 63n); ; ) {
+        const row = await mapRecord(source, next);
+        if (!row) break;
+        yield { rootPage: targetRoot, rowid: row.rowid, record: row.record };
+        if (row.rowid === (1n << 63n) - 1n) break;
+        next = row.rowid + 1n;
+      }
+    } });
+    await target.withSession(async (connection) => {
+      await connection.execute("BEGIN IMMEDIATE");
+      await connection.execute("DROP TABLE embeddings");
+      await connection.execute("ALTER TABLE llm_embeddings_migrating RENAME TO embeddings");
+      await withSqliteStatement(connection.module, { ...connection, signal, sql: "SELECT sql FROM llm_embedding_schema ORDER BY rowid" }, async (query) => {
+        for await (const [sql] of query.rows([], ["text"])) await connection.execute(sql);
+      });
+      if (version < 4) await connection.execute("CREATE INDEX idx_embeddings_content_hash ON embeddings(content_hash)");
+      await connection.execute("DROP TABLE llm_embedding_schema");
+      await withSqliteStatement(connection.module, { ...connection, signal, sql: "INSERT INTO _sqlite_migrations(migration_set,name,applied_at) VALUES (?,?,?)" }, async (query) => {
+        for (const name of migrations2.slice(version)) {
+          const timestamp = now().toISOString().replace("T", " ").replace("Z", "000+00:00");
+          for await (const row of query.rows(["llm.embeddings", name, timestamp], [])) void row;
+        }
+      });
+      await connection.execute("COMMIT");
+    });
+  });
+}
+
+// packages/safe-bash-command-llm/src/collections-embed.ts
+import { FsError } from "../safe-bash-contracts/index.js";
+import { md5 as md52 } from "../safe-bash-checksum-engine/md5.js";
+import { sqliteRecord as sqliteRecord2, withSqliteStatement as withSqliteStatement2 } from "../safe-bash-sqlite-engine/storage.js";
+var blob2 = (size, bytes) => ({ type: "blob", size, bytes });
+var empty2 = { async *[Symbol.asyncIterator]() {
+} };
+var scalar = (bytes) => blob2(bytes.length, { async *[Symbol.asyncIterator]() {
+  yield bytes;
+} });
+async function embedCollection(editor, options) {
+  const { signal, input, collection, id } = options;
+  let spool;
+  let metadataSpool;
+  let failed = false;
+  const digest = md52.create();
+  try {
+    if (typeof id !== "string") throw new TypeError("Embedding ID must be a string");
+    if (!Number.isSafeInteger(options.maxInputBytes) || options.maxInputBytes < 0) throw new RangeError("Invalid embedding input byte limit");
+    spool = await createLlmSpool(options.fs, options.directory, signal, "input");
+    const decoder = options.binary ? void 0 : new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    let size = 0;
+    for await (const bytes of sourceBytes(input.bytes, signal)) {
+      if (bytes.length > options.maxInputBytes - size) throw new RangeError("Embedding input byte limit exceeded");
+      size += bytes.length;
+      for (let offset = 0; offset < bytes.length; offset += 16384) {
+        const part = bytes.subarray(offset, offset + 16384);
+        decoder?.decode(part, { stream: true });
+        digest.update(part);
+        await spool.write(part);
+      }
+    }
+    decoder?.decode();
+    const hash = digest.digest();
+    const duplicate = await editor.withSession((session) => withSqliteStatement2(session.module, { ...session, signal, sql: "SELECT 1 FROM embeddings WHERE collection_id=? AND content_hash=? LIMIT 1" }, async (query) => {
+      for await (const row of query.rows([collection.id, hash], ["integer"])) {
+        void row;
+        return true;
+      }
+      return false;
+    }));
+    if (duplicate) return;
+    let metadata = null;
+    if (options.metadata && Object.keys(options.metadata).length) {
+      metadataSpool = await createLlmSpool(options.fs, options.directory, signal, "input");
+      let metadataSize = 0;
+      for await (const bytes of jsonValue(options.metadata, signal)) {
+        if (bytes.length > options.maxInputBytes - size - metadataSize) throw new RangeError("Embedding input byte limit exceeded");
+        metadataSize += bytes.length;
+        await metadataSpool.write(bytes);
+      }
+      const retainedMetadata = metadataSpool;
+      metadata = { type: "text", size: metadataSize, bytes: { [Symbol.asyncIterator]: () => retainedMetadata.replay()[Symbol.asyncIterator]() } };
+    }
+    if (!options.service.embedSources) throw new Error("LLM service does not support streamed embeddings");
+    const retained = spool;
+    let borrowed = true;
+    const source = { bytes: { async *[Symbol.asyncIterator]() {
+      if (!borrowed) throw new FsError("EBADF", { message: "Embedding source lease is closed" });
+      for await (const bytes of retained.replay()) {
+        if (!borrowed) throw new FsError("EBADF", { message: "Embedding source lease is closed" });
+        yield bytes;
+      }
+    } }, async dispose() {
+      borrowed = false;
+    } };
+    const response = await options.service.embedSources({ model: collection.model, inputs: [source], options: {}, signal, ...options.binary === void 0 ? {} : { binary: options.binary } }).finally(() => {
+      borrowed = false;
+    });
+    const vector = response.vectors[0];
+    if (response.vectors.length !== 1 || !vector || !vector.length || vector.some((value) => !Number.isFinite(value))) throw new TypeError("Invalid embedding vector");
+    const encoded = { async *[Symbol.asyncIterator]() {
+      for (let offset = 0; offset < vector.length; offset += 4096) {
+        signal.throwIfAborted();
+        const bytes = new Uint8Array(Math.min(4096, vector.length - offset) * 4), view = new DataView(bytes.buffer);
+        for (let index = 0; index < bytes.length / 4; index++) view.setFloat32(index * 4, vector[offset + index], true);
+        yield bytes;
+      }
+    } };
+    const content = options.store ? { type: options.binary ? "blob" : "text", size, bytes: { [Symbol.asyncIterator]: () => retained.replay()[Symbol.asyncIterator]() } } : null;
+    const idBytes = new TextEncoder().encode(id);
+    const idValue = { type: "text", size: idBytes.length, bytes: { async *[Symbol.asyncIterator]() {
+      yield idBytes;
+    } } };
+    const values = [collection.id, idValue, blob2(vector.length * 4, encoded), options.binary ? null : content, options.binary ? content : null, scalar(hash), metadata, BigInt(Math.floor(options.now().getTime() / 1e3))];
+    const record = sqliteRecord2(values);
+    let pad = -1, tail = -1;
+    for (let prefix = 0; prefix <= 9 && pad < 0; prefix++) {
+      const base = [collection.id, idValue, null, blob2(prefix, empty2), null, scalar(hash), null];
+      const minimum = sqliteRecord2([...base, blob2(0, empty2)]).size;
+      for (let extra = 0; extra <= 9; extra++) {
+        const count = record.size - minimum - extra;
+        if (count >= 0 && sqliteRecord2([...base, blob2(count, empty2)]).size === record.size) {
+          pad = prefix;
+          tail = count;
+          break;
+        }
+      }
+    }
+    if (pad < 0) throw new Error("Unable to represent embedding placeholder");
+    let rootPage = 0, rowid = 0n;
+    await editor.withSession(async (session) => {
+      await withSqliteStatement2(session.module, { ...session, signal, sql: "SELECT name FROM sqlite_schema WHERE tbl_name='embeddings' AND (type='trigger' OR (type='index' AND name NOT IN ('sqlite_autoindex_embeddings_1','idx_embeddings_content_hash'))) LIMIT 1" }, async (query) => {
+        for await (const [name] of query.rows([], ["text"])) throw new Error(`Unsupported embedding schema extension: ${String(name)}`);
+      });
+      await withSqliteStatement2(session.module, { ...session, signal, sql: "INSERT OR REPLACE INTO embeddings(collection_id,id,embedding,content,content_blob,content_hash,metadata,updated) VALUES(?,?,NULL,zeroblob(?),NULL,?,NULL,zeroblob(?)) RETURNING rowid" }, async (query) => {
+        for await (const [value] of query.rows([collection.id, id, pad, hash, tail], ["integer"])) rowid = value;
+      });
+      await withSqliteStatement2(session.module, { ...session, signal, sql: "SELECT rootpage FROM sqlite_schema WHERE name='embeddings'" }, async (query) => {
+        for await (const [value] of query.rows([], ["integer"])) rootPage = Number(value);
+      });
+    });
+    await editor.rewriteRecord({ rootPage, rowid, record });
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    digest.destroy();
+    const errors = [];
+    for (const close of [() => input.dispose(), () => spool?.close(), () => metadataSpool?.close()]) try {
+      await close();
+    } catch (error) {
+      errors.push(error);
+    }
+    if (!failed && errors.length) await Promise.reject(errors.length === 1 ? errors[0] : new AggregateError(errors, "Embedding cleanup failed"));
+  }
+}
+
+// packages/safe-bash-command-llm/src/collections.ts
+var LlmCollectionDoesNotExist = class extends Error {
+  constructor(name) {
+    super(`Collection '${name}' does not exist`);
+    this.name = "LlmCollectionDoesNotExist";
+  }
+};
+var migrations = ["m001_create_tables", "m002_foreign_key", "m003_add_updated", "m004_store_content_hash", "m005_add_content_blob"];
+var schema = [
+  "CREATE TABLE [_sqlite_migrations] ([migration_set] TEXT,[name] TEXT,[applied_at] TEXT,PRIMARY KEY ([migration_set],[name]))",
+  "CREATE TABLE [collections] ([id] INTEGER PRIMARY KEY,[name] TEXT,[model] TEXT)",
+  "CREATE UNIQUE INDEX [idx_collections_name] ON [collections] ([name])",
+  'CREATE TABLE "embeddings" ([collection_id] INTEGER REFERENCES [collections]([id]),[id] TEXT,[embedding] BLOB,[content] TEXT,[content_blob] BLOB,[content_hash] BLOB,[metadata] TEXT,[updated] INTEGER,PRIMARY KEY ([collection_id],[id]))',
+  "CREATE INDEX [idx_embeddings_content_hash] ON [embeddings] ([content_hash])"
+];
+async function initialize(session, signal, now) {
+  const tables = [];
+  await withSqliteStatement3(session.module, { ...session, signal, sql: "SELECT name FROM sqlite_schema WHERE type='table' AND name IN ('collections','embeddings')" }, async (query) => {
+    for await (const [name] of query.rows([], ["text"])) tables.push(name);
+  });
+  if (!tables.length) {
+    await session.execute(schema[0].replace("CREATE TABLE", "CREATE TABLE IF NOT EXISTS"));
+    for (const statement of schema.slice(1)) await session.execute(statement);
+    const timestamp = now().toISOString().replace("T", " ").replace("Z", "000+00:00");
+    await withSqliteStatement3(session.module, { ...session, signal, sql: "INSERT INTO _sqlite_migrations(migration_set,name,applied_at) VALUES (?,?,?)" }, async (query) => {
+      for (const name of migrations) for await (const row of query.rows(["llm.embeddings", name, timestamp], [])) void row;
+    });
+  } else {
+    const columns = [];
+    await withSqliteStatement3(session.module, { ...session, signal, sql: "SELECT name FROM pragma_table_info('embeddings') ORDER BY cid" }, async (query) => {
+      for await (const [name] of query.rows([], ["text"])) columns.push(name);
+    });
+    if (tables.length !== 2) throw new Error("Incomplete embedding database schema");
+    if (columns.join(",") !== "collection_id,id,embedding,content,content_blob,content_hash,metadata,updated") return migrateLlmCollections(session, signal, now, columns, schema[3], migrations);
+  }
+  return void 0;
+}
+async function withLlmCollections(options, operation) {
+  const { signal } = options;
+  const execute = async (editor) => {
+    let active = true, pending, failed = false, failure;
+    const run = (action) => {
+      if (!active) return Promise.reject(new FsError2("EBADF", { message: "Collection catalog is closed" }));
+      if (pending) {
+        failed = true;
+        failure = new FsError2("EBUSY", { message: "Collection operations must be serialized" });
+        return Promise.reject(failure);
+      }
+      if (failed) return Promise.reject(failure);
+      const task = Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return action();
+      });
+      pending = task;
+      void task.then(() => {
+        pending = void 0;
+      }, (error) => {
+        pending = void 0;
+        failed = true;
+        failure = error;
+      });
+      return task;
+    };
+    const native = (action) => run(async () => {
+      const result = await editor.withSession(async (session) => {
+        try {
+          return { ok: true, value: await action(session) };
+        } catch (error) {
+          return { ok: false, error };
+        }
+      });
+      if (!result.ok) throw result.error;
+      return result.value;
+    });
+    const lookup = async (session, name) => {
+      if (typeof name !== "string") throw new TypeError("Collection name must be a string");
+      return withSqliteStatement3(session.module, { ...session, signal, sql: "SELECT id,name,model FROM collections WHERE name=?" }, async (query) => {
+        for await (const [id, storedName, model] of query.rows([name], ["integer", "text", "text"])) return { id, name: storedName, model };
+        return void 0;
+      });
+    };
+    const catalog = {
+      collection(name, settings = {}) {
+        return native(async (session) => {
+          const existing = await lookup(session, name);
+          if (existing) return existing;
+          if (settings.create === false) throw new LlmCollectionDoesNotExist(name);
+          if (settings.model === void 0) throw new Error("Either model= or model_id= must be provided when creating a new collection");
+          if (typeof settings.model !== "string") throw new TypeError("Collection model must be a string");
+          return withSqliteStatement3(session.module, { ...session, signal, sql: "INSERT INTO collections(name,model) VALUES (?,?) RETURNING id" }, async (query) => {
+            for await (const [id] of query.rows([name, settings.model], ["integer"])) return { id, name, model: settings.model };
+            throw new Error("Collection insertion returned no ID");
+          });
+        });
+      },
+      list(visit) {
+        return native(async (session) => {
+          await withSqliteStatement3(session.module, { ...session, signal, sql: "SELECT id,name,model,(SELECT count(*) FROM embeddings WHERE collection_id=collections.id) FROM collections ORDER BY id" }, async (query) => {
+            for await (const [id, name, model, count] of query.rows([], ["integer", "text", "text", "integer"])) await visit({ id, name, model, count });
+          });
+        });
+      },
+      delete(name) {
+        return native(async (session) => {
+          const existing = await lookup(session, name);
+          if (!existing) throw new LlmCollectionDoesNotExist(name);
+          for (const sql of ["DELETE FROM embeddings WHERE collection_id=?", "DELETE FROM collections WHERE id=?"]) await withSqliteStatement3(session.module, { ...session, signal, sql }, async (query) => {
+            for await (const row of query.rows([existing.id], [])) void row;
+          });
+        });
+      },
+      embed(name, id, settings) {
+        let transferred = false;
+        return run(async () => {
+          const collection = await editor.withSession((session) => lookup(session, name));
+          if (!collection) throw new LlmCollectionDoesNotExist(name);
+          transferred = true;
+          await embedCollection(editor, { ...options, ...settings, collection, id });
+        }).catch(async (error) => {
+          if (!transferred) await settings.input.dispose().catch(() => void 0);
+          throw error;
+        });
+      }
+    };
+    let value2;
+    const errors = [];
+    try {
+      value2 = await operation(catalog);
+    } catch (error) {
+      errors.push(error);
+    }
+    active = false;
+    if (pending) try {
+      await pending;
+    } catch (error) {
+      if (!errors.includes(error)) errors.push(error);
+    }
+    if (failed && !errors.includes(failure)) errors.push(failure);
+    if (errors.length === 1) throw errors[0];
+    if (errors.length) throw new AggregateError(errors, "Collection callback and admitted operation failed");
+    return value2;
+  };
+  let migration, value;
+  const receipt = await transactSqlite({ ...options, async finalize(editor) {
+    if (migration) await migration(editor);
+    value = await execute(editor);
+  } }, async (session) => {
+    migration = await initialize(session, signal, options.now);
+  });
+  return { ...receipt, value };
+}
+export {
+  LlmCollectionDoesNotExist,
+  withLlmCollections
+};

package/dist/safe-bash-command-llm/command.js

@@ -3,9 +3,11 @@ import {
   createLlmCommands,
   llmCommands,
   llmReferenceVersion
-} from "../safe-bash/command-chunks/chunk-HFUL6E5I.js";
-import "../safe-bash/command-chunks/chunk-BNG4ZMZ3.js";
+} from "../safe-bash/command-chunks/chunk-A7CE4EIU.js";
+import "../safe-bash/command-chunks/chunk-V3RGA5PS.js";
 import "../safe-bash/command-chunks/chunk-ZH5K2H4E.js";
+import "../safe-bash/command-chunks/chunk-HJDE7ZNV.js";
+import "../safe-bash/command-chunks/chunk-PXL4NBYP.js";
 import "../safe-bash/command-chunks/chunk-OTEHQQU7.js";
 import "../safe-bash/command-chunks/chunk-VMA3NJXU.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/safe-bash-command-llm/index.js

@@ -11,15 +11,15 @@ import {
   createOpenAiProvider,
   jsonString,
   openAiChatOptions
-} from "../safe-bash/command-chunks/chunk-MR2RLUPV.js";
+} from "../safe-bash/command-chunks/chunk-RQHQCJMV.js";
 import "../safe-bash/command-chunks/chunk-WKUV62RJ.js";
+import "../safe-bash/command-chunks/chunk-UN2RIRCD.js";
 import "../safe-bash/command-chunks/chunk-4SISSPIH.js";
 import {
   createLlmCommand,
   createLlmCommands,
   createLlmConfiguration,
   createLlmInputBudget,
-  createLlmSpool,
   createLlmTemplateStore,
   createLlmUrlSource,
   evaluateLlmTemplate,
@@ -33,17 +33,21 @@ import {
   selectLlmModelByQuery,
   serializeLlmTokenUsage,
   validateLlmTemplateParameters
-} from "../safe-bash/command-chunks/chunk-HFUL6E5I.js";
+} from "../safe-bash/command-chunks/chunk-A7CE4EIU.js";
 import {
-  base64Stream,
-  getLlmAttachmentUrlId,
-  jsonValue
-} from "../safe-bash/command-chunks/chunk-BNG4ZMZ3.js";
-import "../safe-bash/command-chunks/chunk-UN2RIRCD.js";
+  createLlmSpool
+} from "../safe-bash/command-chunks/chunk-V3RGA5PS.js";
 import {
   createLlmService,
   validateModelOptions
 } from "../safe-bash/command-chunks/chunk-ZH5K2H4E.js";
+import {
+  base64Stream,
+  getLlmAttachmentUrlId
+} from "../safe-bash/command-chunks/chunk-HJDE7ZNV.js";
+import {
+  jsonValue
+} from "../safe-bash/command-chunks/chunk-PXL4NBYP.js";
 import {
   resolveUrlAttachment
 } from "../safe-bash/command-chunks/chunk-OTEHQQU7.js";

package/dist/safe-bash-command-llm/openai.js

@@ -1,11 +1,12 @@
 import {
   chatJson,
   createOpenAiProvider
-} from "../safe-bash/command-chunks/chunk-MR2RLUPV.js";
+} from "../safe-bash/command-chunks/chunk-RQHQCJMV.js";
 import "../safe-bash/command-chunks/chunk-WKUV62RJ.js";
-import "../safe-bash/command-chunks/chunk-4SISSPIH.js";
-import "../safe-bash/command-chunks/chunk-BNG4ZMZ3.js";
 import "../safe-bash/command-chunks/chunk-UN2RIRCD.js";
+import "../safe-bash/command-chunks/chunk-4SISSPIH.js";
+import "../safe-bash/command-chunks/chunk-HJDE7ZNV.js";
+import "../safe-bash/command-chunks/chunk-PXL4NBYP.js";
 import "../safe-bash/command-chunks/chunk-OTEHQQU7.js";
 import "../safe-bash/command-chunks/chunk-VMA3NJXU.js";
 import "../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/safe-bash-command-llm/providers/index.js

@@ -10,14 +10,16 @@ import {
   createOpenAiProvider,
   jsonString,
   openAiChatOptions
-} from "../../safe-bash/command-chunks/chunk-MR2RLUPV.js";
+} from "../../safe-bash/command-chunks/chunk-RQHQCJMV.js";
 import "../../safe-bash/command-chunks/chunk-WKUV62RJ.js";
+import "../../safe-bash/command-chunks/chunk-UN2RIRCD.js";
 import "../../safe-bash/command-chunks/chunk-4SISSPIH.js";
 import {
-  base64Stream,
+  base64Stream
+} from "../../safe-bash/command-chunks/chunk-HJDE7ZNV.js";
+import {
   jsonValue
-} from "../../safe-bash/command-chunks/chunk-BNG4ZMZ3.js";
-import "../../safe-bash/command-chunks/chunk-UN2RIRCD.js";
+} from "../../safe-bash/command-chunks/chunk-PXL4NBYP.js";
 import "../../safe-bash/command-chunks/chunk-OTEHQQU7.js";
 import "../../safe-bash/command-chunks/chunk-VMA3NJXU.js";
 import "../../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/safe-bash-command-llm/providers/openai.js

@@ -2,11 +2,12 @@ import "../../safe-bash/command-chunks/chunk-MUUY3FZC.js";
 import {
   chatJson,
   createOpenAiProvider
-} from "../../safe-bash/command-chunks/chunk-MR2RLUPV.js";
+} from "../../safe-bash/command-chunks/chunk-RQHQCJMV.js";
 import "../../safe-bash/command-chunks/chunk-WKUV62RJ.js";
-import "../../safe-bash/command-chunks/chunk-4SISSPIH.js";
-import "../../safe-bash/command-chunks/chunk-BNG4ZMZ3.js";
 import "../../safe-bash/command-chunks/chunk-UN2RIRCD.js";
+import "../../safe-bash/command-chunks/chunk-4SISSPIH.js";
+import "../../safe-bash/command-chunks/chunk-HJDE7ZNV.js";
+import "../../safe-bash/command-chunks/chunk-PXL4NBYP.js";
 import "../../safe-bash/command-chunks/chunk-OTEHQQU7.js";
 import "../../safe-bash/command-chunks/chunk-VMA3NJXU.js";
 import "../../safe-bash/command-chunks/chunk-65DS4IOB.js";

package/dist/safe-bash-command-node/commands/node/browser.js

@@ -2,20 +2,17 @@ import {
   createSafeJsNodeCommand,
   createSafeJsNodeCommands,
   safeJsNodeCommands
-} from "../../../safe-bash/command-chunks/chunk-W5OR7COJ.js";
-import "../../../safe-bash/command-chunks/chunk-5FMXQUDY.js";
-import "../../../safe-bash/command-chunks/chunk-GDAS4LY7.js";
-import "../../../safe-bash/command-chunks/chunk-CB3HTIDK.js";
-import "../../../safe-bash/command-chunks/chunk-P4OJBL2B.js";
-import "../../../safe-bash/command-chunks/chunk-N2A7V3WY.js";
-import "../../../safe-bash/command-chunks/chunk-XFHUSZBM.js";
-import "../../../safe-bash/command-chunks/chunk-YJ3TFZB2.js";
+} from "../../../safe-bash/command-chunks/chunk-PVLPWVRH.js";
+import "../../../safe-bash/command-chunks/chunk-XNJ67APB.js";
+import "../../../safe-bash/command-chunks/chunk-LRDME6WV.js";
+import "../../../safe-bash/command-chunks/chunk-2ANW3FXH.js";
+import "../../../safe-bash/command-chunks/chunk-SWUVHT7G.js";
+import "../../../safe-bash/command-chunks/chunk-UZOGSYJP.js";
+import "../../../safe-bash/command-chunks/chunk-OEKLEUUW.js";
+import "../../../safe-bash/command-chunks/chunk-457CU3IC.js";
+import "../../../safe-bash/command-chunks/chunk-JJK3CU7Z.js";
 import "../../../safe-bash/command-chunks/chunk-22JWEBPL.js";
 import "../../../safe-bash/command-chunks/chunk-D4K44JKA.js";
-import "../../../safe-bash/command-chunks/chunk-AITNVBXO.js";
-import "../../../safe-bash/command-chunks/chunk-G3YO3JIN.js";
-import "../../../safe-bash/command-chunks/chunk-B5F2KQYA.js";
-import "../../../safe-bash/command-chunks/chunk-MRFW2E6B.js";
 import "../../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   createSafeJsNodeCommand as createNodeCommand,

package/dist/safe-bash-command-node/commands/node/buffer.js

@@ -1,8 +1,8 @@
 import {
   bufferBindings,
   bufferSource
-} from "../../../safe-bash/command-chunks/chunk-B5F2KQYA.js";
-import "../../../safe-bash/command-chunks/chunk-MRFW2E6B.js";
+} from "../../../safe-bash/command-chunks/chunk-SWUVHT7G.js";
+import "../../../safe-bash/command-chunks/chunk-457CU3IC.js";
 import "../../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   bufferBindings,

package/dist/safe-bash-command-node/commands/node/default-runtime.js

@@ -1,19 +1,16 @@
 import {
   defaultNodeCommand
-} from "../../../safe-bash/command-chunks/chunk-W5OR7COJ.js";
-import "../../../safe-bash/command-chunks/chunk-5FMXQUDY.js";
-import "../../../safe-bash/command-chunks/chunk-GDAS4LY7.js";
-import "../../../safe-bash/command-chunks/chunk-CB3HTIDK.js";
-import "../../../safe-bash/command-chunks/chunk-P4OJBL2B.js";
-import "../../../safe-bash/command-chunks/chunk-N2A7V3WY.js";
-import "../../../safe-bash/command-chunks/chunk-XFHUSZBM.js";
-import "../../../safe-bash/command-chunks/chunk-YJ3TFZB2.js";
+} from "../../../safe-bash/command-chunks/chunk-PVLPWVRH.js";
+import "../../../safe-bash/command-chunks/chunk-XNJ67APB.js";
+import "../../../safe-bash/command-chunks/chunk-LRDME6WV.js";
+import "../../../safe-bash/command-chunks/chunk-2ANW3FXH.js";
+import "../../../safe-bash/command-chunks/chunk-SWUVHT7G.js";
+import "../../../safe-bash/command-chunks/chunk-UZOGSYJP.js";
+import "../../../safe-bash/command-chunks/chunk-OEKLEUUW.js";
+import "../../../safe-bash/command-chunks/chunk-457CU3IC.js";
+import "../../../safe-bash/command-chunks/chunk-JJK3CU7Z.js";
 import "../../../safe-bash/command-chunks/chunk-22JWEBPL.js";
 import "../../../safe-bash/command-chunks/chunk-D4K44JKA.js";
-import "../../../safe-bash/command-chunks/chunk-AITNVBXO.js";
-import "../../../safe-bash/command-chunks/chunk-G3YO3JIN.js";
-import "../../../safe-bash/command-chunks/chunk-B5F2KQYA.js";
-import "../../../safe-bash/command-chunks/chunk-MRFW2E6B.js";
 import "../../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   defaultNodeCommand

package/dist/safe-bash-command-node/commands/node/filesystem.js

@@ -1,8 +1,8 @@
 import {
   nodeReadFile
-} from "../../../safe-bash/command-chunks/chunk-GDAS4LY7.js";
-import "../../../safe-bash/command-chunks/chunk-G3YO3JIN.js";
-import "../../../safe-bash/command-chunks/chunk-MRFW2E6B.js";
+} from "../../../safe-bash/command-chunks/chunk-OEKLEUUW.js";
+import "../../../safe-bash/command-chunks/chunk-457CU3IC.js";
+import "../../../safe-bash/command-chunks/chunk-JJK3CU7Z.js";
 import "../../../safe-bash/command-chunks/chunk-65DS4IOB.js";
 export {
   nodeReadFile