@poe-platform/safe-bash 0.1.788 → 0.1.790

package/dist/safe-bash/command-chunks/chunk-2C5BEBPY.js

@@ -0,0 +1,1388 @@
+import {
+  createLlmService,
+  validateModelOptions
+} from "./chunk-T5OLGM43.js";
+import {
+  acceptsMimeType,
+  sniffMimeType
+} from "./chunk-AKDMCNX4.js";
+import {
+  init_buffer
+} from "./chunk-HX3SHTCE.js";
+
+// packages/safe-bash-command-llm/dist/command.js
+init_buffer();
+import { createOutputOperation, getCommandArguments, FsError as FsError6 } from "../../safe-bash-contracts/index.js";
+import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+import { pathOf as pathOf2 } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-llm/dist/configuration.js
+init_buffer();
+import { FsError as FsError2, toByteSource as toByteSource2 } from "../../safe-bash-contracts/index.js";
+import { pathOf } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-llm/dist/configuration-publication.js
+init_buffer();
+import { retainFileSystemCleanup } from "@poe-platform/safe-fs/core";
+import { FsError, toByteSource } from "../../safe-bash-contracts/index.js";
+var stagingSerial = 0;
+async function publishConfiguration(fs, directory, path, bytes, parent, expected, signal) {
+  const capabilities = await fs.capabilitiesFor?.(path, { signal, create: expected === null }) ?? fs.capabilities;
+  if (capabilities.atomicFilePublication === true && fs.publishFileConditional) {
+    await fs.publishFileConditional(path, toByteSource(bytes), { parent, expected, mode: 384, signal, maxBytes: bytes.byteLength });
+    return;
+  }
+  if ((capabilities.atomicFileMutation === true || capabilities.trustedOwnedStaging === true) && fs.writeFileConditional) {
+    await fs.writeFileConditional(path, bytes, { parent, expected, mode: 384, signal });
+    return;
+  }
+  if (capabilities.atomicFileStaging !== true || !fs.createStagedFile || !fs.publishStagedFile || !fs.removeStagedFile) {
+    throw new FsError("ENOTSUP", { path, message: "LLM configuration requires atomic conditional publication" });
+  }
+  const ancestors = [];
+  let current = "/";
+  for (const component of ["", ...directory.split("/").filter(Boolean)]) {
+    if (component)
+      current = `${current === "/" ? "" : current}/${component}`;
+    const stat = await fs.lstat(current, { signal });
+    if (stat.type !== "directory")
+      throw new FsError("ENOTDIR", { path: current });
+    ancestors.push({ path: current, stat });
+  }
+  let staging;
+  const cleanup = retainFileSystemCleanup(fs, async (view) => {
+    if (staging)
+      await view.removeStagedFile(staging);
+  }, { maxOperations: 1 });
+  try {
+    for (let attempt = 0; attempt < 16; attempt++) {
+      try {
+        staging = await fs.createStagedFile(`${directory}/.llm-config-${++stagingSerial}`, "entry", { type: "file", data: bytes }, { parent, mode: 384, signal });
+        break;
+      } catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof FsError) || error.code !== "EEXIST")
+          throw error;
+      }
+    }
+    if (!staging)
+      throw new FsError("EEXIST", { path: directory, message: "LLM configuration staging names exhausted" });
+    await fs.publishStagedFile(staging, path, { parent, destination: expected, ancestors, signal });
+  } finally {
+    await cleanup();
+  }
+}
+
+// packages/safe-bash-command-llm/dist/configuration.js
+var maxConfigurationBytes = 1024 * 1024;
+var locks = /* @__PURE__ */ new WeakMap();
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function stringRecord(value) {
+  return record(value) && Object.values(value).every((item) => typeof item === "string");
+}
+function createLlmConfiguration(context) {
+  const { fs, signal } = context;
+  const base = context.env.XDG_CONFIG_HOME ?? `${context.env.HOME ?? "/"}/.config`;
+  const directory = pathOf(context, context.env.LLM_USER_PATH ?? `${base}/io.datasette.llm`);
+  const filename = (name) => `${directory}/${name}`;
+  const stat = async (path) => {
+    try {
+      const result = await fs.lstat(path, { signal });
+      if (result.type !== "file")
+        throw new FsError2("EINVAL", { path, message: "LLM configuration must be a regular file" });
+      return result;
+    } catch (error) {
+      if (error instanceof FsError2 && error.code === "ENOENT")
+        return null;
+      throw error;
+    }
+  };
+  const read = async (name) => {
+    const path = filename(name);
+    if (!await stat(path))
+      return void 0;
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let bytes = 0, text = "";
+    const source = fs.readStream?.(path, { signal, chunkSize: 16384 }) ?? toByteSource2(await fs.readFile(path, { signal, maxBytes: maxConfigurationBytes }));
+    for await (const chunk of source) {
+      signal.throwIfAborted();
+      if (chunk.byteLength > maxConfigurationBytes - bytes)
+        throw new FsError2("EFBIG", { path, message: "LLM configuration byte limit exceeded" });
+      bytes += chunk.byteLength;
+      text += decoder.decode(chunk, { stream: true });
+    }
+    return text + decoder.decode();
+  };
+  const write = async (name, text, observed) => {
+    signal.throwIfAborted();
+    if (!fs.publishFileConditional && !fs.writeFileConditional && !fs.createStagedFile)
+      throw new FsError2("ENOTSUP", { message: "LLM configuration requires atomic conditional publication" });
+    const bytes = new TextEncoder().encode(text);
+    if (bytes.byteLength > maxConfigurationBytes)
+      throw new FsError2("EFBIG", { message: "LLM configuration byte limit exceeded" });
+    await fs.mkdir(directory, { recursive: true, signal });
+    const parent = await fs.stat(directory, { signal });
+    const path = filename(name), expected = observed === void 0 ? await stat(path) : observed;
+    await publishConfiguration(fs, directory, path, bytes, parent, expected, signal);
+  };
+  const serialized = async (operation) => {
+    let entries = locks.get(fs);
+    if (!entries) {
+      entries = /* @__PURE__ */ new Map();
+      locks.set(fs, entries);
+    }
+    const previous = entries.get(directory) ?? Promise.resolve();
+    const current = previous.catch(() => {
+    }).then(() => {
+      signal.throwIfAborted();
+      return operation();
+    });
+    entries.set(directory, current);
+    try {
+      await current;
+    } finally {
+      if (entries.get(directory) === current)
+        entries.delete(directory);
+    }
+  };
+  const json = async (name) => {
+    const text = await read(name);
+    return text === void 0 ? {} : JSON.parse(text);
+  };
+  const aliases = async () => {
+    const value = await json("aliases.json");
+    if (!stringRecord(value))
+      throw new Error("Invalid aliases.json: expected string values");
+    return value;
+  };
+  const options = async () => {
+    const value = await json("model_options.json");
+    if (!record(value) || !Object.values(value).every(stringRecord))
+      throw new Error("Invalid model_options.json: expected model option objects");
+    return value;
+  };
+  const resolveAlias = async (name) => {
+    const values = await aliases(), seen = /* @__PURE__ */ new Set();
+    while (Object.hasOwn(values, name)) {
+      if (seen.has(name))
+        throw new Error(`Alias cycle: ${name}`);
+      seen.add(name);
+      name = values[name];
+    }
+    return name;
+  };
+  const setModelOption = (model, name, value) => serialized(async () => {
+    const expected = await stat(filename("model_options.json"));
+    const values = await options();
+    const previous = Object.hasOwn(values, model) ? values[model] : {};
+    const next = { ...values, [model]: { ...previous, [name]: value } };
+    await write("model_options.json", JSON.stringify(next, null, 2), expected);
+  });
+  return {
+    directory,
+    aliases,
+    resolveAlias,
+    allModelOptions: options,
+    setAlias: (name, model) => serialized(async () => {
+      const expected = await stat(filename("aliases.json"));
+      const values = await aliases();
+      const canonical = await resolveAlias(model);
+      await write("aliases.json", JSON.stringify({ ...values, [name]: canonical }, null, 4) + "\n", expected);
+    }),
+    removeAlias: (name) => serialized(async () => {
+      const expected = await stat(filename("aliases.json"));
+      const values = await aliases();
+      if (!Object.hasOwn(values, name))
+        throw new Error(`No such alias: ${name}`);
+      delete values[name];
+      await write("aliases.json", JSON.stringify(values, null, 4) + "\n", expected);
+    }),
+    defaultModel: () => read("default_model.txt"),
+    setDefaultModel: (model) => serialized(() => write("default_model.txt", model)),
+    modelOptions: async (model) => {
+      const values = await options();
+      return Object.hasOwn(values, model) ? values[model] : {};
+    },
+    setModelOption,
+    clearModelOption: (model, name) => serialized(async () => {
+      const expected = await stat(filename("model_options.json"));
+      const values = await options();
+      if (!Object.hasOwn(values, model))
+        return;
+      if (name === void 0)
+        delete values[model];
+      else {
+        delete values[model][name];
+        if (!Object.keys(values[model]).length)
+          delete values[model];
+      }
+      await write("model_options.json", JSON.stringify(values, null, 2), expected);
+    })
+  };
+}
+
+// packages/safe-bash-command-llm/dist/templates.js
+init_buffer();
+import { FsError as FsError3 } from "../../safe-bash-contracts/index.js";
+var templateFields = ["name", "prompt", "system", "model", "defaults", "options", "attachments", "attachment_types"];
+function template(value, name) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`Invalid template: ${name}`);
+  const fields = value;
+  for (const [key, item] of Object.entries(fields)) {
+    if (!templateFields.includes(key))
+      throw new Error(`Unsupported template field: ${key}`);
+    if (key === "attachments") {
+      if (!Array.isArray(item) || item.some((value2) => typeof value2 !== "string"))
+        throw new Error(`Invalid template: ${name}`);
+    } else if (key === "attachment_types") {
+      if (!Array.isArray(item) || item.some((value2) => !value2 || typeof value2 !== "object" || Array.isArray(value2) || typeof value2.type !== "string" || typeof value2.value !== "string"))
+        throw new Error(`Invalid template: ${name}`);
+      fields[key] = item.map(({ type, value: value2 }) => ({ type, value: value2 }));
+    } else if (["defaults", "options"].includes(key)) {
+      if (!item || typeof item !== "object" || Array.isArray(item) || Object.values(item).some((value2) => typeof value2 !== "string" && typeof value2 !== "number" && typeof value2 !== "boolean"))
+        throw new Error(`Invalid template: ${name}`);
+    } else if (typeof item !== "string")
+      throw new Error(`Invalid template: ${name}`);
+  }
+  return { ...fields, name };
+}
+function interpolate(text, params, validateOnly = false) {
+  if (!text)
+    return text;
+  let result = "";
+  const missing = [];
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] !== "$") {
+      if (!validateOnly)
+        result += text[index];
+      continue;
+    }
+    if (text[index + 1] === "$") {
+      if (!validateOnly)
+        result += "$";
+      index++;
+      continue;
+    }
+    const start = index, braced = text[index + 1] === "{";
+    if (braced)
+      index++;
+    let name = "";
+    while (index + 1 < text.length && "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_".includes(text[index + 1]))
+      name += text[++index];
+    if (!name || "0123456789".includes(name[0]) || braced && text[index + 1] !== "}")
+      throw new Error(`Invalid placeholder in template at position ${start}`);
+    if (braced)
+      index++;
+    if (!Object.hasOwn(params, name)) {
+      if (!missing.includes(name))
+        missing.push(name);
+    } else if (!validateOnly)
+      result += String(params[name]);
+  }
+  if (missing.length)
+    throw new Error(`Missing variables: ${missing.join(", ")}`);
+  return result;
+}
+function validateLlmTemplateParameters(value, params) {
+  const variables = { ...value.defaults, ...params, input: "" };
+  for (const text of [value.prompt, value.system])
+    interpolate(text, variables, true);
+}
+function llmTemplateUsesInput(value) {
+  for (const text of [value.prompt, value.system]) {
+    if (!text)
+      continue;
+    for (let index = 0; index < text.length; index++) {
+      if (text[index] !== "$")
+        continue;
+      if (text[index + 1] === "$") {
+        index++;
+        continue;
+      }
+      let name = "";
+      while (index + 1 < text.length && "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_".includes(text[index + 1]))
+        name += text[++index];
+      if (name === "input")
+        return true;
+    }
+  }
+  return false;
+}
+function evaluateLlmTemplate(value, input, params) {
+  const variables = { ...value.defaults, ...params, input };
+  return { prompt: value.prompt ? interpolate(value.prompt, variables) : input, ...value.system === void 0 ? {} : { system: interpolate(value.system, variables) } };
+}
+function createLlmTemplateStore(context) {
+  const directory = `${createLlmConfiguration(context).directory}/templates`;
+  const filename = (name) => {
+    if (!name || name.includes("/") || name.includes("\\") || name === "." || name === "..")
+      throw new Error(`Invalid template name: ${name}`);
+    return `${directory}/${name}.yaml`;
+  };
+  const load = async (name) => {
+    try {
+      const { parse: parse2 } = await import("../bundled-yaml/index.js");
+      const bytes = await context.fs.readFile(filename(name), { signal: context.signal });
+      return template(parse2(new TextDecoder("utf-8", { fatal: true }).decode(bytes)), name);
+    } catch (error) {
+      if (error instanceof FsError3 && error.code === "ENOENT")
+        throw new Error(`Invalid template: ${name}`);
+      throw error;
+    }
+  };
+  return {
+    directory,
+    load,
+    async save(name, value) {
+      const { stringify } = await import("../bundled-yaml/index.js");
+      const path = filename(name);
+      await context.fs.mkdir(directory, { recursive: true, signal: context.signal });
+      const parent = await context.fs.stat(directory, { signal: context.signal });
+      let expected;
+      try {
+        expected = await context.fs.lstat(path, { signal: context.signal });
+      } catch (error) {
+        if (!(error instanceof FsError3) || error.code !== "ENOENT")
+          throw error;
+        expected = null;
+      }
+      const bytes = new TextEncoder().encode(stringify(value, { indent: 4, lineWidth: 0 }));
+      await publishConfiguration(context.fs, directory, path, bytes, parent, expected, context.signal);
+    },
+    async command(args, output) {
+      const [command, name] = args;
+      if (command === "path" && args.length === 1) {
+        await output(directory + "\n");
+        return;
+      }
+      if (command === "show" && name && args.length === 2) {
+        let value;
+        try {
+          value = await load(name);
+        } catch {
+          throw new Error(`Template '${name}' not found or invalid`);
+        }
+        const { stringify } = await import("../bundled-yaml/index.js");
+        const sorted = Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
+        await output(stringify(sorted, { indent: 4, lineWidth: 0 }) + "\n");
+        return;
+      }
+      if (command !== void 0 && command !== "list" || args.length > 1)
+        throw new Error("Invalid templates command");
+      let files;
+      try {
+        files = await context.fs.readdir(directory, { signal: context.signal });
+      } catch (error) {
+        if (error instanceof FsError3 && error.code === "ENOENT")
+          return;
+        throw error;
+      }
+      const values = [];
+      for (const file of files) {
+        if (file.type !== "file" || !file.name.endsWith(".yaml"))
+          continue;
+        try {
+          values.push(await load(file.name.slice(0, -5)));
+        } catch {
+          context.signal.throwIfAborted();
+        }
+      }
+      const width = Math.max(0, ...values.map((value) => [...value.name].length));
+      for (const value of values.sort((a, b) => a.name.localeCompare(b.name))) {
+        const description = (value.system ? `system: ${value.system}${value.prompt ? ` prompt: ${value.prompt}` : ""}` : value.prompt ?? "").split("\n").join(" ");
+        await output(`${value.name}${" ".repeat(width - [...value.name].length)} : ${description}
+`);
+      }
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/dist/retained-spool.js
+init_buffer();
+import { FsError as FsError4 } from "../../safe-bash-contracts/index.js";
+var serial = 0;
+function verifyRetainedFile(actual, expected) {
+  const sameOwner = expected.identityScope !== void 0 && expected.identityScope === actual.identityScope;
+  const sameIdentity = expected.opaqueIdentity !== void 0 ? expected.opaqueIdentity === actual.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && expected.dev === actual.dev && expected.ino === actual.ino;
+  if (!sameOwner || !sameIdentity || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs)
+    throw new FsError4("EBUSY", { message: "LLM spool changed" });
+}
+async function createLlmSpool(fs, directory, signal, purpose = "output") {
+  const parent = await fs.stat(directory, { signal });
+  if (parent.type !== "directory")
+    throw new FsError4("ENOTDIR", { path: directory });
+  const caps = await fs.capabilitiesFor?.(directory, { signal }) ?? fs.capabilities;
+  if (!caps.retainedStagingCleanup || !caps.retainedStagingWrite || !caps.retainedRead || !fs.createStagedFile || !fs.openReadFile)
+    throw new FsError4("ENOTSUP", { message: "LLM staging requires caller filesystem retained staging and reads" });
+  let staging;
+  for (let attempt = 0; attempt < 16; attempt++) {
+    try {
+      staging = await fs.createStagedFile(`${directory === "/" ? "" : directory}/.llm-${purpose}-${++serial}`, purpose, { type: "file", data: new Uint8Array(0) }, { parent, mode: 384, retainCleanup: true, signal });
+      break;
+    } catch (error) {
+      signal.throwIfAborted();
+      if (!(error instanceof FsError4) || error.code !== "EEXIST")
+        throw error;
+    }
+  }
+  if (!staging)
+    throw new FsError4("EEXIST", { message: "LLM output staging names exhausted" });
+  const owner = staging;
+  const cleanup = owner.cleanup;
+  const writer = owner.writer;
+  if (!cleanup || !writer) {
+    try {
+      await cleanup?.remove();
+    } finally {
+      await cleanup?.close();
+    }
+    throw new FsError4("EIO", { message: "Caller filesystem omitted its retained staging handles" });
+  }
+  let reader;
+  let sealed;
+  let written = 0;
+  let closing;
+  return {
+    async write(bytes) {
+      signal.throwIfAborted();
+      if (sealed || closing)
+        throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      for (let offset = 0; offset < bytes.byteLength; offset += 16384) {
+        const chunk = bytes.subarray(offset, offset + 16384);
+        await writer.write(chunk, { signal });
+        written += chunk.byteLength;
+      }
+    },
+    async *replay() {
+      signal.throwIfAborted();
+      if (sealed || closing)
+        throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      sealed = await writer.finish({ signal });
+      if (sealed.size !== written)
+        throw new FsError4("EIO", { message: "LLM spool size mismatch" });
+      signal.throwIfAborted();
+      if (closing)
+        throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      const opened = await fs.openReadFile(owner.file.path, { signal });
+      if (closing || signal.aborted) {
+        await opened.close();
+        signal.throwIfAborted();
+        throw new FsError4("EBADF", { message: "LLM spool is closed" });
+      }
+      reader = opened;
+      verifyRetainedFile(await reader.stat({ signal }), sealed);
+      let position = 0;
+      while (position < written) {
+        const bytes = await reader.read(position, Math.min(16384, written - position), { signal });
+        if (!bytes.byteLength || bytes.byteLength > Math.min(16384, written - position))
+          throw new FsError4("EIO", { message: "Invalid LLM spool read" });
+        verifyRetainedFile(await reader.stat({ signal }), sealed);
+        position += bytes.byteLength;
+        yield bytes;
+      }
+    },
+    close() {
+      closing ??= (async () => {
+        try {
+          await reader?.close();
+        } finally {
+          try {
+            await cleanup.remove();
+          } finally {
+            await cleanup.close();
+          }
+        }
+      })();
+      return closing;
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/dist/file-source.js
+init_buffer();
+import { FsError as FsError5 } from "../../safe-bash-contracts/index.js";
+function sameFile(actual, expected) {
+  const identified = expected.opaqueIdentity !== void 0 ? expected.opaqueIdentity === actual.opaqueIdentity : expected.dev !== void 0 && expected.ino !== void 0 && expected.dev === actual.dev && expected.ino === actual.ino;
+  if (!identified || expected.identityScope === void 0 || expected.identityScope !== actual.identityScope || actual.type !== "file" || actual.size !== expected.size || actual.revision !== expected.revision || actual.opaqueVersion !== expected.opaqueVersion || actual.mtimeMs !== expected.mtimeMs || actual.ctimeMs !== expected.ctimeMs)
+    throw new FsError5("EBUSY", { message: "LLM attachment changed" });
+}
+async function fileSource({ fs, path, signal, maxBytes = Infinity, expectedStat }) {
+  signal.throwIfAborted();
+  const capabilities = await fs.capabilitiesFor?.(path, { signal }) ?? fs.capabilities;
+  if (!capabilities.retainedRead || !fs.openReadFile)
+    throw new FsError5("ENOTSUP", { message: "LLM attachment sources require retained reads" });
+  const expected = await fs.stat(path, { signal });
+  if (expectedStat)
+    sameFile(expected, expectedStat);
+  if (expected.type !== "file")
+    throw new FsError5("EINVAL", { path });
+  if (expected.size > maxBytes)
+    throw new FsError5("EFBIG", { message: "LLM attachment input byte limit exceeded" });
+  const reader = await fs.openReadFile(path, { signal });
+  let closing;
+  const dispose = () => closing ??= reader.close();
+  try {
+    sameFile(await reader.stat({ signal }), expected);
+  } catch (error) {
+    await dispose();
+    throw error;
+  }
+  let consumed = false;
+  return {
+    dispose,
+    bytes: { async *[Symbol.asyncIterator]() {
+      if (consumed || closing)
+        throw new FsError5("EBADF", { message: "LLM attachment source is closed" });
+      consumed = true;
+      let position = 0;
+      while (position < expected.size) {
+        signal.throwIfAborted();
+        if (closing)
+          throw new FsError5("EBADF", { message: "LLM attachment source is closed" });
+        sameFile(await reader.stat({ signal }), expected);
+        const length = Math.min(16384, expected.size - position);
+        const bytes = await reader.read(position, length, { signal });
+        if (closing)
+          throw new FsError5("EBADF", { message: "LLM attachment source is closed" });
+        signal.throwIfAborted();
+        if (!bytes.byteLength || bytes.byteLength > length)
+          throw new FsError5("EIO", { message: "Invalid LLM attachment read" });
+        sameFile(await reader.stat({ signal }), expected);
+        position += bytes.byteLength;
+        yield bytes;
+      }
+      sameFile(await reader.stat({ signal }), expected);
+    } }
+  };
+}
+
+// packages/safe-bash-command-llm/dist/schemas.js
+init_buffer();
+function parseLlmSchemaDsl(input, multi = false) {
+  const properties = /* @__PURE__ */ Object.create(null);
+  const required = [];
+  const types = { int: "integer", float: "number", bool: "boolean", str: "string" };
+  for (const field of input.split(input.includes("\n") ? "\n" : ",").map((value) => value.trim()).filter(Boolean)) {
+    const colon = field.indexOf(":");
+    const info = (colon < 0 ? field : field.slice(0, colon)).trim();
+    const description = colon < 0 ? "" : field.slice(colon + 1).trim();
+    const parts = [];
+    let word = "";
+    for (const character of info) {
+      if (character.trim() === "") {
+        if (word)
+          parts.push(word);
+        word = "";
+      } else
+        word += character;
+    }
+    if (word)
+      parts.push(word);
+    const name = parts[0];
+    if (!name)
+      throw new Error("Schema field requires a name");
+    const indicator = parts[1] ?? "str";
+    const type = Object.hasOwn(types, indicator) ? types[indicator] : "string";
+    properties[name] = { type, ...description ? { description } : {} };
+    required.push(name);
+  }
+  const schema = { type: "object", properties, required };
+  return multi ? { type: "object", properties: { items: { type: "array", items: schema } }, required: ["items"] } : schema;
+}
+
+// packages/safe-bash-command-llm/dist/configuration-command.js
+init_buffer();
+async function configurationCommand(context, service, args, output, diagnostic) {
+  if (args.length === 1 && args[0] === "--version") {
+    await output("llm, version 0.27.1\n");
+    return true;
+  }
+  const aliases = args[0] === "aliases";
+  const defaults = args[0] === "models" && args[1] === "default";
+  const options = args[0] === "models" && args[1] === "options";
+  if (!aliases && !defaults && !options)
+    return false;
+  const configuration = createLlmConfiguration(context);
+  const canonical = async (model) => {
+    const resolved = await configuration.resolveAlias(model);
+    try {
+      return service.resolve(resolved).model.id;
+    } catch {
+      return resolved;
+    }
+  };
+  const tokens = args.slice(aliases ? 1 : 2), command = tokens[0];
+  if (defaults) {
+    if (tokens.length > 1)
+      throw new Error("Unexpected extra arguments");
+    if (command === void 0)
+      await output(`${await configuration.defaultModel() ?? service.resolve().model.id}
+`);
+    else {
+      const model = service.resolve(await canonical(command)).model.id;
+      await configuration.setDefaultModel(model);
+    }
+    return true;
+  }
+  if (aliases) {
+    if (command === "path" && tokens.length === 1)
+      await output(`${configuration.directory}/aliases.json
+`);
+    else if (command === "set") {
+      const operands = [], queries = [];
+      for (let index = 1; index < tokens.length; index++) {
+        const token = tokens[index];
+        if (token === "-q" || token === "--query") {
+          const query = tokens[++index];
+          if (query === void 0)
+            throw new Error(`Option '${token}' requires an argument`);
+          queries.push(query);
+        } else if (token.startsWith("--query="))
+          queries.push(token.slice(8));
+        else if (token.startsWith("-q") && token.length > 2)
+          queries.push(token.slice(2));
+        else if (token.startsWith("-"))
+          throw new Error(`No such option: ${token}`);
+        else
+          operands.push(token);
+      }
+      if (!operands.length || operands.length > 2)
+        throw new Error("Invalid aliases set arguments");
+      let model = operands[1];
+      const queried = model === void 0;
+      if (model === void 0) {
+        if (!queries.length)
+          throw new Error("You must provide a model_id or at least one -q option");
+        const persisted = await configuration.aliases();
+        const found = service.models.find((entry) => queries.every((query) => [entry.provider.name, entry.model.id, ...entry.model.aliases ?? [], ...Object.entries(persisted).filter(([, id]) => id === entry.model.id).map(([alias]) => alias)].some((text) => text.toLowerCase().includes(query.toLowerCase()))));
+        if (!found)
+          throw new Error(`No model found matching query: ${queries.join(", ")}`);
+        model = found.model.id;
+      }
+      await configuration.setAlias(operands[0], await canonical(model));
+      if (queried)
+        await diagnostic(`Alias '${operands[0]}' set to model '${model}'
+`);
+    } else if (command === "remove" && tokens.length === 2)
+      await configuration.removeAlias(tokens[1]);
+    else if ((command === void 0 || command === "list" || command === "--json") && tokens.slice(command === void 0 ? 0 : 1).every((token) => token === "--json")) {
+      const values = {};
+      for (const { model } of service.models)
+        for (const alias of model.aliases ?? [])
+          if (alias !== model.id)
+            Object.defineProperty(values, alias, { value: model.id, enumerable: true, configurable: true, writable: true });
+      const entries = Object.entries({ ...values, ...await configuration.aliases() });
+      if (tokens.includes("--json"))
+        await output(JSON.stringify(Object.fromEntries(entries), null, 4) + "\n");
+      else {
+        const width = Math.max(0, ...entries.map(([alias]) => [...alias].length));
+        for (const [alias, model] of entries)
+          await output(`${alias}${" ".repeat(width - [...alias].length)} : ${model}
+`);
+      }
+    } else
+      throw new Error("Invalid aliases command");
+    return true;
+  }
+  if (command === "set" && tokens.length === 4) {
+    const model = await canonical(tokens[1]);
+    const entry = service.models.find((entry2) => entry2.model.id === model);
+    if (entry)
+      validateModelOptions(entry.model, { [tokens[2]]: tokens[3] });
+    await configuration.setModelOption(model, tokens[2], tokens[3]);
+    await diagnostic(`Set default option ${tokens[2]}=${tokens[3]} for model ${model}
+`);
+  } else if (command === "show" && tokens.length === 2) {
+    const model = await canonical(tokens[1]), values = await configuration.modelOptions(model);
+    if (!Object.keys(values).length)
+      await diagnostic(`No default options set for model '${model}'.
+`);
+    else
+      for (const [key, value] of Object.entries(values))
+        await output(`${key}: ${value}
+`);
+  } else if (command === "clear" && (tokens.length === 2 || tokens.length === 3)) {
+    const model = await canonical(tokens[1]);
+    const keys = tokens[2] === void 0 ? Object.keys(await configuration.modelOptions(model)) : [tokens[2]];
+    await configuration.clearModelOption(model, tokens[2]);
+    if (keys.length === 1)
+      await output(`Cleared option '${keys[0]}' for model ${model}
+`);
+    else if (keys.length > 1)
+      await output(`Cleared ${keys.join(", ")} options for model ${model}
+`);
+  } else if (command === "list" && tokens.length === 1 || command === void 0) {
+    await listOptions(configuration, output, diagnostic);
+  } else
+    throw new Error("Invalid models options command");
+  return true;
+}
+async function listOptions(configuration, output, diagnostic) {
+  const entries = Object.entries(await configuration.allModelOptions());
+  if (!entries.length)
+    await diagnostic("No default options set for any models.\n");
+  for (const [model, values] of entries) {
+    await output(`${model}:
+`);
+    for (const [key, value] of Object.entries(values))
+      await output(`  ${key}: ${value}
+`);
+  }
+}
+
+// packages/safe-bash-command-llm/dist/models-list.js
+init_buffer();
+var modelsGroupHelp = "Usage: llm models [OPTIONS] COMMAND [ARGS]...\n\n  Manage available models\n\nOptions:\n  -h, --help  Show this message and exit.\n\nCommands:\n  list*    List available models\n  default  Show or set the default model\n  options  Manage default options for models\n";
+var LlmModelsUsageError = class extends Error {
+  constructor(message, usage = true) {
+    super((usage ? "Usage: llm models list [OPTIONS]\nTry 'llm models list -h' for help.\n\n" : "") + `Error: ${message}`);
+  }
+};
+function wrapDescription(description) {
+  const lines = [];
+  let line = "";
+  for (const word of description.split(" ")) {
+    if (!word)
+      continue;
+    if (line && line.length + word.length + 1 > 70) {
+      lines.push(line);
+      line = "";
+    }
+    line += (line ? " " : "") + word;
+  }
+  if (line)
+    lines.push(line);
+  return lines.join("\n      ");
+}
+async function listLlmModels(context, service, tokens, emit, step) {
+  const explicit = tokens[0] === "list";
+  const terminator = tokens.indexOf("--");
+  const groupFlags = terminator < 0 ? tokens : tokens.slice(0, terminator);
+  if (!explicit && groupFlags.some((token) => token === "--help" || token.startsWith("-") && !token.startsWith("--") && token.slice(1).includes("h"))) {
+    await emit(modelsGroupHelp);
+    return;
+  }
+  const queries = [], selected = [];
+  let schemas = false, tools = false, asyncModels = false, options = false, help = false, ended = false;
+  const unexpected = [];
+  const args = explicit ? tokens.slice(1) : tokens.filter((_, index) => index !== terminator);
+  for (let index = 0; index < args.length; index++) {
+    await step();
+    const argument = args[index];
+    if (ended) {
+      unexpected.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    if (argument === "--help" || argument === "-h") {
+      help = true;
+      continue;
+    }
+    if (argument === "--options") {
+      options = true;
+      continue;
+    }
+    if (argument === "--schemas") {
+      schemas = true;
+      continue;
+    }
+    if (argument === "--tools") {
+      tools = true;
+      continue;
+    }
+    if (argument === "--async") {
+      asyncModels = true;
+      continue;
+    }
+    if (!argument.startsWith("-") || argument === "-") {
+      unexpected.push(argument);
+      continue;
+    }
+    const equals = argument.indexOf("=");
+    const long = argument.startsWith("--");
+    const flag = long ? argument.slice(0, equals < 0 ? void 0 : equals) : argument.slice(0, 2);
+    const attached = long ? equals < 0 ? void 0 : argument.slice(equals + 1) : argument.length > 2 ? argument.slice(2) : void 0;
+    if (equals >= 0 && ["--schemas", "--tools", "--async", "--options", "--help", "-h"].includes(flag))
+      throw new LlmModelsUsageError(`Option '${flag}' does not take a value.`, false);
+    if (!["-q", "--query", "-m", "--model"].includes(flag))
+      throw new LlmModelsUsageError(`No such option: ${flag}`);
+    const value = attached ?? args[++index];
+    if (value === void 0)
+      throw new LlmModelsUsageError(`Option '${flag}' requires an argument.`, false);
+    (flag === "-q" || flag === "--query" ? queries : selected).push(value);
+  }
+  if (help) {
+    await emit("Usage: llm models list [OPTIONS]\n\n  List available models\n\nOptions:\n  --options         Show options for each model, if available\n  --async           List async models\n  --schemas         List models that support schemas\n  --tools           List models that support tools\n  -q, --query TEXT  Search for models matching these strings\n  -m, --model TEXT  Specific model IDs\n  -h, --help        Show this message and exit.\n");
+    return;
+  }
+  if (unexpected.length)
+    throw new LlmModelsUsageError(`Got unexpected extra argument${unexpected.length === 1 ? "" : "s"} (${unexpected.join(" ")})`);
+  const configuration = createLlmConfiguration(context);
+  const configuredAliases = await configuration.aliases();
+  const shownDescriptions = /* @__PURE__ */ new Set();
+  for (const { provider, model } of service.models) {
+    await step();
+    const aliases = new Set(model.aliases);
+    for (const [alias, target] of Object.entries(configuredAliases)) {
+      if (target === model.id || target === `${provider.name}/${model.id}` || model.aliases?.includes(target))
+        aliases.add(alias);
+    }
+    const description = `${provider.name}: ${model.id}`;
+    const terms = [description, ...aliases].map((value) => value.toLowerCase());
+    if (!queries.every((query) => terms.some((term) => term.includes(query.toLowerCase()))))
+      continue;
+    if (selected.length && !selected.some((value) => value === model.id || aliases.has(value)))
+      continue;
+    if (schemas && !model.capabilities?.includes("schema") || tools || asyncModels)
+      continue;
+    let output = description + (aliases.size ? ` (aliases: ${[...aliases].join(", ")})` : "");
+    if (options && Object.keys(model.options ?? {}).length) {
+      output += "\n  Options:";
+      for (const [name, rule] of Object.entries(model.options)) {
+        const type = { number: "float", integer: "int", boolean: "boolean", string: "str" }[rule.type];
+        output += `
+    ${name}: ${type}`;
+        if (rule.description && !shownDescriptions.has(provider.name))
+          output += `
+      ${wrapDescription(rule.description)}`;
+      }
+      shownDescriptions.add(provider.name);
+    }
+    if (options && model.attachmentTypes?.length)
+      output += `
+  Attachment types:
+    ${[...model.attachmentTypes].sort().join(", ")}`;
+    if (options && model.capabilities?.includes("schema"))
+      output += "\n  Features:\n  - schemas";
+    await emit(output + "\n");
+  }
+  if (!queries.length && !selected.length && !schemas && !options) {
+    const configured = await configuration.defaultModel();
+    let model = configured;
+    if (model === void 0) {
+      try {
+        model = service.resolve().model.id;
+      } catch {
+      }
+    }
+    if (model !== void 0)
+      await emit(`Default: ${model}
+`);
+  }
+}
+
+// packages/safe-bash-command-llm/dist/command.js
+async function parse(length, text, step) {
+  const parsed = { prompt: "", params: {}, options: /* @__PURE__ */ Object.create(null), attachments: [] };
+  const operands = [];
+  let ended = false;
+  for (let index = 0; index < length; index++) {
+    await step();
+    const argument = text(index);
+    if (!ended && ["--no-log", "-n"].includes(argument))
+      continue;
+    if (!ended && argument === "--no-stream") {
+      parsed.noStream = true;
+      continue;
+    }
+    if (ended || !argument.startsWith("-") || argument === "-") {
+      operands.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    const equals = argument.indexOf("=");
+    const long = argument.startsWith("--");
+    const flag = long ? argument.slice(0, equals < 0 ? void 0 : equals) : argument.slice(0, 2);
+    const attached = long ? equals < 0 ? void 0 : argument.slice(equals + 1) : argument.length > 2 ? argument.slice(2) : void 0;
+    const take = () => {
+      if (++index >= length)
+        throw new Error(`Option ${flag} requires an argument`);
+      return text(index);
+    };
+    if (!["-m", "--model", "-s", "--system", "-o", "--option", "-a", "--attachment", "--at", "--attachment-type", "-t", "--template", "--save", "-p", "--param"].includes(flag))
+      throw new Error(`Unknown option: ${flag}`);
+    const value = attached ?? take();
+    if (flag === "-t" || flag === "--template")
+      parsed.template = value;
+    else if (flag === "--save")
+      parsed.save = value;
+    else if (flag === "-p" || flag === "--param")
+      Object.defineProperty(parsed.params, value, { value: take(), enumerable: true, configurable: true, writable: true });
+    else if (flag === "-m" || flag === "--model")
+      parsed.model = value;
+    else if (flag === "-s" || flag === "--system")
+      parsed.system = value;
+    else if (flag === "-o" || flag === "--option")
+      parsed.options[value] = take();
+    else if (flag === "--at" || flag === "--attachment-type")
+      parsed.attachments.push({ path: value, mimeType: take() });
+    else
+      parsed.attachments.push({ path: value });
+  }
+  parsed.prompt = operands.join(" ");
+  return parsed;
+}
+async function interrupted(start, signal) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const aborted = () => reject(signal.reason);
+    signal.addEventListener("abort", aborted, { once: true });
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return start();
+    }).then((value) => {
+      signal.removeEventListener("abort", aborted);
+      resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", aborted);
+      reject(error);
+    });
+  });
+}
+async function execute(context, service, limits) {
+  context.signal.throwIfAborted();
+  const controller = new AbortController();
+  const operation = createOutputOperation(context, context.stdout);
+  const signal = AbortSignal.any([operation.signal, controller.signal]);
+  inheritYieldCheckpoint(context.signal, signal);
+  let iterator;
+  let closed = false;
+  let ended = false;
+  operation.registerCleanup(() => {
+    if (closed)
+      return;
+    closed = true;
+    controller.abort(new Error("llm request closed"));
+    if (!ended && iterator) {
+      const resource = iterator;
+      void Promise.resolve().then(() => resource.return?.()).catch(() => {
+      });
+    }
+  });
+  let work = 0;
+  const step = async () => {
+    signal.throwIfAborted();
+    if (closed)
+      throw new Error("LLM invocation is closed");
+    work++;
+    if (work % 256 === 0)
+      await yieldTurn(signal);
+  };
+  let outputSpool;
+  let outputBytes = 0;
+  let writing = false;
+  const write = async (chunk) => {
+    if (chunk.byteLength > (limits?.maxOutputBytes ?? Infinity) - outputBytes)
+      throw new FsError6("EFBIG", { message: "llm output byte limit exceeded" });
+    outputBytes += chunk.byteLength;
+    if (outputSpool) {
+      await outputSpool.write(chunk);
+      return;
+    }
+    writing = true;
+    await operation.output.write(chunk);
+    writing = false;
+  };
+  const emitText = async (text) => {
+    for (let offset = 0; offset < text.length; ) {
+      await step();
+      let end = Math.min(text.length, offset + 16384);
+      const last = text.charCodeAt(end - 1);
+      if (end < text.length && last >= 55296 && last <= 56319)
+        end--;
+      await write(new TextEncoder().encode(text.slice(offset, end)));
+      offset = end;
+    }
+  };
+  let inputBytes = 0;
+  const inputLimit = Math.min(context.inputBudget?.maxBytes ?? Infinity, limits?.maxInputBytes ?? Infinity);
+  const checkInput = (size) => {
+    context.inputBudget?.check(inputBytes + size);
+    if (size > inputLimit - inputBytes)
+      throw new FsError6("EFBIG", { message: "llm input byte limit exceeded" });
+  };
+  const admitInput = (size) => {
+    checkInput(size);
+    inputBytes += size;
+  };
+  try {
+    const argumentsValue = getCommandArguments(context);
+    const argumentText = (index) => {
+      const bytes = argumentsValue.bytes(index);
+      if (!bytes)
+        throw new Error("Missing option argument");
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    };
+    if (argumentsValue.args.length === 1 && ["--help", "-h"].includes(argumentsValue.args[0])) {
+      argumentText(0);
+      await emitText("Usage: llm [prompt] [-m MODEL] [-s SYSTEM] [-o KEY VALUE] [-a PATH] [--at PATH MIMETYPE]\n       llm models\nOptions: --model, --system, --option, --attachment; -- ends options\n");
+      return { exitCode: 0 };
+    }
+    if (argumentsValue.args.length === 2 && argumentsValue.args[0] === "models" && ["--help", "-h"].includes(argumentsValue.args[1])) {
+      argumentText(0);
+      argumentText(1);
+      await emitText(modelsGroupHelp);
+      return { exitCode: 0 };
+    }
+    if (argumentsValue.args[0] === "schemas" && argumentsValue.args[1] === "dsl") {
+      const tokens = Array.from({ length: argumentsValue.args.length - 2 }, (_, index) => argumentText(index + 2));
+      const usage = "Usage: llm schemas dsl [OPTIONS] INPUT\n";
+      if (tokens.includes("--help") || tokens.includes("-h")) {
+        await emitText(usage + "\n  Convert LLM's schema DSL to a JSON schema\n\n      llm schema dsl 'name, age int, bio: their bio'\n\nOptions:\n  --multi     Wrap in an array\n  -h, --help  Show this message and exit.\n");
+        return { exitCode: 0 };
+      }
+      let multi = false, optionsEnded = false;
+      const inputs = [];
+      let failure;
+      for (const token of tokens) {
+        await step();
+        if (!optionsEnded && token === "--")
+          optionsEnded = true;
+        else if (!optionsEnded && token === "--multi")
+          multi = true;
+        else if (!optionsEnded && token.startsWith("-") && token !== "-") {
+          failure = `No such option: ${token}`;
+          break;
+        } else {
+          admitInput(new TextEncoder().encode(token).byteLength);
+          inputs.push(token);
+        }
+      }
+      failure ??= inputs.length === 0 ? "Missing argument 'INPUT'." : inputs.length > 1 ? `Got unexpected extra argument (${inputs[1]})` : void 0;
+      if (failure) {
+        await writeDiagnostic(context.stderr, usage + "Try 'llm schemas dsl -h' for help.\n\nError: " + failure + "\n", signal);
+        return { exitCode: 2 };
+      }
+      await emitText(JSON.stringify(parseLlmSchemaDsl(inputs[0], multi), null, 2) + "\n");
+      return { exitCode: 0 };
+    }
+    if (argumentsValue.args[0] === "templates") {
+      try {
+        await createLlmTemplateStore(context).command(Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1)), emitText);
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : "Template failed"}`);
+      }
+      return { exitCode: 0 };
+    }
+    const configurationInvocation = argumentsValue.args[0] === "aliases" || argumentsValue.args[0] === "models" && ["default", "options"].includes(argumentsValue.args[1] ?? "") || argumentsValue.args[0] === "--version";
+    if (configurationInvocation) {
+      try {
+        const tokens = Array.from({ length: argumentsValue.args.length }, (_, index) => argumentText(index));
+        if (await configurationCommand(context, service, tokens, emitText, (text2) => writeDiagnostic(context.stderr, text2, signal)))
+          return { exitCode: 0 };
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : "Configuration failed"}`);
+      }
+    }
+    if (argumentsValue.args[0] === "models") {
+      await listLlmModels(context, service, Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1)), emitText, step);
+      return { exitCode: 0 };
+    }
+    const promptOffset = argumentsValue.args[0] === "prompt" ? 1 : 0;
+    const args = await parse(argumentsValue.args.length - promptOffset, (index) => argumentText(index + promptOffset), step);
+    const configuration = createLlmConfiguration(context);
+    const templateStore = createLlmTemplateStore(context);
+    if (args.save && args.template)
+      throw new Error("Error: --save cannot be used with --template");
+    let stored;
+    try {
+      stored = args.template === void 0 ? void 0 : await templateStore.load(args.template);
+    } catch (error) {
+      throw new Error(`Error: ${error instanceof Error ? error.message : "Invalid template"}`);
+    }
+    if (stored) {
+      try {
+        validateLlmTemplateParameters(stored, args.params);
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : "Invalid template"}`);
+      }
+    }
+    const selected = args.model ?? stored?.model ?? (args.save ? void 0 : await configuration.defaultModel());
+    const model = selected === void 0 ? void 0 : await configuration.resolveAlias(selected);
+    const entry = args.save && selected === void 0 ? void 0 : service.resolve(model);
+    const streamed = entry !== void 0 && service.streamSources !== void 0 && entry.provider.completeSources !== void 0 && entry.model.inputSources !== false;
+    const stagePrompt = streamed && stored === void 0 && args.save === void 0;
+    let promptSpool;
+    let stdinBytes = 0;
+    const fragments = [];
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    const templateUsesInput = stored !== void 0 && llmTemplateUsesInput(stored);
+    if (stored === void 0 || templateUsesInput) {
+      const input = await operation.acquire(() => context.stdinInput ? { next: () => context.stdinInput.read(Math.min(65536, inputLimit - inputBytes + 1), signal) } : context.stdin[Symbol.asyncIterator](), async (iterator2) => {
+        await iterator2.return?.();
+      });
+      while (true) {
+        await step();
+        const result = await interrupted(() => input.next(), signal);
+        signal.throwIfAborted();
+        if (result.done)
+          break;
+        const chunk = result.value;
+        if (!(chunk instanceof Uint8Array))
+          throw new TypeError("Byte sources must yield Uint8Array chunks");
+        admitInput(chunk.byteLength);
+        stdinBytes += chunk.byteLength;
+        if (stagePrompt) {
+          for (let offset = 0; offset < chunk.byteLength; offset += 16384) {
+            await step();
+            decoder.decode(chunk.subarray(offset, Math.min(offset + 16384, chunk.byteLength)), { stream: true });
+          }
+          if (chunk.byteLength) {
+            promptSpool ??= await operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal, "input"), (spool) => spool.close());
+            await promptSpool.write(chunk);
+          }
+        } else
+          fragments.push(decoder.decode(chunk, { stream: true }));
+      }
+    }
+    const decoderTail = decoder.decode();
+    if (!stagePrompt)
+      fragments.push(decoderTail);
+    if (promptSpool && args.prompt) {
+      if (stdinBytes)
+        await promptSpool.write(new TextEncoder().encode(" "));
+      for (let start = 0; start < args.prompt.length; ) {
+        await step();
+        let end = Math.min(args.prompt.length, start + 8192);
+        const last = args.prompt.charCodeAt(end - 1);
+        if (end < args.prompt.length && last >= 55296 && last <= 56319)
+          end--;
+        await promptSpool.write(new TextEncoder().encode(args.prompt.slice(start, end)));
+        start = end;
+      }
+    }
+    const content = fragments.join("");
+    let prompt = content && args.prompt ? `${content} ${args.prompt}` : content || args.prompt;
+    if (args.save) {
+      const attachments2 = args.attachments.filter((item) => item.mimeType === void 0).map((item) => item.path);
+      const attachmentTypes = args.attachments.filter((item) => item.mimeType !== void 0).map((item) => ({ type: item.mimeType, value: item.path }));
+      const saved = {
+        ...args.model === void 0 ? {} : { model: entry.model.id },
+        ...prompt ? { prompt } : {},
+        ...args.system === void 0 ? {} : { system: args.system },
+        ...Object.keys(args.params).length ? { defaults: args.params } : {},
+        ...Object.keys(args.options).length ? { options: args.options } : {},
+        ...attachments2.length ? { attachments: attachments2 } : {},
+        ...attachmentTypes.length ? { attachment_types: attachmentTypes } : {}
+      };
+      await templateStore.save(args.save, saved);
+      return { exitCode: 0 };
+    }
+    if (stored) {
+      try {
+        const evaluated = evaluateLlmTemplate(stored, templateUsesInput ? prompt : "", args.params);
+        if (evaluated.prompt)
+          prompt = !templateUsesInput && args.prompt ? `${evaluated.prompt}
+${args.prompt}` : evaluated.prompt;
+        if (args.system === void 0 && evaluated.system !== void 0)
+          args.system = evaluated.system;
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : "Invalid template"}`);
+      }
+    }
+    if (!entry)
+      throw new Error("No model selected; use --model or configure defaultModel");
+    args.options = { ...await configuration.modelOptions(entry.model.id), ...stored?.options, ...args.options };
+    args.attachments = [
+      ...(stored?.attachments ?? []).map((path) => ({ path })),
+      ...args.attachments.filter((item) => item.mimeType === void 0),
+      ...(stored?.attachment_types ?? []).map((item) => ({ path: item.value, mimeType: item.type })),
+      ...args.attachments.filter((item) => item.mimeType !== void 0)
+    ];
+    const attachments = [];
+    const sourceAttachments = [];
+    const textSource = (value) => ({
+      async dispose() {
+      },
+      bytes: { async *[Symbol.asyncIterator]() {
+        for (let offset = 0; offset < value.length; ) {
+          await step();
+          let end = Math.min(value.length, offset + 16384);
+          const last = value.charCodeAt(end - 1);
+          if (end < value.length && last >= 55296 && last <= 56319)
+            end--;
+          yield new TextEncoder().encode(value.slice(offset, end));
+          offset = end;
+        }
+      } }
+    });
+    for (const attachment of args.attachments) {
+      await step();
+      if (attachment.path.includes("://"))
+        throw new Error("URL attachments are not supported");
+      const path = pathOf2(context, attachment.path);
+      const stat = await interrupted(() => context.fs.stat(path, { signal }), signal);
+      checkInput(stat.size);
+      if (streamed) {
+        const source = await operation.acquire(() => fileSource({ fs: context.fs, path, signal, maxBytes: inputLimit - inputBytes, expectedStat: stat }), (source2) => source2.dispose());
+        const input = source.bytes[Symbol.asyncIterator]();
+        const first = await interrupted(() => input.next(), signal);
+        const mimeType2 = attachment.mimeType ?? sniffMimeType(path, first.done ? new Uint8Array() : first.value);
+        if (!acceptsMimeType(entry.model.attachmentTypes ?? [], mimeType2))
+          throw new Error(`Model ${entry.model.id} does not accept ${mimeType2}`);
+        admitInput(stat.size);
+        let closed2 = false, consumed = false;
+        sourceAttachments.push({ mimeType: mimeType2, source: {
+          async dispose() {
+            closed2 = true;
+            await source.dispose();
+          },
+          bytes: { async *[Symbol.asyncIterator]() {
+            if (closed2 || consumed)
+              throw new FsError6("EBADF", { message: "LLM attachment source is closed" });
+            consumed = true;
+            signal.throwIfAborted();
+            if (!first.done)
+              yield first.value;
+            while (true) {
+              if (closed2)
+                throw new FsError6("EBADF", { message: "LLM attachment source is closed" });
+              const next = await interrupted(() => input.next(), signal);
+              if (closed2)
+                throw new FsError6("EBADF", { message: "LLM attachment source is closed" });
+              if (next.done)
+                break;
+              yield next.value;
+            }
+          } }
+        } });
+        continue;
+      }
+      const bytes = await interrupted(() => context.fs.readFile(path, {
+        signal,
+        ...inputLimit === Infinity ? {} : { maxBytes: inputLimit - inputBytes }
+      }), signal);
+      signal.throwIfAborted();
+      if (!(bytes instanceof Uint8Array))
+        throw new TypeError("Attachment read must return Uint8Array");
+      admitInput(bytes.byteLength);
+      const mimeType = attachment.mimeType ?? sniffMimeType(path, bytes);
+      if (!acceptsMimeType(entry.model.attachmentTypes ?? [], mimeType))
+        throw new Error(`Model ${entry.model.id} does not accept ${mimeType}`);
+      attachments.push({ mimeType, bytes: new Uint8Array(bytes) });
+    }
+    const request = {
+      model: entry.model.id,
+      prompt,
+      ...args.system === void 0 ? {} : { system: args.system },
+      attachments,
+      options: args.options,
+      signal
+    };
+    signal.throwIfAborted();
+    if (args.noStream)
+      outputSpool = await operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal), (spool) => spool.close());
+    if (streamed) {
+      const events = service.streamSources({
+        model: request.model,
+        options: request.options,
+        signal,
+        prompt: promptSpool ? { bytes: promptSpool.replay(), dispose: promptSpool.close } : textSource(prompt),
+        ...args.system === void 0 ? {} : { system: textSource(args.system) },
+        attachments: sourceAttachments
+      });
+      iterator = (async function* () {
+        for await (const event of events) {
+          if (event.type === "text")
+            yield event.text;
+          else if (event.type === "bytes")
+            yield event.data;
+        }
+      })()[Symbol.asyncIterator]();
+    } else
+      iterator = service.complete(request)[Symbol.asyncIterator]();
+    const text = (entry.model.outputType ?? "text/plain").toLowerCase().startsWith("text/");
+    let pendingSurrogate = "";
+    while (true) {
+      await step();
+      const result = await interrupted(() => iterator.next(), signal);
+      signal.throwIfAborted();
+      if (result.done) {
+        ended = true;
+        break;
+      }
+      if (text ? typeof result.value !== "string" : !(result.value instanceof Uint8Array))
+        throw new Error(`Provider ${entry.provider.name} returned a response chunk incompatible with ${entry.model.outputType ?? "text/plain"}`);
+      if (typeof result.value === "string") {
+        let chunk = pendingSurrogate + result.value;
+        const last = chunk.charCodeAt(chunk.length - 1);
+        pendingSurrogate = last >= 55296 && last <= 56319 ? chunk.slice(-1) : "";
+        if (pendingSurrogate)
+          chunk = chunk.slice(0, -1);
+        if (chunk)
+          await emitText(chunk);
+      } else
+        await write(result.value);
+    }
+    if (text) {
+      if (pendingSurrogate)
+        await emitText(pendingSurrogate);
+      await write(Uint8Array.of(10));
+    }
+    if (outputSpool)
+      for await (const chunk of outputSpool.replay()) {
+        writing = true;
+        await operation.output.write(chunk);
+        writing = false;
+      }
+    return { exitCode: 0 };
+  } catch (error) {
+    context.signal.throwIfAborted();
+    operation.signal.throwIfAborted();
+    controller.abort(error);
+    if (writing)
+      throw error;
+    await operation.close();
+    await writeDiagnostic(context.stderr, `${error instanceof Error ? error.message.slice(0, 4096) : "llm provider failed"}
+`, context.signal);
+    return { exitCode: error instanceof LlmModelsUsageError ? 2 : 1 };
+  } finally {
+    controller.abort(new Error("llm request closed"));
+    await operation.close();
+  }
+}
+function createLlmCommand(options = {}) {
+  for (const [name, value] of Object.entries(options.limits ?? {})) {
+    if (!Number.isSafeInteger(value) || value < 0)
+      throw new TypeError(`Invalid llm limit: ${name}`);
+  }
+  const limits = options.limits === void 0 ? void 0 : Object.freeze({ ...options.limits });
+  if (options.service && (options.providers !== void 0 || options.defaultModel !== void 0))
+    throw new TypeError("Configure providers and defaultModel on the injected LLM service");
+  const service = options.service ?? createLlmService({ ...options, providers: options.providers ?? [] });
+  return { name: "llm", description: "Query injected language and media models", execute: (context) => execute(context, service, limits) };
+}
+function createLlmCommands(options = {}) {
+  return [createLlmCommand(options)];
+}
+function llmCommands(options = {}) {
+  const definitions = createLlmCommands(options);
+  const replace = options.replace ?? false;
+  return { name: "llm-commands", setup(host) {
+    if (!replace && host.commands.has("llm"))
+      throw new Error("Command already registered: llm");
+    for (const definition of definitions)
+      host.commands.register(definition, { replace });
+  } };
+}
+
+export {
+  createLlmConfiguration,
+  validateLlmTemplateParameters,
+  evaluateLlmTemplate,
+  createLlmTemplateStore,
+  parseLlmSchemaDsl,
+  createLlmCommand,
+  createLlmCommands,
+  llmCommands
+};