@poe-platform/safe-bash 0.1.817 → 0.1.819

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

@@ -0,0 +1,3820 @@
+import {
+  pythonRepr
+} from "./chunk-MCUDSE4H.js";
+import {
+  createLlmConfiguration,
+  embeddingCommand,
+  publishConfiguration
+} from "./chunk-WOT2YXBT.js";
+import {
+  createLlmSpool,
+  fileSource,
+  isPythonWhitespace,
+  stripPythonWhitespace
+} from "./chunk-BZLLQWRK.js";
+import {
+  createLlmService,
+  validateModelOptions
+} from "./chunk-YNFQ5AXM.js";
+import {
+  validateJsonData
+} from "./chunk-3PO534WJ.js";
+import {
+  attachmentBytesId,
+  getLlmAttachmentUrlId
+} from "./chunk-B74LVFAN.js";
+import {
+  tokenInteger
+} from "./chunk-GDH7OVYK.js";
+import {
+  resolveUrlAttachment,
+  validateAttachmentUrl
+} from "./chunk-B6NAEWHC.js";
+import {
+  referenceJson
+} from "./chunk-E47FFS5M.js";
+import {
+  sourceBytes,
+  waitForSource
+} from "./chunk-QX3WKBLI.js";
+import {
+  jsonValue
+} from "./chunk-GNPPPYDF.js";
+import {
+  acceptsMimeType,
+  sniffMimeType
+} from "./chunk-VMA3NJXU.js";
+
+// packages/safe-bash-command-llm/src/plugins-command.ts
+var usage = "Usage: llm plugins [OPTIONS]\n";
+var help = usage + "\n  List installed plugins\n\nOptions:\n  --all        Include built-in default plugins\n  --hook TEXT  Filter for plugins that implement this hook\n  -h, --help   Show this message and exit.\n";
+async function pluginsCommand(args, output, diagnostic, step, signal, load) {
+  const error = async (message, withUsage = false) => {
+    await diagnostic((withUsage ? usage + "Try 'llm plugins -h' for help.\n\n" : "") + "Error: " + message + "\n");
+    return 2;
+  };
+  const hooks = [], extra = [];
+  let all = false, showHelp = false, ended = false;
+  for (let index = 0; index < args.length; index++) {
+    await step();
+    const token = args[index];
+    if (ended || !token.startsWith("-") || token === "-") {
+      extra.push(token);
+      continue;
+    }
+    if (token === "--") {
+      ended = true;
+      continue;
+    }
+    const equals = token.indexOf("="), flag = equals < 0 ? token : token.slice(0, equals);
+    if (flag === "--all" || flag === "--help") {
+      if (equals >= 0) return error(`Option '${flag}' does not take a value.`);
+      if (flag === "--all") all = true;
+      else showHelp = true;
+    } else if (flag === "--hook") {
+      if (equals < 0 && args[++index] === void 0) return error("Option '--hook' requires an argument.");
+      hooks.push(equals < 0 ? args[index] : token.slice(equals + 1));
+    } else if (!token.startsWith("--")) {
+      for (const letter of token.slice(1)) {
+        if (letter !== "h") return error(`No such option: -${letter}`, true);
+        showHelp = true;
+      }
+    } else return error(`No such option: ${flag}`, true);
+  }
+  if (showHelp) {
+    await output(help);
+    return 0;
+  }
+  if (extra.length) return error(`Got unexpected extra argument${extra.length === 1 ? "" : "s"} (${extra.join(" ")})`, true);
+  if (!load) {
+    await diagnostic("Error: Python plugin discovery is not configured\n");
+    return 1;
+  }
+  const plugins = await load({ all, hooks });
+  for await (const bytes of referenceJson(plugins, signal, true)) {
+    await step();
+    await output(new TextDecoder().decode(bytes));
+  }
+  await output("\n");
+  return 0;
+}
+
+// packages/safe-bash-command-llm/src/chat-help.ts
+var chatHelp = "Usage: llm chat [OPTIONS]\n\n  Hold an ongoing chat with a model.\n\nOptions:\n  -s, --system TEXT             System prompt to use\n  -m, --model TEXT              Model to use\n  -f, --fragment TEXT           Fragment (alias, URL, hash or file path) to\n                                add to the prompt\n  --sf, --system-fragment TEXT  Fragment to add to system prompt\n  -t, --template TEXT           Template to use\n  -p, --param <TEXT TEXT>...    Parameters for template\n  -o, --option <TEXT TEXT>...   key/value options for the model\n  --no-stream                   Do not stream output\n  --key TEXT                    API key to use\n  -T, --tool TEXT               Name of a tool to make available to the model\n  --functions TEXT              Python code block or file path defining\n                                functions to register as tools\n  --td, --tools-debug           Show full details of tool executions\n  --ta, --tools-approve         Manually approve every tool execution\n  --cl, --chain-limit INTEGER   How many chained tool responses to allow,\n                                default 5, set 0 for unlimited\n  -h, --help                    Show this message and exit.\n";
+
+// packages/safe-bash-command-llm/src/chat-editor.ts
+import { FsError } from "../../safe-bash-contracts/index.js";
+var serial = 0;
+async function editChatPrompt(options) {
+  const { context, operation } = options, { fs, signal } = context;
+  if (!context.invoke) throw new Error("Chat editor is not configured");
+  if (!fs.createStagedFile || !fs.removeFileConditional) throw new FsError("ENOTSUP", { message: "Chat editing requires caller staging and conditional cleanup" });
+  const parent = await fs.stat(context.cwd, { signal });
+  let staging;
+  for (let attempt = 0; attempt < 16; attempt++) {
+    try {
+      staging = await operation.acquire(() => fs.createStagedFile(
+        `${context.cwd === "/" ? "" : context.cwd}/.llm-edit-${++serial}`,
+        "prompt.txt",
+        { type: "file", data: new Uint8Array(0) },
+        { parent, mode: 384, retainCleanup: true, signal }
+      ), async (value) => {
+        try {
+          await value.cleanup?.remove();
+        } finally {
+          await value.cleanup?.close();
+        }
+      });
+      break;
+    } catch (error) {
+      signal.throwIfAborted();
+      if (!(error instanceof FsError) || error.code !== "EEXIST") throw error;
+    }
+  }
+  if (!staging?.writer || !staging.cleanup) throw new FsError("ENOTSUP", { message: "Chat editor staging needs retained handles" });
+  const owned = staging;
+  const initial = await owned.writer.finish({ signal });
+  const path = owned.file.path;
+  let expected = initial, failed = false;
+  const cleanup = async () => {
+    try {
+      expected = await fs.lstat(path);
+    } catch (error) {
+      if (error instanceof FsError && error.code === "ENOENT") return;
+      throw error;
+    }
+    await fs.removeFileConditional(path, { parent: owned.directory.stat, expected });
+  };
+  try {
+    const editor = context.env.VISUAL || context.env.EDITOR || "vi";
+    const result = await context.invoke("sh", ["-c", editor + ' "$1"', "llm-chat-editor", path], {
+      signal,
+      cwd: context.cwd,
+      env: context.env,
+      replaceEnv: true,
+      stdin: context.stdin,
+      stdout: context.stdout,
+      stderr: context.stderr,
+      externalInvocation: true
+    });
+    signal.throwIfAborted();
+    if (result.exitCode !== 0) throw new Error("Editing failed!");
+    expected = await fs.lstat(path, { signal });
+    if (expected.type !== "file") throw new FsError("EINVAL", { path });
+    if (expected.mtimeMs === initial.mtimeMs) return void 0;
+    const source = await operation.acquire(() => fileSource({ fs, path, signal, expectedStat: expected }), (value) => value.dispose());
+    const raw = await operation.acquire(() => createLlmSpool(fs, context.cwd, signal, "input"), (value) => value.close());
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }), encoder = new TextEncoder();
+    let offset = 0, start = -1, end = 0;
+    const inspect = (text) => {
+      for (const char of text) {
+        const size = encoder.encode(char).length;
+        if (!isPythonWhitespace(char)) {
+          if (start < 0) start = offset;
+          end = offset + size;
+        }
+        offset += size;
+      }
+    };
+    try {
+      for await (const bytes of source.bytes) {
+        options.admit(bytes.length, false);
+        await raw.write(bytes);
+        inspect(decoder.decode(bytes, { stream: true }));
+      }
+      inspect(decoder.decode());
+    } finally {
+      await source.dispose();
+    }
+    const trimmed = await operation.acquire(() => createLlmSpool(fs, context.cwd, signal, "input"), (value) => value.close());
+    try {
+      if (start >= 0) for await (const bytes of raw.replay(async () => ({ start, end }))) await trimmed.write(bytes);
+    } finally {
+      await raw.close();
+    }
+    return trimmed;
+  } catch (error) {
+    failed = true;
+    throw error;
+  } finally {
+    await cleanup().catch((error) => {
+      if (!failed) throw error;
+    });
+  }
+}
+
+// packages/safe-bash-command-llm/src/chat-input.ts
+import { yieldTurn } from "../../safe-bash-contracts/yield.js";
+function createChatInput(options) {
+  const { context, operation } = options, { signal } = context;
+  let iterator, pending = new Uint8Array(0), position = 0, ended = false;
+  let multi, multiSize = 0, endToken = "!end", iterations = 0;
+  const create = () => operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal, "input"), (spool) => spool.close());
+  const chunk = async () => {
+    while (position === pending.length) {
+      if (ended) return { done: true, value: void 0 };
+      iterator ??= await operation.acquire(() => context.stdinInput ? { next: () => context.stdinInput.readAvailable ? context.stdinInput.readAvailable(4096, signal, 10) : context.stdinInput.read(1, signal) } : context.stdin[Symbol.asyncIterator](), async (input) => {
+        await input.return?.();
+      });
+      const next = await waitForSource(() => iterator.next(), signal);
+      if (next.done) {
+        ended = true;
+        continue;
+      }
+      if (!(next.value instanceof Uint8Array)) throw new TypeError("Byte sources must yield Uint8Array chunks");
+      options.admit(next.value.length, false);
+      pending = next.value;
+      position = 0;
+      await yieldTurn(signal);
+    }
+    const start = position;
+    while (position < pending.length && position - start < 4096) {
+      const byte = pending[position++];
+      if (byte === 10) break;
+    }
+    return { done: false, value: pending.subarray(start, position) };
+  };
+  const inspect = async (spool) => {
+    let probe = "", whitespace2 = "", overflow = false;
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    const accept = (text) => {
+      for (const char of text) {
+        if (isPythonWhitespace(char)) {
+          if (probe && whitespace2.length <= 4096) whitespace2 += char;
+        } else {
+          if (probe.length + whitespace2.length + char.length > 4096) overflow = true;
+          if (!overflow) probe += whitespace2 + char;
+          whitespace2 = "";
+        }
+      }
+    };
+    for await (const bytes of spool.replay()) {
+      accept(decoder.decode(bytes, { stream: true }));
+      await yieldTurn(signal);
+    }
+    accept(decoder.decode());
+    return { probe, exact: !overflow };
+  };
+  const line = async () => {
+    const spool = await create();
+    let size = 0, seen = false;
+    while (true) {
+      const next = await chunk();
+      if (next.done) return seen ? { spool, size } : (await spool.close(), void 0);
+      let bytes = next.value;
+      if (!bytes.length) continue;
+      seen = true;
+      const last = bytes[bytes.length - 1];
+      const newline = last === 10;
+      if (newline) bytes = bytes.subarray(0, -1);
+      await spool.write(bytes);
+      size += bytes.length;
+      if (newline) return { spool, size };
+    }
+  };
+  const control = async (spool) => {
+    let value = "";
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    for await (const bytes of spool.replay()) {
+      options.admit(bytes.length, true);
+      value += decoder.decode(bytes, { stream: true });
+    }
+    return value + decoder.decode();
+  };
+  const words = (value) => {
+    const result = [];
+    let word = "";
+    for (const char of value) {
+      if (isPythonWhitespace(char)) {
+        if (word) result.push(word);
+        word = "";
+      } else word += char;
+    }
+    if (word) result.push(word);
+    return result;
+  };
+  return {
+    approvalInput: () => ({ next: chunk }),
+    async next() {
+      while (true) {
+        await options.write(multi ? " " : "> ");
+        const value = await line();
+        if (!value) throw new Error("Aborted!");
+        if (!value.size) {
+          await value.spool.close();
+          continue;
+        }
+        let includeInitialFragments = iterations++ === 0;
+        let inspected = await inspect(value.spool);
+        if (inspected.probe.startsWith("!multi")) {
+          const bits = words(stripPythonWhitespace(await control(value.spool)));
+          if (bits.length > 1) endToken = "!end " + bits.slice(1).join(" ");
+          multi ??= await create();
+          await value.spool.close();
+          continue;
+        }
+        if (inspected.exact && inspected.probe === "!edit") {
+          await value.spool.close();
+          const edited = await editChatPrompt({ ...options, context: { ...context, stdin: { async *[Symbol.asyncIterator]() {
+            while (true) {
+              const next = await chunk();
+              if (next.done) return;
+              yield next.value;
+            }
+          } } } });
+          if (!edited) {
+            await options.diagnostic("Editor closed without saving.\n");
+            continue;
+          }
+          value.spool = edited;
+          value.size = 0;
+          for await (const bytes of edited.replay()) value.size += bytes.length;
+          inspected = await inspect(edited);
+        }
+        const fragments = [];
+        if (inspected.probe.startsWith("!fragment ")) {
+          includeInitialFragments = false;
+          const text = await control(value.spool);
+          const lines = [];
+          let start = 0;
+          for (let index = 0; index < text.length; index++) {
+            if (!["\n", "\r", "\v", "\f", "", "", "", "\x85", "\u2028", "\u2029"].includes(text[index])) continue;
+            lines.push(text.slice(start, index));
+            if (text[index] === "\r" && text[index + 1] === "\n") index++;
+            start = index + 1;
+          }
+          if (start < text.length) lines.push(text.slice(start));
+          const promptLines = [];
+          for (const line2 of lines) {
+            if (line2.startsWith("!fragment ")) fragments.push(...words(stripPythonWhitespace(line2).slice(10)));
+            else promptLines.push(line2);
+          }
+          await value.spool.close();
+          value.spool = await create();
+          const bytes = new TextEncoder().encode(promptLines.join("\n"));
+          await value.spool.write(bytes);
+          value.size = bytes.length;
+        }
+        if (fragments.length) await options.resolveFragments(fragments);
+        if (multi) {
+          if (stripPythonWhitespace(inspected.exact ? inspected.probe : inspected.probe.startsWith("!end") ? await control(value.spool) : "") === endToken) {
+            await value.spool.close();
+            value.spool = multi;
+            multi = void 0;
+            multiSize = 0;
+          } else {
+            if (value.size) {
+              if (multiSize) {
+                await multi.write(Uint8Array.of(10));
+                multiSize++;
+                options.admit(1, false);
+              }
+              for await (const bytes of value.spool.replay()) await multi.write(bytes);
+              multiSize += value.size;
+            }
+            await value.spool.close();
+            continue;
+          }
+        }
+        const final = await inspect(value.spool);
+        return { spool: value.spool, includeInitialFragments, exit: final.exact && (final.probe === "exit" || final.probe === "quit") };
+      }
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/src/prompt-tool-chain.ts
+import { yieldTurn as yieldTurn4 } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-llm/src/tool-chain.ts
+import { shellValueByteLength } from "../../safe-bash-contracts/index.js";
+import { inheritYieldCheckpoint as inheritYieldCheckpoint2, yieldTurn as yieldTurn3 } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-llm/src/tool-execution.ts
+import { inheritYieldCheckpoint, yieldTurn as yieldTurn2 } from "../../safe-bash-contracts/yield.js";
+var LlmCancelToolCall = class extends Error {
+};
+async function* outputBytes(output, signal) {
+  if (typeof output !== "string") {
+    yield* referenceJson(output, signal);
+    return;
+  }
+  const encoder = new TextEncoder();
+  for (let offset = 0; offset < output.length; ) {
+    signal.throwIfAborted();
+    let end = Math.min(output.length, offset + 4096);
+    const last = output.charCodeAt(end - 1);
+    if (end < output.length && last >= 55296 && last <= 56319) end--;
+    yield encoder.encode(output.slice(offset, end));
+    offset = end;
+  }
+}
+async function executeLlmToolCalls(options, visit) {
+  const limit = options.maxOutputBytes ?? Infinity;
+  if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0))
+    throw new RangeError("Invalid tool output byte limit");
+  const controller = new AbortController();
+  const signal = options.async ? AbortSignal.any([options.context.signal, controller.signal]) : options.context.signal;
+  inheritYieldCheckpoint(options.context.signal, signal);
+  const tools = new Map(options.tools.map((tool) => [tool.name, tool]));
+  let size = 0;
+  const context = {
+    ...options.context,
+    signal,
+    get maxBytes() {
+      return limit - size;
+    }
+  };
+  const execute2 = async (call, index) => {
+    const tool = tools.get(call.name);
+    let closed = false, failed2 = false, cleanup;
+    const resources = /* @__PURE__ */ new Map();
+    const own = (source) => {
+      const existing = resources.get(source);
+      if (existing) return existing.lease;
+      let disposal, read = false;
+      const dispose = () => disposal ??= Promise.resolve().then(() => source.dispose());
+      const lease = {
+        dispose,
+        bytes: {
+          async *[Symbol.asyncIterator]() {
+            if (closed || disposal || read)
+              throw new Error("Tool result lease is closed or already consumed");
+            read = true;
+            let steps = 0;
+            for await (const bytes of sourceBytes(source.bytes, signal)) {
+              if (++steps % 256 === 0) await yieldTurn2(signal);
+              if (closed || disposal) throw new Error("Tool result lease is closed");
+              if (bytes.length > limit - size)
+                throw new RangeError("Tool output byte limit exceeded");
+              size += bytes.length;
+              for (let offset = 0; offset < bytes.length; offset += 16384) {
+                if (++steps % 256 === 0) await yieldTurn2(signal);
+                signal.throwIfAborted();
+                if (closed || disposal) throw new Error("Tool result lease is closed");
+                yield Uint8Array.from(bytes.subarray(offset, offset + 16384));
+              }
+            }
+          }
+        }
+      };
+      resources.set(source, { lease, dispose });
+      if (closed) void dispose().catch(() => void 0);
+      return lease;
+    };
+    const close = () => {
+      closed = true;
+      return cleanup ??= Promise.allSettled(
+        Array.from(resources.values(), (resource) => resource.dispose())
+      ).then((results) => {
+        const rejected = results.find((result) => result.status === "rejected");
+        if (rejected?.status === "rejected") throw rejected.reason;
+      });
+    };
+    const abort = () => {
+      void close().catch(() => void 0);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+      signal.throwIfAborted();
+      let exception, output, executed = false;
+      try {
+        await waitForSource(
+          () => Promise.resolve(options.beforeCall?.(tool, call, context)),
+          signal
+        );
+      } catch (error) {
+        signal.throwIfAborted();
+        if (!(error instanceof LlmCancelToolCall)) throw error;
+        exception = error;
+        output = { output: "Cancelled: " + error.message };
+      }
+      if (!output && !tool) {
+        const error = new Error(`tool "${call.name}" does not exist`);
+        exception = error;
+        output = { output: "Error: " + error.message };
+      }
+      if (!output) {
+        if (!tool.implementation)
+          throw new Error(`No implementation available for tool: ${call.name}`);
+        executed = true;
+        try {
+          if (!call.arguments || typeof call.arguments !== "object" || Array.isArray(call.arguments))
+            throw new TypeError("Tool arguments must be a JSON object");
+          validateJsonData(call.arguments, "Tool arguments must be finite JSON data");
+          const pending2 = Promise.resolve().then(() => {
+            signal.throwIfAborted();
+            return tool.implementation(
+              call.arguments,
+              context
+            );
+          }).then((value) => {
+            if (value?.source) own(value.source);
+            if (Array.isArray(value?.attachments)) {
+              for (const attachment of value.attachments)
+                if (attachment?.source) own(attachment.source);
+            }
+            return value;
+          });
+          output = await waitForSource(() => pending2, signal);
+          if (!output || typeof output !== "object" || "source" in output === "output" in output)
+            throw new TypeError("Invalid tool output");
+          if ("output" in output)
+            validateJsonData(output.output, "Tool output must be finite JSON data");
+          if ("source" in output && (!output.source || typeof output.source.dispose !== "function" || typeof output.source.bytes?.[Symbol.asyncIterator] !== "function"))
+            throw new TypeError("Invalid tool output source");
+        } catch (error) {
+          signal.throwIfAborted();
+          exception = error;
+          output = { output: "Error: " + (error instanceof Error ? error.message : String(error)) };
+        }
+      }
+      const attachments = [];
+      if (output.attachments !== void 0 && !Array.isArray(output.attachments))
+        throw new TypeError("Invalid tool attachments");
+      for (const attachment of output.attachments ?? []) {
+        if (!attachment || typeof attachment.mimeType !== "string" || !attachment.mimeType || attachment.id !== void 0 && typeof attachment.id !== "string")
+          throw new TypeError("Invalid tool attachment");
+        if (attachment.url !== void 0) {
+          if (attachment.source !== void 0) throw new TypeError("Invalid tool attachment");
+          validateAttachmentUrl(attachment.url);
+          attachments.push(attachment);
+        } else {
+          if (!attachment.source || typeof attachment.source.dispose !== "function" || typeof attachment.source.bytes?.[Symbol.asyncIterator] !== "function")
+            throw new TypeError("Invalid tool attachment source");
+          attachments.push({ ...attachment, source: own(attachment.source) });
+        }
+      }
+      const source = output.source ?? {
+        bytes: outputBytes(output.output, signal),
+        async dispose() {
+        }
+      };
+      await waitForSource(
+        () => Promise.resolve(
+          visit({
+            call,
+            output: own(source),
+            attachments,
+            executed,
+            ...exception === void 0 ? {} : { exception }
+          }, index)
+        ),
+        signal
+      );
+    } catch (error) {
+      failed2 = true;
+      throw signal.aborted ? signal.reason : error;
+    } finally {
+      signal.removeEventListener("abort", abort);
+      await close().catch((error) => {
+        if (!failed2 && !signal.aborted) throw error;
+      });
+    }
+  };
+  const pending = [];
+  let failure, failed = false;
+  const fail = (error) => {
+    if (!failed) {
+      failed = true;
+      failure = error;
+      controller.abort(error);
+    }
+  };
+  try {
+    const preparations = new Set([...tools.values()].map((tool) => tool.prepare).filter((prepare) => prepare !== void 0));
+    for (const prepare of preparations) {
+      await waitForSource(async () => prepare(context, { async: options.async ?? false }), signal);
+    }
+    for (let index = 0; index < options.calls.length; index++) {
+      await yieldTurn2(signal);
+      const call = options.calls[index];
+      const tool = tools.get(call.name);
+      if (options.async && !tool?.implementation) continue;
+      if (options.async && tool?.async) {
+        pending.push(execute2(call, index).catch(fail));
+      } else await execute2(call, index);
+    }
+  } catch (error) {
+    fail(error);
+  }
+  await Promise.all(pending);
+  if (failed) throw failure;
+  signal.throwIfAborted();
+}
+
+// packages/safe-bash-command-llm/src/tool-chain.ts
+async function* streamLlmToolChain(options) {
+  const chainLimit = options.chainLimit === void 0 ? 10 : options.chainLimit;
+  if (chainLimit !== null && typeof chainLimit !== "bigint" && !Number.isSafeInteger(chainLimit)) throw new RangeError("Invalid chain limit");
+  const outputLimit = options.maxOutputBytes ?? Infinity;
+  const toolLimit = options.maxToolOutputBytes ?? Infinity;
+  for (const limit of [outputLimit, toolLimit])
+    if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid chain byte limit");
+  const controller = new AbortController();
+  const signal = AbortSignal.any([options.context.signal, controller.signal]);
+  inheritYieldCheckpoint2(options.context.signal, signal);
+  let outputBytes2 = 0, toolBytes = 0;
+  const admit = (size) => {
+    if (size > outputLimit - outputBytes2) throw new RangeError("LLM chain output byte limit exceeded");
+    outputBytes2 += size;
+  };
+  const counted = (source) => ({
+    dispose: () => source.dispose(),
+    bytes: { async *[Symbol.asyncIterator]() {
+      for await (const bytes of source.bytes) {
+        toolBytes += bytes.length;
+        yield bytes;
+      }
+    } }
+  });
+  try {
+    for (let index = 0; ; index++) {
+      await yieldTurn3(signal);
+      const iterator = options.openResponse(index, signal)[Symbol.asyncIterator]();
+      let ended = false;
+      let events = 0;
+      let response;
+      try {
+        while (true) {
+          if (++events % 256 === 0) await yieldTurn3(signal);
+          const next = await waitForSource(() => iterator.next(), signal);
+          if (next.done) {
+            ended = true;
+            break;
+          }
+          const event = next.value;
+          if (response) throw new Error("LLM response event must be final");
+          if (event.type === "response") {
+            response = event;
+            if (event.response.toolCalls) for await (const bytes of jsonValue(event.response.toolCalls, signal)) admit(bytes.length);
+            yield event;
+          } else if (event.type === "text") {
+            for (let offset = 0; offset < event.text.length; ) {
+              await yieldTurn3(signal);
+              let end = Math.min(event.text.length, offset + 4096);
+              const last = event.text.charCodeAt(end - 1);
+              if (end < event.text.length && last >= 55296 && last <= 56319) end--;
+              const text = event.text.slice(offset, end);
+              admit(shellValueByteLength(text));
+              yield { type: "text", text };
+              offset = end;
+            }
+          } else if (event.type === "bytes") {
+            for (let offset = 0; offset < event.data.length; offset += 16384) {
+              await yieldTurn3(signal);
+              const bytes = event.data.subarray(offset, offset + 16384);
+              admit(bytes.length);
+              yield { type: "bytes", data: Uint8Array.from(bytes) };
+            }
+          } else throw new TypeError("Invalid LLM stream event");
+        }
+      } finally {
+        if (!ended) {
+          controller.abort(new Error("LLM chain response closed"));
+          void Promise.resolve().then(() => iterator.return?.()).catch(() => void 0);
+        }
+      }
+      signal.throwIfAborted();
+      if (!response) throw new Error("LLM stream ended without response metadata");
+      if (chainLimit && index + 1 >= chainLimit) throw new Error(`Chain limit of ${chainLimit} exceeded.`);
+      const calls = response.response.toolCalls ?? [];
+      let visited = false;
+      await executeLlmToolCalls({
+        ...options.async === void 0 ? {} : { async: options.async },
+        tools: options.tools,
+        calls,
+        context: { ...options.context, signal },
+        maxOutputBytes: toolLimit - toolBytes,
+        ...options.beforeCall ? { beforeCall: options.beforeCall } : {}
+      }, (result, callIndex) => {
+        visited = true;
+        return options.visit({
+          ...result,
+          output: counted(result.output),
+          attachments: result.attachments.map((attachment) => attachment.source ? { ...attachment, source: counted(attachment.source) } : attachment)
+        }, callIndex);
+      });
+      if (!visited) return;
+    }
+  } finally {
+    controller.abort(new Error("LLM chain closed"));
+  }
+}
+
+// packages/safe-bash-command-llm/src/prompt-tool-chain.ts
+async function* promptToolChain(options) {
+  const { context, operation, request, service, tools, streamed, textSource } = options;
+  const signal = request.signal;
+  const create = () => operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal, "input"), (spool) => spool.close());
+  const retain = async (source, admit, text) => {
+    const spool = await create();
+    let size = 0;
+    const decoder = text ? new TextDecoder("utf-8", { fatal: true }) : void 0;
+    try {
+      for await (const bytes of sourceBytes(source.bytes, signal)) {
+        if (admit) options.admitInput(bytes.length, !streamed);
+        decoder?.decode(bytes, { stream: true });
+        await spool.write(bytes);
+        size += bytes.length;
+      }
+      decoder?.decode();
+      return { spool, size };
+    } finally {
+      await source.dispose();
+    }
+  };
+  const retainAttachments = async (attachments, admit) => {
+    const result = [];
+    for (const attachment of attachments) {
+      const identity = { mimeType: attachment.mimeType, ...attachment.id === void 0 ? {} : { id: attachment.id } };
+      if (admit) {
+        for await (const bytes of jsonValue({ ...identity, ...attachment.url === void 0 ? {} : { url: attachment.url } }, signal)) options.admitInput(bytes.length, true);
+      }
+      result.push(attachment.source ? { ...identity, content: await retain(attachment.source, admit, false) } : { ...identity, url: attachment.url });
+    }
+    return result;
+  };
+  const lease = (content, activeSignal) => operation.acquire(() => content.spool.lease(activeSignal), (source) => source.dispose());
+  const sourceAttachments = (attachments, activeSignal) => Promise.all(attachments.map(async (attachment) => attachment.content ? { mimeType: attachment.mimeType, ...attachment.id === void 0 ? {} : { id: attachment.id }, source: await lease(attachment.content, activeSignal) } : { mimeType: attachment.mimeType, ...attachment.id === void 0 ? {} : { id: attachment.id }, url: attachment.url }));
+  const sameContent = async (left, right) => {
+    if (left.size !== right.size) return false;
+    const first = await lease(left, signal), second = await lease(right, signal);
+    const iterator = sourceBytes(second.bytes, signal)[Symbol.asyncIterator]();
+    let pending = new Uint8Array(0), offset = 0;
+    try {
+      for await (const bytes of sourceBytes(first.bytes, signal)) {
+        await yieldTurn4(signal);
+        for (const byte of bytes) {
+          while (offset === pending.length) {
+            const next = await iterator.next();
+            if (next.done) return false;
+            pending = next.value;
+            offset = 0;
+          }
+          if (byte !== pending[offset++]) return false;
+        }
+      }
+      return true;
+    } finally {
+      try {
+        await iterator.return?.();
+      } finally {
+        await Promise.all([first.dispose(), second.dispose()]);
+      }
+    }
+  };
+  const materialize = async (content) => {
+    let value = "";
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+    const source = await lease(content, signal);
+    try {
+      for await (const bytes of source.bytes) value += decoder.decode(bytes, { stream: true });
+    } finally {
+      await source.dispose();
+    }
+    return value + decoder.decode();
+  };
+  const bufferedAttachments = async (attachments) => Promise.all(attachments.map(async (attachment) => {
+    const identity = { mimeType: attachment.mimeType, ...attachment.id === void 0 ? {} : { id: attachment.id } };
+    if (!attachment.content) return { ...identity, url: attachment.url };
+    const bytes = new Uint8Array(attachment.content.size);
+    let offset = 0;
+    for await (const chunk of attachment.content.spool.replay()) {
+      bytes.set(chunk, offset);
+      offset += chunk.length;
+    }
+    return { ...identity, bytes };
+  }));
+  const declarations = tools.map(({ name, description, inputSchema }) => ({ name, ...description === void 0 ? {} : { description }, inputSchema }));
+  for await (const bytes of jsonValue(declarations, signal)) options.admitInput(bytes.length, true);
+  const prompt = await retain(request.prompt, false, true);
+  const system = request.system === void 0 ? void 0 : await retain(request.system, false, true);
+  const initialAttachments = await retainAttachments(request.attachments, false);
+  const empty = await retain(textSource(""), false, true);
+  const messages = options.chatMessages ?? [];
+  let currentPrompt = prompt, currentAttachments = initialAttachments, currentSystem = system;
+  if (options.chatMessages) {
+    if (!system?.size) currentSystem = void 0;
+    else if (messages.length) {
+      let previous;
+      for (let index = messages.length - 1; index >= 0; index--) {
+        if (messages[index].role === "system") {
+          previous = messages[index];
+          break;
+        }
+      }
+      if (!previous || !await sameContent(previous.content, system)) messages.push({ role: "system", content: system });
+      currentSystem = void 0;
+    }
+  }
+  let responseContent, responseCalls = [], prepared = false;
+  let nextAttachments = [];
+  const pendingResults = /* @__PURE__ */ new Map();
+  let approvals = Promise.resolve(), diagnostics = Promise.resolve();
+  yield* streamLlmToolChain({
+    context: { ...context, signal },
+    tools,
+    chainLimit: options.chainLimit,
+    ...request.async ? { async: true } : {},
+    maxOutputBytes: options.maxOutputBytes,
+    maxToolOutputBytes: options.remainingInput(),
+    openResponse(index, activeSignal) {
+      return (async function* () {
+        if (index) {
+          for (let callIndex = 0; callIndex < responseCalls.length; callIndex++) {
+            const result = pendingResults.get(callIndex);
+            if (result) {
+              messages.push(result.message);
+              nextAttachments.push(...result.attachments);
+            }
+          }
+          pendingResults.clear();
+          currentPrompt = empty;
+          currentSystem = void 0;
+          currentAttachments = nextAttachments;
+          nextAttachments = [];
+        }
+        prepared = false;
+        const base = {
+          ...request.async ? { async: true } : {},
+          maxOutputBytes: options.maxOutputBytes,
+          ...request.model === void 0 ? {} : { model: request.model },
+          options: request.options,
+          signal: activeSignal,
+          stream: request.stream,
+          ...request.key === void 0 ? {} : { key: request.key },
+          tools: declarations,
+          ...!index && request.schema !== void 0 ? { schema: request.schema } : {}
+        };
+        const events = streamed ? service.streamSources({
+          ...base,
+          prompt: await lease(currentPrompt, activeSignal),
+          ...currentSystem ? { system: await lease(currentSystem, activeSignal) } : {},
+          attachments: await sourceAttachments(currentAttachments, activeSignal),
+          messages: await Promise.all(messages.map(async (message) => ({ ...message, content: await lease(message.content, activeSignal) })))
+        }) : service.stream({
+          ...base,
+          prompt: await materialize(currentPrompt),
+          ...currentSystem ? { system: await materialize(currentSystem) } : {},
+          attachments: await bufferedAttachments(currentAttachments),
+          messages: await Promise.all(messages.map(async (message) => ({ ...message, content: await materialize(message.content) })))
+        });
+        responseContent = { spool: await create(), size: 0 };
+        let surrogate = "";
+        const append = async (text) => {
+          for await (const bytes of textSource(text).bytes) {
+            await responseContent.spool.write(bytes);
+            responseContent.size += bytes.length;
+          }
+        };
+        for await (const event of events) {
+          if (event.type === "text") {
+            let text = surrogate + event.text;
+            const last = text.charCodeAt(text.length - 1);
+            surrogate = last >= 55296 && last <= 56319 ? text.slice(-1) : "";
+            if (surrogate) text = text.slice(0, -1);
+            await append(text);
+          } else if (event.type === "bytes") {
+            await responseContent.spool.write(event.data);
+            responseContent.size += event.data.length;
+          } else {
+            if (surrogate) await append(surrogate);
+            responseCalls = event.response.toolCalls ?? [];
+          }
+          yield event;
+        }
+      })();
+    },
+    beforeCall(tool, call, context2) {
+      const approval = approvals.then(async () => {
+        context2.signal.throwIfAborted();
+        if (!prepared) {
+          prepared = true;
+          options.admitInput(responseContent.size, !streamed);
+          for await (const bytes of jsonValue(responseCalls, signal)) options.admitInput(bytes.length, true);
+          if (currentSystem?.size) messages.push({ role: "system", content: currentSystem });
+          if (currentPrompt.size) messages.push({ role: "user", content: currentPrompt });
+          if (responseContent.size) messages.push({ role: "assistant", content: responseContent });
+          messages.push({ role: "assistant", content: empty, toolCalls: responseCalls });
+        }
+        await options.beforeCall?.(tool, call, context2);
+      });
+      approvals = approval.then(() => {
+      }, () => {
+      });
+      return approval;
+    },
+    async visit(result, callIndex) {
+      const content = await retain(result.output, true, true);
+      const attachments = await retainAttachments(result.attachments, true);
+      pendingResults.set(callIndex, { message: { role: "tool", ...result.call.id === void 0 ? {} : { toolCallId: result.call.id }, content }, attachments });
+      if (options.debugWrite) {
+        const write = options.debugWrite;
+        diagnostics = diagnostics.then(async () => {
+          signal.throwIfAborted();
+          const { debugToolResult } = await import("./prompt-tool-debug-ERJKK3XZ.js");
+          await debugToolResult({ context: { ...context, signal }, result, output: content.spool, attachments, write });
+        });
+        await diagnostics;
+      }
+    }
+  });
+  if (options.chatMessages && responseContent && !prepared) {
+    options.admitInput(responseContent.size, !streamed);
+    if (currentSystem?.size) messages.push({ role: "system", content: currentSystem });
+    if (currentPrompt.size) messages.push({ role: "user", content: currentPrompt });
+    if (responseContent.size) messages.push({ role: "assistant", content: responseContent });
+  }
+}
+
+// packages/safe-bash-command-llm/src/prompt-tool-approval.ts
+import { pipeBytes } from "../../safe-bash-contracts/index.js";
+import { writeDiagnostic } from "../../safe-bash-contracts/escaping.js";
+import { yieldTurn as yieldTurn5 } from "../../safe-bash-contracts/yield.js";
+function createToolApproval(options) {
+  const { context, write, admitInput } = options, { signal } = context;
+  const encoder = new TextEncoder();
+  let iterator, pending = new Uint8Array(0), position = 0, ended = false, skipLineFeed = false;
+  const answer = async () => {
+    const decoder = new TextDecoder("utf-8", { fatal: true });
+    let value = "", seen = false, trailing = false, invalid = false, steps = 0;
+    const accept = (text) => {
+      for (const char of text) {
+        if (isPythonWhitespace(char)) {
+          if (value) trailing = true;
+        } else if (trailing || value.length >= 3) invalid = true;
+        else value += char.toLowerCase();
+      }
+    };
+    while (true) {
+      if (++steps % 256 === 0) await yieldTurn5(signal);
+      signal.throwIfAborted();
+      if (position === pending.length) {
+        if (ended) {
+          accept(decoder.decode());
+          return seen ? invalid ? "invalid" : value : void 0;
+        }
+        iterator ??= await options.openInput();
+        const next = await waitForSource(() => iterator.next(), signal);
+        if (next.done) {
+          ended = true;
+          continue;
+        }
+        if (!(next.value instanceof Uint8Array)) throw new TypeError("Byte sources must yield Uint8Array chunks");
+        admitInput(next.value.length);
+        pending = next.value;
+        position = 0;
+        continue;
+      }
+      if (skipLineFeed) {
+        skipLineFeed = false;
+        if (pending[position] === 10) {
+          position++;
+          continue;
+        }
+      }
+      seen = true;
+      const end = Math.min(pending.length, position + 4096);
+      let newline = position;
+      while (newline < end && pending[newline] !== 10 && pending[newline] !== 13) newline++;
+      accept(decoder.decode(pending.subarray(position, newline), { stream: true }));
+      position = newline;
+      if (newline < end) {
+        skipLineFeed = pending[position] === 13;
+        position++;
+        accept(decoder.decode());
+        return invalid ? "invalid" : value;
+      }
+    }
+  };
+  return async (_tool, call) => {
+    await writeDiagnostic(context.stderr, `Tool call: ${call.name}(`, signal);
+    await pipeBytes(pythonRepr(call.arguments, signal), context.stderr, signal);
+    await writeDiagnostic(context.stderr, ")\n", signal);
+    while (true) {
+      await write(encoder.encode("Approve tool call? [y/N]: "));
+      const value = await answer();
+      if (value === void 0) throw new Error("");
+      if (value === "y" || value === "yes") return;
+      if (value === "" || value === "n" || value === "no") throw new LlmCancelToolCall("User cancelled tool call");
+      await write(encoder.encode("Error: invalid input\n"));
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/src/tool-registry.ts
+function createLlmToolRegistry(tools) {
+  const registry = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    if (!tool || typeof tool.name !== "string" || !tool.name || !tool.inputSchema || Array.isArray(tool.inputSchema) || typeof tool.inputSchema !== "object")
+      throw new TypeError("Invalid LLM tool definition");
+    for (const value of [tool.description, tool.plugin, tool.signature, tool.registryKey])
+      if (value !== void 0 && typeof value !== "string")
+        throw new TypeError("Invalid LLM tool metadata");
+    if (tool.implementation !== void 0 && typeof tool.implementation !== "function")
+      throw new TypeError("Invalid LLM tool implementation");
+    if (tool.selectionIndex !== void 0 && (!Number.isSafeInteger(tool.selectionIndex) || tool.selectionIndex < 0))
+      throw new TypeError("Invalid LLM tool selection index");
+    if (tool.prepare !== void 0 && typeof tool.prepare !== "function")
+      throw new TypeError("Invalid LLM tool preparation");
+    if (tool.async !== void 0 && typeof tool.async !== "boolean")
+      throw new TypeError("Invalid LLM tool async declaration");
+    validateJsonData(tool.inputSchema, "Tool schema must be finite JSON data");
+    let name = tool.name, suffix = 0;
+    while (registry.has(name)) name = `${tool.name}_${++suffix}`;
+    registry.set(name, tool);
+  }
+  return registry;
+}
+function selectLlmTools(registry, names) {
+  const missing = names.filter((name) => !registry.has(name));
+  if (missing.length)
+    throw new Error(
+      `Tool(s) ${missing.join(", ")} not found. Available tools: ${[...registry.keys()].join(", ")}`
+    );
+  return names.map((name) => registry.get(name));
+}
+
+// packages/safe-bash-command-llm/src/fragment-loader-command.ts
+async function fragmentLoaderCommand(tokens, loaders, output, diagnostic) {
+  const usage3 = "Usage: llm fragments loaders [OPTIONS]\n";
+  let failure, help2 = false, ended = false;
+  const operands = [];
+  for (const token of tokens) {
+    if (!ended && token === "--") ended = true;
+    else if (!ended && (token === "--help" || token === "-h")) help2 = true;
+    else if (!ended && token.startsWith("-") && token !== "-") {
+      failure = `No such option: ${token.split("=")[0]}`;
+      break;
+    } else operands.push(token);
+  }
+  if (help2 && !failure) {
+    await output(usage3 + "\n  Show fragment loaders registered by plugins\n\nOptions:\n  -h, --help  Show this message and exit.\n");
+    return 0;
+  }
+  failure ??= operands.length ? `Got unexpected extra argument (${operands[0]})` : void 0;
+  if (failure) {
+    await diagnostic(usage3 + "Try 'llm fragments loaders --help' for help.\n\nError: " + failure + "\n");
+    return 2;
+  }
+  let found = false;
+  for (const [prefix, loader] of loaders) {
+    if (found) await output("\n");
+    found = true;
+    await output(`${prefix}:
+`);
+    const lines = (loader.description || "Undocumented").split("\n");
+    let common;
+    for (const line of lines) {
+      if (!line.trim()) continue;
+      let width = 0;
+      while (line[width] === " " || line[width] === "	") width++;
+      const indent = line.slice(0, width);
+      if (common === void 0) common = indent;
+      else {
+        let i = 0;
+        while (i < common.length && common[i] === indent[i]) i++;
+        common = common.slice(0, i);
+      }
+    }
+    const description = lines.map((line) => line.trim() ? line.slice(common?.length ?? 0) : "").join("\n").trim();
+    for (const line of description.split("\n")) await output((line.trim() ? `  ${line}` : line) + "\n");
+  }
+  if (!found) await output("No fragment loaders found\n");
+  return 0;
+}
+
+// packages/safe-bash-command-llm/src/tools-command.ts
+var usage2 = "Usage: llm tools list [OPTIONS] [TOOL_DEFS]...\n";
+var groupHelp = "Usage: llm tools [OPTIONS] COMMAND [ARGS]...\n\n  Manage tools that can be made available to LLMs\n\nOptions:\n  -h, --help  Show this message and exit.\n\nCommands:\n  list*  List available tools that have been provided by plugins\n";
+var listHelp = usage2 + "\n  List available tools that have been provided by plugins\n\nOptions:\n  --json            Output as JSON\n  --functions TEXT  Python code block or file path defining functions to\n                    register as tools\n  -h, --help        Show this message and exit.\n";
+function compareNames(left, right) {
+  let a = 0, b = 0;
+  while (a < left.length && b < right.length) {
+    const x = left.codePointAt(a), y = right.codePointAt(b);
+    if (x !== y) return x - y;
+    a += x > 65535 ? 2 : 1;
+    b += y > 65535 ? 2 : 1;
+  }
+  return left.length - a - (right.length - b);
+}
+async function toolsCommand(tokens, registry, output, diagnostic, step, signal, load) {
+  let groupEager = false, separator = -1;
+  const error = async (message, withUsage = false) => {
+    await diagnostic(
+      (withUsage ? usage2 + "Try 'llm tools list --help' for help.\n\n" : "") + "Error: " + message + "\n"
+    );
+    return 2;
+  };
+  for (let index = 0; index < tokens.length; index++) {
+    await step();
+    const token = tokens[index];
+    if (token === "--") {
+      separator = index;
+      break;
+    }
+    if (!token.startsWith("-") || token === "-") break;
+    if (token.startsWith("--help=")) return error("Option '--help' does not take a value.");
+    if (token === "--help" || !token.startsWith("--") && token.slice(1).includes("h"))
+      groupEager = true;
+  }
+  if (groupEager) {
+    await output(groupHelp);
+    return 0;
+  }
+  const groupArgs = tokens.filter((_, index) => index !== separator);
+  const args = groupArgs[0] === "list" ? groupArgs.slice(1) : groupArgs;
+  const names = [];
+  let json = false, help2 = false, ended = false;
+  const functions = [];
+  for (let index = 0; index < args.length; index++) {
+    await step();
+    const token = args[index];
+    if (ended || !token.startsWith("-") || token === "-") {
+      names.push(token);
+      continue;
+    }
+    if (token === "--") {
+      ended = true;
+      continue;
+    }
+    const equals = token.indexOf("="), flag = equals < 0 ? token : token.slice(0, equals);
+    if (["--json", "--help"].includes(flag) && equals >= 0)
+      return error(`Option '${flag}' does not take a value.`);
+    if (token === "--json") {
+      json = true;
+      continue;
+    }
+    if (token === "--help" || token === "-h") {
+      help2 = true;
+      continue;
+    }
+    if (flag === "--functions") {
+      if (equals < 0 && args[++index] === void 0)
+        return error("Option '--functions' requires an argument.");
+      functions.push(equals < 0 ? args[index] : token.slice(equals + 1));
+      continue;
+    }
+    return error(`No such option '${flag}'.`, true);
+  }
+  if (help2) {
+    await output(listHelp);
+    return 0;
+  }
+  if (functions.length && !load) {
+    await diagnostic("Error: Python tool loading is not configured\n");
+    return 1;
+  }
+  let selected;
+  let toolboxes = [];
+  try {
+    const dynamicNames = names.filter((name) => !registry.has(name));
+    const loaded = load && (!names.length || functions.length || dynamicNames.length) ? await load(functions, dynamicNames, !names.length || dynamicNames.length > 0) : { tools: [] };
+    toolboxes = [...loaded.toolboxes ?? []].sort((left, right) => compareNames(left.name, right.name));
+    selected = new Map(names.length ? [...loaded.tools, ...selectLlmTools(registry, load ? names.filter((name) => registry.has(name)) : names)].map((tool) => [tool.name, tool]) : [...registry, ...loaded.tools.map((tool) => [tool.registryKey ?? tool.name, tool])]);
+  } catch (failure) {
+    await diagnostic("Error: " + (failure instanceof Error ? failure.message : String(failure)) + "\n");
+    return 1;
+  }
+  const entries = [...selected].sort(([left], [right]) => compareNames(left, right));
+  if (json) {
+    const tools = entries.map(([name, tool]) => ({
+      name,
+      description: tool.description ?? null,
+      arguments: tool.inputSchema,
+      plugin: tool.plugin ?? null
+    }));
+    for await (const bytes of referenceJson({ tools, toolboxes: toolboxes.map((box) => ({ name: box.name, tools: box.tools.map((tool) => ({
+      name: tool.name,
+      description: tool.description ?? null,
+      arguments: tool.inputSchema
+    })) })) }, signal, true)) {
+      await step();
+      await output(new TextDecoder().decode(bytes));
+    }
+    await output("\n");
+    return 0;
+  }
+  const describe = async (tool, indent) => {
+    await step();
+    await output(indent + tool.name + (tool.signature ?? "()") + (tool.plugin ? ` (plugin: ${tool.plugin})` : "") + "\n\n");
+    if (tool.description) {
+      const description = tool.description.trim();
+      let start = 0;
+      while (start <= description.length) {
+        await step();
+        const newline = description.indexOf("\n", start), end = newline < 0 ? description.length : newline;
+        const line = description.slice(start, end);
+        await output((line.trim() ? indent + "  " : "") + line + "\n");
+        if (newline < 0) break;
+        start = end + 1;
+      }
+      await output("\n");
+    }
+  };
+  for (const [, tool] of entries) await describe(tool, "");
+  for (const box of toolboxes) {
+    await step();
+    await output(box.name + ":\n\n");
+    for (const tool of box.tools) await describe(tool, "  ");
+  }
+  return 0;
+}
+
+// packages/safe-bash-command-llm/src/fragment-loaders.ts
+import { yieldTurn as yieldTurn6 } from "../../safe-bash-contracts/yield.js";
+function getLlmFragmentPrefix(reference) {
+  const colon = reference.indexOf(":");
+  if (colon <= 0) return void 0;
+  for (let i = 0; i < colon; i++) {
+    const code = reference.charCodeAt(i);
+    if (!(code >= 48 && code <= 57 || code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 45 || code === 95)) return void 0;
+  }
+  return reference.slice(0, colon);
+}
+function createLlmFragmentLoaders(entries) {
+  const loaders = /* @__PURE__ */ new Map();
+  for (const [prefix, loader] of entries) {
+    let name = prefix, suffix = 0;
+    while (loaders.has(name)) name = `${prefix}_${++suffix}`;
+    loaders.set(name, loader);
+  }
+  return loaders;
+}
+async function* loadLlmPluginFragments(reference, loaders, context, allowAttachments = true) {
+  const prefix = getLlmFragmentPrefix(reference), loader = prefix === void 0 ? void 0 : loaders.get(prefix);
+  if (!loader) throw new Error(`Unknown fragment prefix: ${prefix ?? reference}`);
+  const { signal } = context;
+  let iterator, ended = false;
+  try {
+    signal.throwIfAborted();
+    iterator = loader(reference.slice(prefix.length + 1), context)[Symbol.asyncIterator]();
+    while (true) {
+      await yieldTurn6(signal);
+      const pending = Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return iterator.next();
+      });
+      void pending.then((result2) => {
+        if (signal.aborted && !result2.done) void result2.value.source.dispose().catch(() => void 0);
+      }, () => void 0);
+      const result = await waitForSource(() => pending, signal);
+      if (result.done) {
+        ended = true;
+        break;
+      }
+      const value = result.value;
+      let closing;
+      const dispose = () => closing ??= Promise.resolve().then(() => value.source.dispose());
+      try {
+        if (value.type !== "text" && value.type !== "attachment") throw new TypeError("Invalid fragment loader result");
+        if (value.type === "attachment" && !allowAttachments) throw new Error(`Fragment loader ${prefix} returned a disallowed attachment`);
+        const source = { bytes: value.source.bytes, dispose, normalizeNewlines: false };
+        yield { ...value, source };
+      } finally {
+        await dispose();
+      }
+    }
+  } catch (error) {
+    signal.throwIfAborted();
+    throw new Error(`Could not load fragment ${reference}: ${error instanceof Error ? error.message : String(error)}`);
+  } finally {
+    if (iterator && !ended) {
+      const retired = Promise.resolve().then(() => iterator.return?.());
+      if (signal.aborted) void retired.catch(() => void 0);
+      else await waitForSource(() => retired, signal);
+    }
+  }
+}
+
+// packages/safe-bash-command-llm/src/url-fragment-source.ts
+import { pythonFileCodepages } from "../../safe-bash-csv-engine/python-file-codepages.js";
+import { pythonSingleByteCodepages } from "../../safe-bash-csv-engine/python-codepages.js";
+import { normalizeEncoding, pythonCodecAliases } from "../../safe-bash-csv-engine/python-codec-aliases.js";
+
+// packages/safe-bash-command-llm/src/url-source.ts
+import { FsError as FsError2 } from "../../safe-bash-contracts/index.js";
+import { inheritYieldCheckpoint as inheritYieldCheckpoint3, yieldTurn as yieldTurn7 } from "../../safe-bash-contracts/yield.js";
+function createLlmUrlSource(options) {
+  validateAttachmentUrl(options.url);
+  const limit = options.maxBytes ?? Infinity;
+  const maxRedirects = options.maxRedirects ?? 0;
+  if (!Number.isSafeInteger(maxRedirects) || maxRedirects < 0) throw new RangeError("Invalid URL redirect limit");
+  if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid URL input byte limit");
+  if (typeof options.fetch !== "function") throw new TypeError("Attachment URL loading is not configured");
+  options.signal.throwIfAborted();
+  const controller = new AbortController();
+  const signal = AbortSignal.any([options.signal, controller.signal]);
+  inheritYieldCheckpoint3(options.signal, signal);
+  let response;
+  let reader;
+  let closed = false, consumed = false;
+  let cancellation;
+  const cancel = () => {
+    if (!response) return Promise.resolve();
+    return cancellation ??= Promise.resolve().then(() => reader ? reader.cancel() : response.body?.cancel());
+  };
+  const abort = () => {
+    void cancel().catch(() => void 0);
+  };
+  signal.addEventListener("abort", abort, { once: true });
+  const dispose = async () => {
+    closed = true;
+    controller.abort(new FsError2("EBADF", { message: "LLM URL input is closed" }));
+    signal.removeEventListener("abort", abort);
+    const cleanup = cancel();
+    if (options.signal.aborted) void cleanup.catch(() => void 0);
+    else await cleanup;
+  };
+  return { dispose, bytes: { async *[Symbol.asyncIterator]() {
+    if (closed || consumed) throw new FsError2("EBADF", { message: "LLM URL input is closed or consumed" });
+    consumed = true;
+    let failed = false, size = 0, windows = 0;
+    try {
+      signal.throwIfAborted();
+      let url = options.url;
+      for (let redirects = 0; ; redirects++) {
+        await waitForSource(() => options.fetch(url, { method: "GET", redirect: "manual", signal }).then((value) => {
+          response = value;
+          if (closed || signal.aborted) void cancel().catch(() => void 0);
+          return value;
+        }), signal);
+        signal.throwIfAborted();
+        const location = response.headers.get("location");
+        if (![301, 302, 303, 307, 308].includes(response.status) || !location || maxRedirects === 0) break;
+        if (redirects >= maxRedirects) throw new Error("Exceeded maximum allowed redirects.");
+        const next = new URL(location, url).href;
+        validateAttachmentUrl(next);
+        await waitForSource(cancel, signal);
+        response = void 0;
+        cancellation = void 0;
+        url = next;
+      }
+      if (!response.ok) throw new Error(`Attachment URL returned HTTP ${response.status}`);
+      if (!response.body) return;
+      reader = response.body.getReader();
+      while (true) {
+        const next = await waitForSource(() => reader.read(), signal);
+        if (next.done) return;
+        if (!(next.value instanceof Uint8Array)) throw new TypeError("Attachment URL must return byte chunks");
+        if (next.value.length > limit - size) throw new FsError2("EFBIG", { message: "Attachment URL input byte limit exceeded" });
+        options.admitBytes?.(next.value.length);
+        size += next.value.length;
+        if (!next.value.length && ++windows % 64 === 0) await yieldTurn7(signal);
+        for (let offset = 0; offset < next.value.length; offset += 16384) {
+          if (++windows % 64 === 0) await yieldTurn7(signal);
+          signal.throwIfAborted();
+          yield next.value.slice(offset, offset + 16384);
+        }
+      }
+    } catch (error) {
+      failed = true;
+      throw signal.aborted ? signal.reason : error;
+    } finally {
+      await dispose().catch((error) => {
+        if (!failed) throw error;
+      });
+      reader?.releaseLock();
+    }
+  } } };
+}
+
+// packages/safe-bash-command-llm/src/url-fragment-source.ts
+function charset(header) {
+  const parameters = [];
+  let part = "", quoted = false, escaped = false;
+  for (const character of header ?? "") {
+    if (escaped) {
+      part += character;
+      escaped = false;
+      continue;
+    }
+    if (quoted && character === "\\") {
+      escaped = true;
+      continue;
+    }
+    if (character === '"') {
+      quoted = !quoted;
+      continue;
+    }
+    if (character === ";" && !quoted) {
+      parameters.push(part);
+      part = "";
+    } else part += character;
+  }
+  parameters.push(part);
+  for (const parameter of parameters.slice(1)) {
+    const equals = parameter.indexOf("=");
+    if (equals >= 0 && parameter.slice(0, equals).trim().toLowerCase() === "charset")
+      return parameter.slice(equals + 1).trim();
+  }
+  return "utf-8";
+}
+function responseDecoder(header) {
+  const name = charset(header), encoding = pythonCodecAliases[normalizeEncoding(name)] ?? "utf-8";
+  const table = pythonSingleByteCodepages[encoding] ?? pythonFileCodepages[encoding];
+  if (table)
+    return {
+      decode(bytes) {
+        let result = "";
+        for (const byte of bytes ?? []) {
+          const code = table[byte];
+          result += String.fromCodePoint(code < 0 ? 65533 : code);
+        }
+        return result;
+      }
+    };
+  if (encoding !== "utf-8" && encoding !== "utf-8-sig")
+    throw new Error(`Unsupported URL fragment charset: ${name}`);
+  const decoder = new TextDecoder("utf-8", { ignoreBOM: true });
+  if (encoding === "utf-8") return decoder;
+  const signature = Uint8Array.of(239, 187, 191);
+  let offset = 0, decided = false;
+  return {
+    decode(bytes = new Uint8Array(), options) {
+      let index = 0, prefix = "";
+      while (!decided && index < bytes.length) {
+        if (bytes[index] !== signature[offset]) {
+          decided = true;
+          prefix = decoder.decode(signature.subarray(0, offset), { stream: true });
+          break;
+        }
+        index++;
+        offset++;
+        if (offset === 3) decided = true;
+      }
+      return decided ? prefix + decoder.decode(bytes.subarray(index), options) : "";
+    }
+  };
+}
+function createLlmUrlFragmentSource(options) {
+  let decoder, contentType = null;
+  const raw = createLlmUrlSource({
+    ...options,
+    maxRedirects: 3,
+    fetch: async (input, init) => {
+      const response = await options.fetch(input, init);
+      contentType = response.headers.get("content-type");
+      return response;
+    }
+  });
+  return {
+    normalizeNewlines: false,
+    dispose: raw.dispose,
+    bytes: {
+      async *[Symbol.asyncIterator]() {
+        const encoder = new TextEncoder();
+        try {
+          for await (const bytes of raw.bytes) {
+            if (!bytes.length) continue;
+            decoder ??= responseDecoder(contentType);
+            const text = decoder.decode(bytes, { stream: true });
+            if (text) yield encoder.encode(text);
+          }
+          options.signal.throwIfAborted();
+          const tail = decoder?.decode();
+          if (tail) yield encoder.encode(tail);
+        } finally {
+          await raw.dispose();
+        }
+      }
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/src/fragments.ts
+import { yieldTurn as yieldTurn8 } from "../../safe-bash-contracts/yield.js";
+function whitespace(code) {
+  return code >= 9 && code <= 13 || code >= 28 && code <= 32 || code === 133 || code === 160 || code === 5760 || code >= 8192 && code <= 8202 || code === 8232 || code === 8233 || code === 8239 || code === 8287 || code === 12288;
+}
+async function createLlmFragmentSource(options) {
+  const { fs, directory, signal } = options;
+  let output;
+  try {
+    output = await createLlmSpool(fs, directory, signal, "input");
+  } catch (error) {
+    await options.tail?.dispose();
+    throw error;
+  }
+  let count = 0, tailDisposed = false;
+  const append = async (source, tail = false) => {
+    let part;
+    try {
+      part = await createLlmSpool(fs, directory, signal, "input");
+      const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+      let size = 0, start, end = 0, previousCR = false;
+      const normalize = (text) => {
+        if (!(source.normalizeNewlines ?? options.normalizeNewlines) || tail) return text;
+        let result = "";
+        for (const character of text) {
+          if (character !== "\n" || !previousCR) result += character === "\r" ? "\n" : character;
+          previousCR = character === "\r";
+        }
+        return result;
+      };
+      const scan = (text) => {
+        for (const character of text) {
+          const code = character.codePointAt(0);
+          const length = code < 128 ? 1 : code < 2048 ? 2 : code < 65536 ? 3 : 4;
+          if (!whitespace(code)) {
+            start ??= size;
+            end = size + length;
+          }
+          size += length;
+        }
+      };
+      for await (const chunk of sourceBytes(source.bytes, signal)) {
+        if (!tail) options.admitBytes?.(chunk.byteLength, source);
+        if (!chunk.byteLength) await yieldTurn8(signal);
+        for (let offset = 0; offset < chunk.byteLength; offset += 16384) {
+          await yieldTurn8(signal);
+          const window = chunk.subarray(offset, offset + 16384);
+          const text = normalize(decoder.decode(window, { stream: true }));
+          scan(text);
+          await part.write(new TextEncoder().encode(text));
+        }
+      }
+      const last = normalize(decoder.decode());
+      scan(last);
+      if (last) await part.write(new TextEncoder().encode(last));
+      if (options.system ? start === void 0 : tail && size === 0) return;
+      if (count++) {
+        const separator = options.system ? Uint8Array.of(10, 10) : Uint8Array.of(10);
+        options.admitSeparator?.(separator.byteLength);
+        await output.write(separator);
+      }
+      for await (const chunk of part.replay(
+        options.system ? async () => ({ start, end }) : void 0
+      ))
+        await output.write(chunk);
+    } finally {
+      try {
+        await part?.close();
+      } finally {
+        if (tail) tailDisposed = true;
+        await source.dispose();
+      }
+    }
+  };
+  let iterator, ended = false;
+  try {
+    iterator = options.fragments[Symbol.asyncIterator]();
+    while (true) {
+      await yieldTurn8(signal);
+      const pending = Promise.resolve().then(() => {
+        signal.throwIfAborted();
+        return iterator.next();
+      });
+      void pending.then(
+        (result2) => {
+          if (signal.aborted && !result2.done) void result2.value.dispose().catch(() => void 0);
+        },
+        () => void 0
+      );
+      const result = await waitForSource(() => pending, signal);
+      if (result.done) {
+        ended = true;
+        break;
+      }
+      await append(result.value);
+    }
+    if (options.tail) await append(options.tail, true);
+    return { bytes: output.replay(), dispose: output.close };
+  } catch (error) {
+    await output.close();
+    throw error;
+  } finally {
+    try {
+      if (!tailDisposed) await options.tail?.dispose();
+    } finally {
+      if (iterator && !ended) {
+        const retired = Promise.resolve().then(() => iterator.return?.());
+        if (signal.aborted) void retired.catch(() => void 0);
+        else await retired;
+      }
+    }
+  }
+}
+
+// packages/safe-bash-command-llm/src/embed-models-command.ts
+var groupHelp2 = "Usage: llm embed-models [OPTIONS] COMMAND [ARGS]...\n\n  Manage available embedding models\n\nOptions:\n  -h, --help  Show this message and exit.\n\nCommands:\n  list*    List available embedding models\n  default  Show or set the default embedding model\n";
+async function embeddingModelsCommand(context, service, tokens, emit, diagnostic, step, maxConfigurationBytes = Infinity) {
+  if (tokens[0] === "--" && ["list", "default"].includes(tokens[1] ?? "")) tokens = tokens.slice(1);
+  const defaults = tokens[0] === "default", explicit = tokens[0] === "list" || defaults;
+  const command = defaults ? "default" : "list";
+  const usage3 = `Usage: llm embed-models ${command} [OPTIONS]${defaults ? " [MODEL]" : ""}
+`;
+  const fail = async (message, withUsage = true) => {
+    await diagnostic((withUsage ? usage3 + `Try 'llm embed-models ${command} -h' for help.
+
+` : "") + `Error: ${message}
+`);
+    return 2;
+  };
+  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(groupHelp2);
+    return 0;
+  }
+  const args = explicit ? tokens.slice(1) : tokens.filter((_, index) => index !== terminator);
+  const queries = [], operands = [];
+  let ended = false, help2 = false, remove = false;
+  for (let index = 0; index < args.length; index++) {
+    await step();
+    const token = args[index];
+    if (!ended && token === "--") {
+      ended = true;
+      continue;
+    }
+    if (ended || !token.startsWith("-") || token === "-") {
+      operands.push(token);
+      continue;
+    }
+    if (token === "--help" || token === "-h") {
+      help2 = true;
+      continue;
+    }
+    if (defaults && token === "--remove-default") {
+      remove = true;
+      continue;
+    }
+    if (!token.startsWith("--")) {
+      for (let cursor = 1; cursor < token.length; cursor++) {
+        const flag2 = "-" + token[cursor];
+        if (flag2 === "-h") {
+          help2 = true;
+          continue;
+        }
+        if (defaults || flag2 !== "-q") return fail(`No such option: ${flag2}`);
+        const value2 = token.slice(cursor + 1) || args[++index];
+        if (value2 === void 0) return fail(`Option '${flag2}' requires an argument.`, false);
+        queries.push(value2.toLowerCase());
+        break;
+      }
+      continue;
+    }
+    const equals = token.indexOf("=");
+    const flag = token.slice(0, equals < 0 ? void 0 : equals);
+    if (equals >= 0 && (flag === "--help" || defaults && flag === "--remove-default")) return fail(`Option '${flag}' does not take a value.`, false);
+    if (defaults || flag !== "--query") return fail(`No such option: ${flag}`);
+    const attached = equals < 0 ? void 0 : token.slice(equals + 1);
+    const value = attached ?? args[++index];
+    if (value === void 0) return fail(`Option '${flag}' requires an argument.`, false);
+    queries.push(value.toLowerCase());
+  }
+  if (help2) {
+    await emit(usage3 + (defaults ? "\n  Show or set the default embedding model\n\nOptions:\n  --remove-default  Reset to specifying no default model\n  -h, --help        Show this message and exit.\n" : "\n  List available embedding models\n\nOptions:\n  -q, --query TEXT  Search for embedding models matching these strings\n  -h, --help        Show this message and exit.\n"));
+    return 0;
+  }
+  const extra = operands.slice(defaults ? 1 : 0);
+  if (extra.length) return fail(`Got unexpected extra argument${extra.length === 1 ? "" : "s"} (${extra.join(" ")})`);
+  const configuration = createLlmConfiguration(context, maxConfigurationBytes);
+  if (defaults) {
+    const selected = operands[0];
+    if (!selected && !remove) {
+      const model = await configuration.defaultModel("default_embedding_model.txt");
+      if (model === void 0) await diagnostic("<No default embedding model set>\n");
+      else await emit(model + "\n");
+    } else if (remove) await configuration.setDefaultModel(null, "default_embedding_model.txt");
+    else {
+      const resolved = await configuration.resolveAlias(selected);
+      let entry;
+      try {
+        entry = service.resolve(resolved);
+      } catch {
+      }
+      if (!entry?.model.capabilities?.includes("embed") || !entry.provider.embed && !entry.provider.embedSources) {
+        await diagnostic(`Error: Unknown embedding model: ${selected}
+`);
+        return 1;
+      }
+      await configuration.setDefaultModel(entry.model.id, "default_embedding_model.txt");
+    }
+    return 0;
+  }
+  const configured = await configuration.aliases();
+  let emitted = false;
+  for (const entry of service.models) {
+    await step();
+    if (!entry.model.capabilities?.includes("embed") || !entry.provider.embed && !entry.provider.embedSources) continue;
+    const aliases = [...entry.model.aliases ?? []];
+    for (const [alias, target] of Object.entries(configured)) {
+      await step();
+      if (target === entry.model.id) aliases.push(alias);
+    }
+    const description = `${entry.provider.name}: ${entry.model.id}`;
+    const terms = [description, ...aliases].map((value) => value.toLowerCase());
+    if (!queries.every((query) => terms.some((term) => term.includes(query)))) continue;
+    await emit(description + (aliases.length ? ` (aliases: ${aliases.join(", ")})` : "") + "\n");
+    emitted = true;
+  }
+  if (!emitted) await emit("\n");
+  return 0;
+}
+
+// packages/safe-bash-command-llm/src/usage.ts
+async function* serializeLlmTokenUsage(usage3, signal) {
+  signal.throwIfAborted();
+  const encoder = new TextEncoder();
+  let separator = "";
+  for (const name of ["input", "output"]) {
+    const value = usage3?.[name];
+    if (value === void 0 || value === null) continue;
+    if (typeof value !== "number" || !Number.isFinite(value)) throw new TypeError(`Invalid LLM ${name} token count`);
+    yield encoder.encode(`${separator}${value.toLocaleString("en-US", { maximumFractionDigits: 20 })} ${name}`);
+    separator = ", ";
+  }
+  const details = usage3?.details;
+  if (!details || typeof details !== "object") return;
+  let nonempty = false;
+  for (const key in details) if (Object.hasOwn(details, key)) {
+    nonempty = true;
+    break;
+  }
+  if (!nonempty) return;
+  yield encoder.encode(separator);
+  yield* referenceJson(details, signal);
+}
+
+// packages/safe-bash-command-llm/src/input-budget.ts
+import { FsError as FsError3, shellValueByteLength as shellValueByteLength2 } from "../../safe-bash-contracts/index.js";
+function createLlmInputBudget(limits = {}, parent) {
+  for (const [name, value] of Object.entries({ maxInputBytes: limits.maxInputBytes, maxBufferedInputBytes: limits.maxBufferedInputBytes })) {
+    if (value !== void 0 && value !== Infinity && (!Number.isSafeInteger(value) || value < 0)) throw new RangeError(`Invalid LLM input limit: ${name}`);
+  }
+  const totalLimit = Math.min(limits.maxInputBytes ?? Infinity, parent?.maxBytes ?? Infinity);
+  const bufferedLimit = limits.maxBufferedInputBytes ?? Infinity;
+  let total = 0, buffered = 0;
+  const check = (size, materialized = false) => {
+    if (!Number.isSafeInteger(size) || size < 0) throw new RangeError("Invalid LLM input size");
+    if (materialized && size > bufferedLimit - buffered) throw new FsError3("EFBIG", { message: "llm buffered input byte limit exceeded" });
+    if (size > totalLimit - total) throw new FsError3("EFBIG", { message: "llm input byte limit exceeded" });
+    parent?.check(total + size);
+  };
+  return {
+    check,
+    get totalBytes() {
+      return total;
+    },
+    remaining(materialized = false) {
+      return Math.min(totalLimit - total, materialized ? bufferedLimit - buffered : Infinity);
+    },
+    admit(size, materialized = false) {
+      check(size, materialized);
+      total += size;
+      if (materialized) buffered += size;
+    },
+    /** Charge materialization of bytes already admitted as streamed input. */
+    materialize(size) {
+      if (!Number.isSafeInteger(size) || size < 0) throw new RangeError("Invalid LLM input size");
+      if (size > bufferedLimit - buffered) throw new FsError3("EFBIG", { message: "llm buffered input byte limit exceeded" });
+      buffered += size;
+    },
+    admitText(text) {
+      const size = shellValueByteLength2(text);
+      check(size, true);
+      total += size;
+      buffered += size;
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/src/command.ts
+import { pipeBytes as pipeBytes2, createOutputOperation, getCommandArguments, shellValueByteLength as shellValueByteLength3, FsError as FsError6 } from "../../safe-bash-contracts/index.js";
+import { inheritYieldCheckpoint as inheritYieldCheckpoint4, yieldTurn as yieldTurn11 } from "../../safe-bash-contracts/yield.js";
+import { writeDiagnostic as writeDiagnostic2 } from "../../safe-bash-contracts/escaping.js";
+import { pathOf as pathOf3 } from "../../safe-bash-contracts/path.js";
+
+// packages/safe-bash-command-llm/src/templates.ts
+import { FsError as FsError4 } from "../../safe-bash-contracts/index.js";
+import { pathOf } from "../../safe-bash-contracts/path.js";
+function unicodeOrder(left, right) {
+  let a = 0, b = 0;
+  while (a < left.length && b < right.length) {
+    const x = left.codePointAt(a), y = right.codePointAt(b);
+    if (x !== y) return x - y;
+    a += x > 65535 ? 2 : 1;
+    b += y > 65535 ? 2 : 1;
+  }
+  return (a < left.length ? 1 : 0) - (b < right.length ? 1 : 0);
+}
+var templateFields = ["name", "prompt", "system", "model", "defaults", "options", "attachments", "attachment_types", "extract", "extract_last", "schema_object", "fragments", "system_fragments", "tools", "functions"];
+function template(value, name) {
+  if (typeof value === "string") return { name, prompt: value };
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`Invalid template: ${name}`);
+  const fields = { ...value, name };
+  for (const [key, item] of Object.entries(fields)) {
+    if (!templateFields.includes(key)) throw new Error(`Unsupported template field: ${key}`);
+    if (item === null) {
+      delete fields[key];
+      continue;
+    }
+    if (["attachments", "fragments", "system_fragments", "tools"].includes(key)) {
+      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)) throw new Error(`Invalid template: ${name}`);
+    } else if (key === "schema_object") {
+      if (typeof item !== "object" || Array.isArray(item)) throw new Error(`Invalid template: ${name}`);
+    } else if (["extract", "extract_last"].includes(key)) {
+      if (typeof item !== "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, admitText) {
+  if (!text) return text;
+  let result = "";
+  const append = (value) => {
+    if (!validateOnly) {
+      admitText?.(value);
+      result += value;
+    }
+  };
+  const missing = [];
+  for (let index = 0; index < text.length; index++) {
+    if (text[index] !== "$") {
+      const point = text.codePointAt(index);
+      const literal = String.fromCodePoint(point);
+      append(literal);
+      if (point > 65535) index++;
+      continue;
+    }
+    if (text[index + 1] === "$") {
+      append("$");
+      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) append(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, admitText) {
+  const variables = { ...value.defaults, ...params, input };
+  if (!value.prompt) admitText?.(input);
+  return { prompt: value.prompt ? interpolate(value.prompt, variables, false, admitText) : input, ...value.system === void 0 ? {} : { system: interpolate(value.system, variables, false, admitText) } };
+}
+function abortLoader(start, signal, late) {
+  signal.throwIfAborted();
+  return new Promise((resolve, reject) => {
+    const abort = () => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.reason);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => {
+      signal.throwIfAborted();
+      return start();
+    }).then((value) => {
+      signal.removeEventListener("abort", abort);
+      if (signal.aborted) {
+        if (late) void Promise.resolve().then(() => late(value)).catch(() => void 0);
+        reject(signal.reason);
+      } else resolve(value);
+    }, (error) => {
+      signal.removeEventListener("abort", abort);
+      reject(signal.aborted ? signal.reason : error);
+    });
+    if (signal.aborted) abort();
+  });
+}
+function createLlmTemplateStore(context, loaders) {
+  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 {
+      context.signal.throwIfAborted();
+      if (name.startsWith("https://") || name.startsWith("http://")) {
+        const fetch = context.fetch ?? context.capabilities?.fetch;
+        if (!fetch) throw new Error("Template URL loading is not configured");
+        if (!loaders || loaders.maxRemoteBytes !== Infinity && (!Number.isSafeInteger(loaders.maxRemoteBytes) || loaders.maxRemoteBytes < 1)) throw new Error("Template URL byte limit is not configured");
+        const materializedLimit = loaders.maxBytes ?? Infinity;
+        let response, failed = false;
+        let reader;
+        const abort = () => {
+          void reader?.cancel().catch(() => {
+          });
+        };
+        try {
+          response = await abortLoader(() => fetch(name, { signal: context.signal }), context.signal, async (response2) => {
+            await response2.body?.cancel();
+          });
+          if (!response.ok) {
+            const kind = response.status < 500 ? "Client" : "Server";
+            throw new Error(`${kind} error '${response.status} ${response.statusText}' for url '${name}'
+For more information check: https://developer.mozilla.org/en-US/docs/Web/HTTP/Status/${response.status}`);
+          }
+          reader = response.body?.getReader();
+          context.signal.addEventListener("abort", abort, { once: true });
+          context.signal.throwIfAborted();
+          const decoder = new TextDecoder("utf-8", { fatal: true });
+          const chunks = [];
+          let total = 0;
+          while (reader) {
+            context.signal.throwIfAborted();
+            const next = await abortLoader(() => reader.read(), context.signal);
+            context.signal.throwIfAborted();
+            if (next.done) break;
+            total += next.value.byteLength;
+            if (total > loaders.maxRemoteBytes) throw new RangeError("Template URL exceeds byte limit");
+            if (total > materializedLimit) throw new FsError4("EFBIG", { message: "llm buffered input byte limit exceeded" });
+            loaders.admitBytes?.(next.value.byteLength);
+            chunks.push(decoder.decode(next.value, { stream: true }));
+          }
+          chunks.push(decoder.decode());
+          const { parse: parse3 } = await import("../bundled-yaml/index.js");
+          const value = template(parse3(chunks.join("")), name);
+          Object.defineProperty(value, "functionsTrusted", { value: false });
+          return value;
+        } catch (error) {
+          failed = true;
+          context.signal.throwIfAborted();
+          throw new Error(`Could not load template ${name}: ${error instanceof Error ? error.message : String(error)}`);
+        } finally {
+          context.signal.removeEventListener("abort", abort);
+          if (reader) {
+            const cancelled = reader.cancel();
+            if (context.signal.aborted) {
+              void cancelled.catch(() => void 0);
+              reader.releaseLock();
+            } else try {
+              await cancelled.catch((error) => {
+                if (!failed) throw error;
+              });
+            } finally {
+              reader.releaseLock();
+            }
+          } else if (response?.body) {
+            const cancelled = response.body.cancel();
+            if (context.signal.aborted) void cancelled.catch(() => void 0);
+            else await cancelled.catch((error) => {
+              if (!failed) throw error;
+            });
+          }
+        }
+      }
+      const { parse: parse2 } = await import("../bundled-yaml/index.js");
+      let path = pathOf(context, name);
+      try {
+        await context.fs.stat(path, { signal: context.signal });
+      } catch (error) {
+        if (!(error instanceof FsError4) || error.code !== "ENOENT") throw error;
+        const colon = name.indexOf(":");
+        if (colon > 0) {
+          const prefix = name.slice(0, colon);
+          let valid = true;
+          for (const letter of prefix) if (!"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789_-".includes(letter)) {
+            valid = false;
+            break;
+          }
+          if (valid) {
+            const loader = loaders?.loaders?.get(prefix);
+            if (!loader) throw new Error(`Unknown template prefix: ${prefix}`);
+            try {
+              const loaded = await abortLoader(() => loader(name.slice(colon + 1), context.signal), context.signal);
+              context.signal.throwIfAborted();
+              const materializedLimit = loaders?.maxBytes ?? Infinity;
+              let loadedBytes = 0;
+              if (loaders?.admitBytes || materializedLimit !== Infinity) for await (const bytes2 of jsonValue(loaded, context.signal)) {
+                loadedBytes += bytes2.byteLength;
+                if (loadedBytes > materializedLimit) throw new FsError4("EFBIG", { message: "llm buffered input byte limit exceeded" });
+                loaders?.admitBytes?.(bytes2.byteLength);
+              }
+              const value = template(loaded, loaded.name);
+              Object.defineProperty(value, "functionsTrusted", { value: false });
+              return value;
+            } catch (error2) {
+              context.signal.throwIfAborted();
+              throw new Error(`Could not load template ${name}: ${error2 instanceof Error ? error2.message : String(error2)}`);
+            }
+          }
+        }
+        path = filename(name);
+      }
+      const size = (await context.fs.stat(path, { signal: context.signal })).size;
+      if (size > (loaders?.maxBytes ?? Infinity)) throw new FsError4("EFBIG", { message: "llm buffered input byte limit exceeded" });
+      const bytes = await context.fs.readFile(path, { signal: context.signal, ...loaders?.maxBytes === void 0 || loaders.maxBytes === Infinity ? {} : { maxBytes: loaders.maxBytes } });
+      loaders?.admitBytes?.(bytes.byteLength);
+      return template(parse2(new TextDecoder("utf-8", { fatal: true }).decode(bytes)), name);
+    } catch (error) {
+      if (error instanceof FsError4 && error.code === "ENOENT") throw new Error(`Invalid template: ${name}`);
+      throw error;
+    }
+  };
+  const publish = async (name, bytes) => {
+    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 FsError4) || error.code !== "ENOENT") throw error;
+      expected = null;
+    }
+    await publishConfiguration(context.fs, directory, path, bytes, parent, expected, context.signal);
+  };
+  return {
+    directory,
+    load,
+    async save(name, value) {
+      const { stringify } = await import("../bundled-yaml/index.js");
+      await publish(name, new TextEncoder().encode(stringify(value, { indent: 4, lineWidth: 0 })));
+    },
+    async command(args, output, diagnostic) {
+      const actions = ["list", "edit", "loaders", "path", "show"];
+      const grouped = args.length === 1 && ["--help", "-h"].includes(args[0]);
+      const routed = args[0] === "--" ? args.slice(1) : args;
+      const explicit = actions.includes(routed[0] ?? "");
+      const command = explicit ? routed[0] : "list";
+      const tokens = explicit ? routed.slice(1) : routed;
+      const descriptions = {
+        list: "List available prompt templates",
+        edit: "Edit the specified prompt template using the default $EDITOR",
+        loaders: "Show template loaders registered by plugins",
+        path: "Output the path to the templates directory",
+        show: "Show the specified prompt template"
+      };
+      const usage3 = `Usage: llm templates ${command} [OPTIONS]${["show", "edit"].includes(command) ? " NAME" : ""}
+`;
+      if (grouped) {
+        await output("Usage: llm templates [OPTIONS] COMMAND [ARGS]...\n\n  Manage stored prompt templates\n\nOptions:\n  -h, --help  Show this message and exit.\n\nCommands:\n  list*    List available prompt templates\n  edit     Edit the specified prompt template using the default $EDITOR\n  loaders  Show template loaders registered by plugins\n  path     Output the path to the templates directory\n  show     Show the specified prompt template\n");
+        return 0;
+      }
+      let optionsEnded = false;
+      const operands = [];
+      let failure;
+      let help2 = false, showUsage = true;
+      for (const token of tokens) {
+        context.signal.throwIfAborted();
+        if (!optionsEnded && token === "--") optionsEnded = true;
+        else if (!optionsEnded && token === "--help") help2 = true;
+        else if (!optionsEnded && token.startsWith("--help=")) {
+          failure = "Option '--help' does not take a value.";
+          showUsage = false;
+          break;
+        } else if (!optionsEnded && token.startsWith("-") && !token.startsWith("--") && token !== "-") {
+          for (const letter of token.slice(1)) {
+            if (letter === "h") help2 = true;
+            else {
+              failure = `No such option: -${letter}`;
+              break;
+            }
+          }
+          if (failure) break;
+        } else if (!optionsEnded && token.startsWith("-") && token !== "-") {
+          failure = `No such option: ${token.split("=")[0]}`;
+          break;
+        } else operands.push(token);
+      }
+      if (help2 && !failure) {
+        await output(usage3 + `
+  ${descriptions[command]}
+
+Options:
+  -h, --help  Show this message and exit.
+`);
+        return 0;
+      }
+      const needsName = ["show", "edit"].includes(command);
+      failure ??= needsName && !operands.length ? "Missing argument 'NAME'." : operands.length > (needsName ? 1 : 0) ? `Got unexpected extra argument (${operands[needsName ? 1 : 0]})` : void 0;
+      if (failure) {
+        await diagnostic((showUsage ? usage3 + `Try 'llm templates ${command} -h' for help.
+
+` : "") + `Error: ${failure}
+`);
+        return 2;
+      }
+      const name = operands[0];
+      if (command === "loaders") {
+        if (!loaders?.loaders?.size) await output("No template loaders found\n");
+        else for (const [prefix, loader] of loaders.loaders) {
+          context.signal.throwIfAborted();
+          const lines = (loader.description || "Undocumented").split("\n");
+          let margin;
+          for (const line of lines) {
+            if (!line.trim()) continue;
+            let length = 0;
+            while (length < line.length && (line[length] === " " || line[length] === "	")) length++;
+            const leading = line.slice(0, length);
+            if (margin === void 0) margin = leading;
+            else {
+              let common = 0;
+              while (common < margin.length && common < leading.length && margin[common] === leading[common]) common++;
+              margin = margin.slice(0, common);
+            }
+          }
+          const docs = lines.map((line) => line.trim() ? line.slice(margin?.length ?? 0) : "").join("\n").trim();
+          await output(prefix + ":\n" + docs.split("\n").map((line) => line.trim() ? "  " + line : line).join("\n") + "\n");
+        }
+        return 0;
+      }
+      if (command === "path") {
+        await output(directory + "\n");
+        return 0;
+      }
+      if (command === "show" && name) {
+        let value;
+        try {
+          value = await load(name);
+        } catch {
+          throw new Error(`Template '${name}' not found or invalid`);
+        }
+        const { templateYaml } = await import("./template-yaml-2YVS7IVT.js");
+        await output(templateYaml(value));
+        return 0;
+      }
+      if (command === "edit") {
+        if (!context.invoke) throw new Error("Template editor is not configured");
+        const path = filename(name);
+        try {
+          await context.fs.lstat(path, { signal: context.signal });
+        } catch (error) {
+          if (!(error instanceof FsError4) || error.code !== "ENOENT") throw error;
+          await publish(name, new TextEncoder().encode("prompt: "));
+        }
+        const editor = context.env.VISUAL || context.env.EDITOR || "vi";
+        const result = await context.invoke("sh", ["-c", editor + ' "$1"', "llm-template-editor", path], {
+          signal: context.signal,
+          cwd: context.cwd,
+          env: context.env,
+          replaceEnv: true,
+          ...context.stdin ? { stdin: context.stdin } : {},
+          ...context.stdout ? { stdout: context.stdout } : {},
+          ...context.stderr ? { stderr: context.stderr } : {},
+          externalInvocation: true
+        });
+        context.signal.throwIfAborted();
+        if (result.exitCode !== 0) throw new Error("Editing failed!");
+        await load(name);
+        return 0;
+      }
+      let files;
+      try {
+        files = await context.fs.readdir(directory, { signal: context.signal });
+      } catch (error) {
+        if (error instanceof FsError4 && error.code === "ENOENT") return 0;
+        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) => unicodeOrder(a.name, b.name))) {
+        const description = (value.system ? `system: ${value.system}${value.prompt ? ` prompt: ${value.prompt}` : ""}` : value.prompt ?? "").split("\n").join(" ");
+        let suppliedColumns = NaN;
+        const columnText = (context.env.COLUMNS ?? "").trim();
+        const digits = columnText.startsWith("+") || columnText.startsWith("-") ? columnText.slice(1) : columnText;
+        let valid = digits.length > 0;
+        for (const digit of digits) if (!"0123456789".includes(digit)) {
+          valid = false;
+          break;
+        }
+        if (valid) suppliedColumns = Number(columnText);
+        const columns = Number.isSafeInteger(suppliedColumns) && suppliedColumns > 0 ? suppliedColumns : 80;
+        const text = `${value.name}${" ".repeat(width - [...value.name].length)} : ${description}`;
+        const points = [...text];
+        const truncated = points.length > columns ? points.slice(0, Math.max(0, columns - 3)).join("") + "..." : text;
+        await output(truncated + "\n");
+      }
+      return 0;
+    }
+  };
+}
+
+// packages/safe-bash-command-llm/src/extract-range.ts
+import { yieldTurn as yieldTurn9 } from "../../safe-bash-contracts/yield.js";
+
+// packages/safe-bash-command-llm/src/word-ranges.ts
+var wordRanges = [[48, 57], [65, 90], [95, 95], [97, 122], [170, 170], [178, 179], [181, 181], [185, 186], [188, 190], [192, 214], [216, 246], [248, 705], [710, 721], [736, 740], [748, 748], [750, 750], [880, 884], [886, 887], [890, 893], [895, 895], [902, 902], [904, 906], [908, 908], [910, 929], [931, 1013], [1015, 1153], [1162, 1327], [1329, 1366], [1369, 1369], [1376, 1416], [1488, 1514], [1519, 1522], [1568, 1610], [1632, 1641], [1646, 1647], [1649, 1747], [1749, 1749], [1765, 1766], [1774, 1788], [1791, 1791], [1808, 1808], [1810, 1839], [1869, 1957], [1969, 1969], [1984, 2026], [2036, 2037], [2042, 2042], [2048, 2069], [2074, 2074], [2084, 2084], [2088, 2088], [2112, 2136], [2144, 2154], [2208, 2228], [2230, 2247], [2308, 2361], [2365, 2365], [2384, 2384], [2392, 2401], [2406, 2415], [2417, 2432], [2437, 2444], [2447, 2448], [2451, 2472], [2474, 2480], [2482, 2482], [2486, 2489], [2493, 2493], [2510, 2510], [2524, 2525], [2527, 2529], [2534, 2545], [2548, 2553], [2556, 2556], [2565, 2570], [2575, 2576], [2579, 2600], [2602, 2608], [2610, 2611], [2613, 2614], [2616, 2617], [2649, 2652], [2654, 2654], [2662, 2671], [2674, 2676], [2693, 2701], [2703, 2705], [2707, 2728], [2730, 2736], [2738, 2739], [2741, 2745], [2749, 2749], [2768, 2768], [2784, 2785], [2790, 2799], [2809, 2809], [2821, 2828], [2831, 2832], [2835, 2856], [2858, 2864], [2866, 2867], [2869, 2873], [2877, 2877], [2908, 2909], [2911, 2913], [2918, 2927], [2929, 2935], [2947, 2947], [2949, 2954], [2958, 2960], [2962, 2965], [2969, 2970], [2972, 2972], [2974, 2975], [2979, 2980], [2984, 2986], [2990, 3001], [3024, 3024], [3046, 3058], [3077, 3084], [3086, 3088], [3090, 3112], [3114, 3129], [3133, 3133], [3160, 3162], [3168, 3169], [3174, 3183], [3192, 3198], [3200, 3200], [3205, 3212], [3214, 3216], [3218, 3240], [3242, 3251], [3253, 3257], [3261, 3261], [3294, 3294], [3296, 3297], [3302, 3311], [3313, 3314], [3332, 3340], [3342, 3344], [3346, 3386], [3389, 3389], [3406, 3406], [3412, 3414], [3416, 3425], [3430, 3448], [3450, 3455], [3461, 3478], [3482, 3505], [3507, 3515], [3517, 3517], [3520, 3526], [3558, 3567], [3585, 3632], [3634, 3635], [3648, 3654], [3664, 3673], [3713, 3714], [3716, 3716], [3718, 3722], [3724, 3747], [3749, 3749], [3751, 3760], [3762, 3763], [3773, 3773], [3776, 3780], [3782, 3782], [3792, 3801], [3804, 3807], [3840, 3840], [3872, 3891], [3904, 3911], [3913, 3948], [3976, 3980], [4096, 4138], [4159, 4169], [4176, 4181], [4186, 4189], [4193, 4193], [4197, 4198], [4206, 4208], [4213, 4225], [4238, 4238], [4240, 4249], [4256, 4293], [4295, 4295], [4301, 4301], [4304, 4346], [4348, 4680], [4682, 4685], [4688, 4694], [4696, 4696], [4698, 4701], [4704, 4744], [4746, 4749], [4752, 4784], [4786, 4789], [4792, 4798], [4800, 4800], [4802, 4805], [4808, 4822], [4824, 4880], [4882, 4885], [4888, 4954], [4969, 4988], [4992, 5007], [5024, 5109], [5112, 5117], [5121, 5740], [5743, 5759], [5761, 5786], [5792, 5866], [5870, 5880], [5888, 5900], [5902, 5905], [5920, 5937], [5952, 5969], [5984, 5996], [5998, 6e3], [6016, 6067], [6103, 6103], [6108, 6108], [6112, 6121], [6128, 6137], [6160, 6169], [6176, 6264], [6272, 6276], [6279, 6312], [6314, 6314], [6320, 6389], [6400, 6430], [6470, 6509], [6512, 6516], [6528, 6571], [6576, 6601], [6608, 6618], [6656, 6678], [6688, 6740], [6784, 6793], [6800, 6809], [6823, 6823], [6917, 6963], [6981, 6987], [6992, 7001], [7043, 7072], [7086, 7141], [7168, 7203], [7232, 7241], [7245, 7293], [7296, 7304], [7312, 7354], [7357, 7359], [7401, 7404], [7406, 7411], [7413, 7414], [7418, 7418], [7424, 7615], [7680, 7957], [7960, 7965], [7968, 8005], [8008, 8013], [8016, 8023], [8025, 8025], [8027, 8027], [8029, 8029], [8031, 8061], [8064, 8116], [8118, 8124], [8126, 8126], [8130, 8132], [8134, 8140], [8144, 8147], [8150, 8155], [8160, 8172], [8178, 8180], [8182, 8188], [8304, 8305], [8308, 8313], [8319, 8329], [8336, 8348], [8450, 8450], [8455, 8455], [8458, 8467], [8469, 8469], [8473, 8477], [8484, 8484], [8486, 8486], [8488, 8488], [8490, 8493], [8495, 8505], [8508, 8511], [8517, 8521], [8526, 8526], [8528, 8585], [9312, 9371], [9450, 9471], [10102, 10131], [11264, 11310], [11312, 11358], [11360, 11492], [11499, 11502], [11506, 11507], [11517, 11517], [11520, 11557], [11559, 11559], [11565, 11565], [11568, 11623], [11631, 11631], [11648, 11670], [11680, 11686], [11688, 11694], [11696, 11702], [11704, 11710], [11712, 11718], [11720, 11726], [11728, 11734], [11736, 11742], [11823, 11823], [12293, 12295], [12321, 12329], [12337, 12341], [12344, 12348], [12353, 12438], [12445, 12447], [12449, 12538], [12540, 12543], [12549, 12591], [12593, 12686], [12690, 12693], [12704, 12735], [12784, 12799], [12832, 12841], [12872, 12879], [12881, 12895], [12928, 12937], [12977, 12991], [13312, 19903], [19968, 40956], [40960, 42124], [42192, 42237], [42240, 42508], [42512, 42539], [42560, 42606], [42623, 42653], [42656, 42735], [42775, 42783], [42786, 42888], [42891, 42943], [42946, 42954], [42997, 43009], [43011, 43013], [43015, 43018], [43020, 43042], [43056, 43061], [43072, 43123], [43138, 43187], [43216, 43225], [43250, 43255], [43259, 43259], [43261, 43262], [43264, 43301], [43312, 43334], [43360, 43388], [43396, 43442], [43471, 43481], [43488, 43492], [43494, 43518], [43520, 43560], [43584, 43586], [43588, 43595], [43600, 43609], [43616, 43638], [43642, 43642], [43646, 43695], [43697, 43697], [43701, 43702], [43705, 43709], [43712, 43712], [43714, 43714], [43739, 43741], [43744, 43754], [43762, 43764], [43777, 43782], [43785, 43790], [43793, 43798], [43808, 43814], [43816, 43822], [43824, 43866], [43868, 43881], [43888, 44002], [44016, 44025], [44032, 55203], [55216, 55238], [55243, 55291], [63744, 64109], [64112, 64217], [64256, 64262], [64275, 64279], [64285, 64285], [64287, 64296], [64298, 64310], [64312, 64316], [64318, 64318], [64320, 64321], [64323, 64324], [64326, 64433], [64467, 64829], [64848, 64911], [64914, 64967], [65008, 65019], [65136, 65140], [65142, 65276], [65296, 65305], [65313, 65338], [65345, 65370], [65382, 65470], [65474, 65479], [65482, 65487], [65490, 65495], [65498, 65500], [65536, 65547], [65549, 65574], [65576, 65594], [65596, 65597], [65599, 65613], [65616, 65629], [65664, 65786], [65799, 65843], [65856, 65912], [65930, 65931], [66176, 66204], [66208, 66256], [66273, 66299], [66304, 66339], [66349, 66378], [66384, 66421], [66432, 66461], [66464, 66499], [66504, 66511], [66513, 66517], [66560, 66717], [66720, 66729], [66736, 66771], [66776, 66811], [66816, 66855], [66864, 66915], [67072, 67382], [67392, 67413], [67424, 67431], [67584, 67589], [67592, 67592], [67594, 67637], [67639, 67640], [67644, 67644], [67647, 67669], [67672, 67702], [67705, 67742], [67751, 67759], [67808, 67826], [67828, 67829], [67835, 67867], [67872, 67897], [67968, 68023], [68028, 68047], [68050, 68096], [68112, 68115], [68117, 68119], [68121, 68149], [68160, 68168], [68192, 68222], [68224, 68255], [68288, 68295], [68297, 68324], [68331, 68335], [68352, 68405], [68416, 68437], [68440, 68466], [68472, 68497], [68521, 68527], [68608, 68680], [68736, 68786], [68800, 68850], [68858, 68899], [68912, 68921], [69216, 69246], [69248, 69289], [69296, 69297], [69376, 69415], [69424, 69445], [69457, 69460], [69552, 69579], [69600, 69622], [69635, 69687], [69714, 69743], [69763, 69807], [69840, 69864], [69872, 69881], [69891, 69926], [69942, 69951], [69956, 69956], [69959, 69959], [69968, 70002], [70006, 70006], [70019, 70066], [70081, 70084], [70096, 70106], [70108, 70108], [70113, 70132], [70144, 70161], [70163, 70187], [70272, 70278], [70280, 70280], [70282, 70285], [70287, 70301], [70303, 70312], [70320, 70366], [70384, 70393], [70405, 70412], [70415, 70416], [70419, 70440], [70442, 70448], [70450, 70451], [70453, 70457], [70461, 70461], [70480, 70480], [70493, 70497], [70656, 70708], [70727, 70730], [70736, 70745], [70751, 70753], [70784, 70831], [70852, 70853], [70855, 70855], [70864, 70873], [71040, 71086], [71128, 71131], [71168, 71215], [71236, 71236], [71248, 71257], [71296, 71338], [71352, 71352], [71360, 71369], [71424, 71450], [71472, 71483], [71680, 71723], [71840, 71922], [71935, 71942], [71945, 71945], [71948, 71955], [71957, 71958], [71960, 71983], [71999, 71999], [72001, 72001], [72016, 72025], [72096, 72103], [72106, 72144], [72161, 72161], [72163, 72163], [72192, 72192], [72203, 72242], [72250, 72250], [72272, 72272], [72284, 72329], [72349, 72349], [72384, 72440], [72704, 72712], [72714, 72750], [72768, 72768], [72784, 72812], [72818, 72847], [72960, 72966], [72968, 72969], [72971, 73008], [73030, 73030], [73040, 73049], [73056, 73061], [73063, 73064], [73066, 73097], [73112, 73112], [73120, 73129], [73440, 73458], [73648, 73648], [73664, 73684], [73728, 74649], [74752, 74862], [74880, 75075], [77824, 78894], [82944, 83526], [92160, 92728], [92736, 92766], [92768, 92777], [92880, 92909], [92928, 92975], [92992, 92995], [93008, 93017], [93019, 93025], [93027, 93047], [93053, 93071], [93760, 93846], [93952, 94026], [94032, 94032], [94099, 94111], [94176, 94177], [94179, 94179], [94208, 100343], [100352, 101589], [101632, 101640], [110592, 110878], [110928, 110930], [110948, 110951], [110960, 111355], [113664, 113770], [113776, 113788], [113792, 113800], [113808, 113817], [119520, 119539], [119648, 119672], [119808, 119892], [119894, 119964], [119966, 119967], [119970, 119970], [119973, 119974], [119977, 119980], [119982, 119993], [119995, 119995], [119997, 120003], [120005, 120069], [120071, 120074], [120077, 120084], [120086, 120092], [120094, 120121], [120123, 120126], [120128, 120132], [120134, 120134], [120138, 120144], [120146, 120485], [120488, 120512], [120514, 120538], [120540, 120570], [120572, 120596], [120598, 120628], [120630, 120654], [120656, 120686], [120688, 120712], [120714, 120744], [120746, 120770], [120772, 120779], [120782, 120831], [123136, 123180], [123191, 123197], [123200, 123209], [123214, 123214], [123584, 123627], [123632, 123641], [124928, 125124], [125127, 125135], [125184, 125251], [125259, 125259], [125264, 125273], [126065, 126123], [126125, 126127], [126129, 126132], [126209, 126253], [126255, 126269], [126464, 126467], [126469, 126495], [126497, 126498], [126500, 126500], [126503, 126503], [126505, 126514], [126516, 126519], [126521, 126521], [126523, 126523], [126530, 126530], [126535, 126535], [126537, 126537], [126539, 126539], [126541, 126543], [126545, 126546], [126548, 126548], [126551, 126551], [126553, 126553], [126555, 126555], [126557, 126557], [126559, 126559], [126561, 126562], [126564, 126564], [126567, 126570], [126572, 126578], [126580, 126583], [126585, 126588], [126590, 126590], [126592, 126601], [126603, 126619], [126625, 126627], [126629, 126633], [126635, 126651], [127232, 127244], [130032, 130041], [131072, 173789], [173824, 177972], [177984, 178205], [178208, 183969], [183984, 191456], [194560, 195101], [196608, 201546]];
+
+// packages/safe-bash-command-llm/src/extract-range.ts
+function isWord(value) {
+  let low = 0, high = wordRanges.length - 1;
+  while (low <= high) {
+    const mid = low + high >>> 1;
+    const [start, end] = wordRanges[mid];
+    if (value < start) high = mid - 1;
+    else if (value > end) low = mid + 1;
+    else return true;
+  }
+  return false;
+}
+async function findExtractedRange(reader, last, signal) {
+  let cache = new Uint8Array(0);
+  let cacheStart = -1, work = 0;
+  async function byte(position2) {
+    signal.throwIfAborted();
+    if (++work % 4096 === 0) await yieldTurn9(signal);
+    if (position2 < 0 || position2 >= reader.size) throw new Error("Invalid extraction position");
+    if (position2 < cacheStart || position2 >= cacheStart + cache.length) {
+      cache = await reader.read(position2, Math.min(16384, reader.size - position2));
+      cacheStart = position2;
+      signal.throwIfAborted();
+      if (!cache.length || cache.length > Math.min(16384, reader.size - position2)) throw new Error("Invalid extraction read");
+    }
+    return cache[position2 - cacheStart];
+  }
+  async function line(start) {
+    let position2 = start, ticks = 0;
+    while (position2 < reader.size && await byte(position2) === 96) {
+      ticks++;
+      position2++;
+    }
+    let opening = ticks >= 3, closing = ticks >= 3;
+    while (position2 < reader.size) {
+      const value = await byte(position2);
+      if (value === 10) return { start, next: position2 + 1, ticks, opening, closing };
+      closing = closing && value === 32;
+      let point = value, width = 1;
+      if (value >= 194 && value <= 244) {
+        width = value < 224 ? 2 : value < 240 ? 3 : 4;
+        point = value & (width === 2 ? 31 : width === 3 ? 15 : 7);
+        for (let i = 1; i < width; i++) {
+          if (position2 + i >= reader.size) {
+            opening = false;
+            width = 1;
+            break;
+          }
+          const continuation = await byte(position2 + i);
+          if (continuation < 128 || continuation > 191) {
+            opening = false;
+            width = 1;
+            break;
+          }
+          point = point << 6 | continuation & 63;
+        }
+      } else if (value >= 128) opening = false;
+      opening = opening && isWord(point);
+      position2 += width;
+    }
+    return { start, next: reader.size, ticks, opening: false, closing };
+  }
+  const failedLengths = new Uint8Array(16384);
+  let position = 0, selected;
+  while (position < reader.size) {
+    const candidate = await line(position);
+    position = candidate.next;
+    if (!candidate.opening) continue;
+    if (candidate.ticks < failedLengths.length * 8 && failedLengths[candidate.ticks >>> 3] & 1 << (candidate.ticks & 7)) continue;
+    let matched = false;
+    let search = candidate.next;
+    while (search < reader.size) {
+      const ending = await line(search);
+      search = ending.next;
+      if (ending.closing && ending.ticks === candidate.ticks) {
+        matched = true;
+        selected = { start: candidate.next, end: ending.start };
+        if (!last) return selected;
+        position = ending.next;
+        break;
+      }
+    }
+    if (!matched && candidate.ticks < failedLengths.length * 8) failedLengths[candidate.ticks >>> 3] |= 1 << (candidate.ticks & 7);
+  }
+  return selected;
+}
+
+// packages/safe-bash-command-llm/src/schemas.ts
+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/src/schema-input.ts
+import { FsError as FsError5 } from "../../safe-bash-contracts/index.js";
+import { pathOf as pathOf2 } from "../../safe-bash-contracts/path.js";
+async function resolveLlmSchemaInput(context, input, options) {
+  context.signal.throwIfAborted();
+  let schema;
+  const trimmed = input.trim();
+  if (trimmed.startsWith("t:")) {
+    const name = trimmed.slice(2);
+    const template2 = await options.loadTemplate(name);
+    schema = template2.schema_object;
+    if (!schema) throw new Error("Template '" + name + "' has no schema");
+  } else {
+    if (trimmed.startsWith("{")) {
+      try {
+        schema = JSON.parse(input);
+      } catch {
+      }
+    }
+    if (schema === void 0 && (trimmed.includes(" ") || input.includes(","))) schema = parseLlmSchemaDsl(input);
+    if (schema === void 0) {
+      const path = pathOf2(context, input);
+      let stat;
+      try {
+        stat = await context.fs.stat(path, { signal: context.signal });
+      } catch (error) {
+        if (!(error instanceof FsError5) || error.code !== "ENOENT") throw error;
+      }
+      if (stat) {
+        const source = await fileSource({ fs: context.fs, path, signal: context.signal, maxBytes: options.maxBytes ?? Infinity, expectedStat: stat });
+        let text = "";
+        const decoder = new TextDecoder("utf-8", { fatal: true });
+        try {
+          for await (const bytes of source.bytes) {
+            options.admitBytes?.(bytes.byteLength);
+            text += decoder.decode(bytes, { stream: true });
+          }
+          text += decoder.decode();
+        } finally {
+          await source.dispose();
+        }
+        try {
+          schema = JSON.parse(text);
+        } catch {
+          throw new Error("Schema file contained invalid JSON");
+        }
+      }
+    }
+  }
+  context.signal.throwIfAborted();
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) throw new Error("Invalid schema");
+  return options.multi ? { type: "object", properties: { items: { type: "array", items: schema } }, required: ["items"] } : schema;
+}
+
+// packages/safe-bash-command-llm/src/configuration-command.ts
+async function configurationCommand(context, service, args, output, diagnostic, admitInput, maxConfigurationBytes = Infinity) {
+  if (args.length === 1 && args[0] === "--version") {
+    await output("llm, version 0.27.1\n");
+    return true;
+  }
+  const keysCmd = args[0] === "keys";
+  const aliases = args[0] === "aliases";
+  const defaults = args[0] === "models" && args[1] === "default";
+  const options = args[0] === "models" && args[1] === "options";
+  if (!keysCmd && !aliases && !defaults && !options) return false;
+  const configuration = createLlmConfiguration(context, maxConfigurationBytes);
+  if (keysCmd) {
+    const tokens2 = args.slice(1), sub = tokens2[0];
+    if (sub === "path" && tokens2.length === 1) {
+      await output(`${configuration.directory}/keys.json
+`);
+      return true;
+    }
+    if (sub === void 0 || sub === "list" && tokens2.length === 1) {
+      const path = `${configuration.directory}/keys.json`;
+      let exists = true;
+      try {
+        await context.fs.lstat(path, { signal: context.signal });
+      } catch {
+        exists = false;
+      }
+      if (!exists) {
+        await output("No keys found\n");
+        return true;
+      }
+      const stored = await configuration.keys();
+      for (const key of Object.keys(stored).sort()) {
+        await output(`${key}
+`);
+      }
+      return true;
+    }
+    if (sub === "get" && tokens2.length === 2) {
+      await output(`${await configuration.getKey(tokens2[1])}
+`);
+      return true;
+    }
+    if (sub === "set") {
+      let name;
+      let value;
+      for (let i = 1; i < tokens2.length; i++) {
+        const token = tokens2[i];
+        if (token === "--value") {
+          if (++i >= tokens2.length) throw new Error("Option '--value' requires an argument");
+          value = tokens2[i];
+        } else if (token.startsWith("--value=")) {
+          value = token.slice(8);
+        } else if (token.startsWith("-")) {
+          throw new Error(`No such option: ${token}`);
+        } else if (name === void 0) {
+          name = token;
+        } else {
+          throw new Error("Unexpected extra arguments");
+        }
+      }
+      if (!name) throw new Error("Missing argument 'NAME'");
+      if (value === void 0) {
+        let stdinText = "";
+        const decoder = new TextDecoder();
+        for await (const chunk of context.stdin) {
+          context.signal.throwIfAborted();
+          admitInput(chunk.byteLength, true);
+          stdinText += decoder.decode(chunk, { stream: true });
+        }
+        stdinText += decoder.decode();
+        value = stdinText.replace(/\r?\n$/, "");
+      }
+      await configuration.setKey(name, value);
+      return true;
+    }
+    throw new Error("Invalid keys command");
+  }
+  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/src/model-selection.ts
+import { yieldTurn as yieldTurn10 } from "../../safe-bash-contracts/yield.js";
+function getLlmModelAliases({ provider, model }, configured) {
+  const aliases = new Set(model.aliases);
+  for (const [alias, target] of Object.entries(configured)) {
+    if (target === model.id || target === `${provider.name}/${model.id}` || model.aliases?.includes(target)) aliases.add(alias);
+  }
+  return [...aliases];
+}
+async function selectLlmModelByQuery(models, queries, configuredAliases = {}, signal) {
+  if (!queries.length) throw new TypeError("Model selection requires a query");
+  let selected;
+  const normalized = queries.map((query) => query.toLowerCase());
+  for (let index = 0; index < models.length; index++) {
+    signal?.throwIfAborted();
+    if (signal && index && index % 256 === 0) await yieldTurn10(signal);
+    const entry = models[index];
+    const terms = [entry.model.displayName ?? `${entry.provider.name}: ${entry.model.id}`, ...getLlmModelAliases(entry, configuredAliases), ...entry.model.asyncModel ? [entry.model.id] : []].map((value) => value.toLowerCase());
+    if (normalized.every((query) => terms.some((term) => term.includes(query))) && (!selected || [...entry.model.id].length < [...selected.model.id].length)) selected = entry;
+  }
+  signal?.throwIfAborted();
+  if (!selected) throw new Error(`No model found matching queries ${queries.join(", ")}`);
+  return selected;
+}
+
+// packages/safe-bash-command-llm/src/models-list.ts
+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, usage3 = true) {
+    super((usage3 ? "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, maxConfigurationBytes = Infinity) {
+  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, help2 = 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") {
+      help2 = 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 (help2) {
+    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, maxConfigurationBytes);
+  const configuredAliases = await configuration.aliases();
+  const shownDescriptions = /* @__PURE__ */ new Set();
+  for (const { provider, model: syncModel } of service.models) {
+    await step();
+    const aliases = getLlmModelAliases({ provider, model: syncModel }, configuredAliases);
+    const description = syncModel.displayName ?? `${provider.name}: ${syncModel.id}`;
+    const terms = [description, ...aliases, ...syncModel.asyncModel ? [syncModel.id] : []].map((value) => value.toLowerCase());
+    if (!queries.every((query) => terms.some((term) => term.includes(query.toLowerCase())))) continue;
+    if (selected.length && !selected.some((value) => value === syncModel.id || aliases.includes(value))) continue;
+    if (schemas && !syncModel.capabilities?.includes("schema") || tools && !syncModel.capabilities?.includes("tools") || asyncModels && !syncModel.asyncModel) continue;
+    const model = asyncModels ? service.resolve(syncModel.id, { async: true }).model : syncModel;
+    let output = (model.displayName ?? `${provider.name}: ${model.id}`) + (aliases.length ? ` (aliases: ${aliases.join(", ")})` : "");
+    if (model.outputType) output += `
+  Output type: ${model.outputType}`;
+    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", object: "dict", array: "list" }[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(", ")}`;
+    const features = [
+      ...model.canStream ? ["streaming"] : [],
+      ...model.capabilities?.includes("schema") ? ["schemas"] : [],
+      ...model.capabilities?.includes("tools") ? ["tools"] : [],
+      ...syncModel.asyncModel ? ["async"] : []
+    ];
+    if (options && features.length) output += "\n  Features:\n" + features.map((feature) => `  - ${feature}`).join("\n");
+    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/src/command.ts
+var llmReferenceVersion = "0.27.1";
+var LlmPromptUsageError = class extends Error {
+};
+async function parse(length, text, step, chat = false) {
+  const parsed = { toolNames: [], functions: [], chainLimit: 5, prompt: "", queries: [], fragments: [], systemFragments: [], 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 || !argument.startsWith("-") || argument === "-") {
+      operands.push(argument);
+      continue;
+    }
+    if (argument === "--") {
+      ended = true;
+      continue;
+    }
+    const equals = argument.indexOf("="), long = argument.startsWith("--");
+    for (let cursor = long ? 0 : 1; cursor < argument.length; cursor++) {
+      await step();
+      const flag = long ? argument.slice(0, equals < 0 ? void 0 : equals) : "-" + argument[cursor];
+      if (chat) {
+        if (flag === "-h" || flag === "--help") {
+          if (long && equals >= 0) throw new LlmPromptUsageError(`Error: Option '${flag}' does not take a value.`);
+          parsed.help = true;
+          if (long) break;
+          continue;
+        }
+        if (!["--td", "--tools-debug", "--ta", "--tools-approve", "--no-stream", "--functions", "-T", "--tool", "--cl", "--chain-limit", "-f", "--fragment", "--sf", "--system-fragment", "-m", "--model", "-s", "--system", "-o", "--option", "-t", "--template", "-p", "--param", "--key"].includes(flag))
+          throw new LlmPromptUsageError(`Usage: llm chat [OPTIONS]
+Try 'llm chat -h' for help.
+
+Error: No such option: ${flag}`);
+      }
+      const boolean = ["--async", "--td", "--tools-debug", "--ta", "--tools-approve", "--no-log", "-n", "-x", "--extract", "--xl", "--extract-last", "-u", "--usage", "--no-stream"].includes(flag);
+      if (boolean) {
+        if (long && equals >= 0) throw new LlmPromptUsageError(`Error: Option '${flag}' does not take a value.`);
+        if (["-x", "--extract", "--xl", "--extract-last"].includes(flag)) {
+          parsed.extract = flag === "--xl" || flag === "--extract-last" ? "last" : parsed.extract ?? "first";
+          parsed.noStream = true;
+        } else if (flag === "-u" || flag === "--usage") parsed.usage = true;
+        else if (flag === "--no-stream") parsed.noStream = true;
+        else if (flag === "--async") parsed.async = true;
+        else if (flag === "--ta" || flag === "--tools-approve") parsed.toolsApprove = true;
+        else if (flag === "--td" || flag === "--tools-debug") parsed.toolsDebug = true;
+        if (long) break;
+        continue;
+      }
+      if (!["--functions", "-T", "--tool", "--cl", "--chain-limit", "-f", "--fragment", "--sf", "--system-fragment", "-q", "--query", "-m", "--model", "-s", "--system", "-o", "--option", "-a", "--attachment", "--at", "--attachment-type", "-t", "--template", "--save", "-p", "--param", "--key", "--schema", "--schema-multi"].includes(flag)) throw new Error(`Unknown option: ${flag}`);
+      const attached = long ? equals < 0 ? void 0 : argument.slice(equals + 1) : argument.slice(cursor + 1) || void 0;
+      const arity = ["-o", "--option", "-p", "--param", "--at", "--attachment-type"].includes(flag) ? 2 : 1;
+      if (length - index - 1 < arity - (attached === void 0 ? 0 : 1)) throw new LlmPromptUsageError(`Error: Option '${flag}' requires ${arity === 2 ? "2 arguments" : "an argument"}.`);
+      const value = attached ?? text(++index);
+      if (flag === "--functions") parsed.functions.push(value);
+      else if (flag === "-T" || flag === "--tool") parsed.toolNames.push(value);
+      else if (flag === "--cl" || flag === "--chain-limit") {
+        const integer = tokenInteger(value);
+        if (integer === void 0) throw new LlmPromptUsageError(`Usage: llm prompt [OPTIONS] [PROMPT]
+Try 'llm prompt --help' for help.
+
+Error: Invalid value for '--cl' / '--chain-limit': '${value}' is not a valid integer.`);
+        parsed.chainLimit = BigInt(integer);
+      } else if (flag === "-f" || flag === "--fragment") parsed.fragments.push(value);
+      else if (flag === "--sf" || flag === "--system-fragment") parsed.systemFragments.push(value);
+      else if (flag === "-q" || flag === "--query") parsed.queries.push(value);
+      else if (flag === "-t" || flag === "--template") parsed.template = value;
+      else if (flag === "--schema") parsed.schema = value;
+      else if (flag === "--schema-multi") parsed.schemaMulti = value;
+      else if (flag === "--key") parsed.key = value;
+      else if (flag === "--save") parsed.save = value;
+      else if (flag === "-p" || flag === "--param") Object.defineProperty(parsed.params, value, { value: text(++index), 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] = text(++index);
+      else if (flag === "--at" || flag === "--attachment-type") parsed.attachments.push({ path: value, mimeType: text(++index) });
+      else parsed.attachments.push({ path: value });
+      break;
+    }
+  }
+  if (parsed.help) return parsed;
+  if (chat && operands.length) throw new LlmPromptUsageError(`Usage: llm chat [OPTIONS]
+Try 'llm chat -h' for help.
+
+Error: Got unexpected extra argument${operands.length === 1 ? "" : "s"} (${operands.join(" ")})`);
+  if (operands.length > 1) throw new LlmPromptUsageError(`Usage: llm prompt [OPTIONS] [PROMPT]
+Try 'llm prompt --help' for help.
+
+Error: Got unexpected extra argument${operands.length === 2 ? "" : "s"} (${operands.slice(1).join(" ")})`);
+  parsed.prompt = operands[0] ?? "";
+  parsed.promptSupplied = operands.length > 0;
+  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, templateLoaderOptions, collections, fragmentLoaders, tools, loadTools) {
+  context.signal.throwIfAborted();
+  const controller = new AbortController();
+  const operation = createOutputOperation(context, context.stdout);
+  const signal = AbortSignal.any([operation.signal, controller.signal]);
+  inheritYieldCheckpoint4(context.signal, signal);
+  let iterator;
+  let responseUsage;
+  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 yieldTurn11(signal);
+  };
+  let outputSpool;
+  let usageSpool;
+  let outputBytes2 = 0;
+  let outputFailed = false;
+  const writeOutput = async (sink, chunk) => {
+    try {
+      await sink.write(chunk);
+    } catch (error) {
+      outputFailed = true;
+      throw error;
+    }
+  };
+  const admitOutput = (size) => {
+    if (size > (limits?.maxOutputBytes ?? Infinity) - outputBytes2) throw new FsError6("EFBIG", { message: "llm output byte limit exceeded" });
+    outputBytes2 += size;
+  };
+  const write = async (chunk, immediate = false) => {
+    admitOutput(chunk.byteLength);
+    if (outputSpool && !immediate) {
+      await outputSpool.write(chunk);
+      return;
+    }
+    await writeOutput(operation.output, chunk);
+  };
+  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;
+    }
+  };
+  const input = createLlmInputBudget(limits);
+  let shellInputBytes = 0;
+  const admitInput = (size, materialized = false) => {
+    context.inputBudget?.check(shellInputBytes + size);
+    input.admit(size, materialized);
+    shellInputBytes += size;
+  };
+  const admitBuffered = (size) => input.admit(size, true);
+  const functionSessions = /* @__PURE__ */ new Set();
+  const loadDefinitions = async (definitions, toolNames = [], discovery = false, pluginQuery) => {
+    if (!loadTools) throw new Error("Python tool loading is not configured");
+    const diagnostic = operation.child(context.stderr).output;
+    const loaded = await operation.acquire(async () => {
+      const value = await loadTools({
+        definitions,
+        toolNames,
+        discovery,
+        ...pluginQuery ? { pluginQuery } : {},
+        context: { ...context, signal, stdout: { write: (bytes) => write(bytes, true) }, stderr: { write: async (bytes) => {
+          admitOutput(bytes.length);
+          await writeOutput(diagnostic, bytes);
+        } } },
+        maxInputBytes: input.remaining(true),
+        maxOutputBytes: limits?.maxOutputBytes ?? Infinity
+      });
+      let closing;
+      return { tools: value.tools, ...value.plugins ? { plugins: value.plugins } : {}, ...value.toolboxes ? { toolboxes: value.toolboxes } : {}, close: () => closing ??= Promise.resolve().then(() => value.close()) };
+    }, (value) => value.close());
+    functionSessions.add(loaded);
+    return loaded;
+  };
+  const invocationLoaders = { ...templateLoaderOptions, get maxBytes() {
+    return input.remaining(true);
+  }, admitBytes: admitBuffered };
+  try {
+    let argumentsValue = getCommandArguments(context);
+    const argumentText = (index) => {
+      const value = argumentsValue.values[index];
+      if (value === void 0) throw new Error("Missing option argument");
+      input.admit(shellValueByteLength3(value), true);
+      const bytes = argumentsValue.bytes(index);
+      if (!bytes) throw new Error("Missing option argument");
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+    };
+    let eager;
+    let separator;
+    for (let index = 0; index < argumentsValue.args.length; index++) {
+      await step();
+      const token = argumentsValue.args[index];
+      if (token === "--") {
+        separator = index;
+        break;
+      }
+      if (!token.startsWith("-") || token === "-") break;
+      if (token.startsWith("--")) {
+        const equals = token.indexOf("=");
+        const flag = equals < 0 ? token : token.slice(0, equals);
+        if (flag !== "--version" && flag !== "--help") continue;
+        argumentText(index);
+        if (equals >= 0) {
+          await writeDiagnostic2(context.stderr, `Error: Option '${flag}' does not take a value.
+`, signal);
+          return { exitCode: 2 };
+        }
+        eager ??= flag === "--version" ? "version" : "help";
+      } else {
+        for (let cursor = 1; cursor < token.length; cursor++) {
+          await step();
+          if (token[cursor] !== "h") continue;
+          argumentText(index);
+          eager ??= "help";
+          break;
+        }
+      }
+    }
+    if (eager === "version") {
+      await emitText(`llm, version ${llmReferenceVersion}
+`);
+      return { exitCode: 0 };
+    }
+    if (eager === "help") {
+      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, -u/--usage; -- ends options\n");
+      return { exitCode: 0 };
+    }
+    if (separator !== void 0) {
+      argumentText(separator);
+      argumentsValue = argumentsValue.select(Array.from({ length: argumentsValue.args.length - 1 }, (_, position) => position < separator ? position : position + 1));
+    }
+    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] === "plugins") {
+      argumentText(0);
+      const tokens = Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1));
+      return { exitCode: await pluginsCommand(
+        tokens,
+        emitText,
+        (text) => writeDiagnostic2(context.stderr, text, signal),
+        step,
+        signal,
+        loadTools ? async (query) => {
+          const session = await loadDefinitions([], [], false, query);
+          if (!session.plugins) throw new Error("Python runtime did not return plugin metadata");
+          return session.plugins;
+        } : void 0
+      ) };
+    }
+    if (argumentsValue.args[0] === "tools") {
+      argumentText(0);
+      const tokens = Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1));
+      return { exitCode: await toolsCommand(tokens, tools, emitText, (text) => writeDiagnostic2(context.stderr, text, signal), step, signal, loadTools ? loadDefinitions : void 0) };
+    }
+    if (argumentsValue.args[0] === "fragments") {
+      if (argumentsValue.args[1] !== "loaders") {
+        await writeDiagnostic2(context.stderr, "Error: Fragment history is host-owned. Use a file, URL, or registered loader.\n", signal);
+        return { exitCode: 2 };
+      }
+      const tokens = Array.from({ length: argumentsValue.args.length - 2 }, (_, index) => argumentText(index + 2));
+      return { exitCode: await fragmentLoaderCommand(tokens, fragmentLoaders, emitText, (text) => writeDiagnostic2(context.stderr, text, signal)) };
+    }
+    if (argumentsValue.args[0] === "schemas" && argumentsValue.args[1] !== "dsl") {
+      await writeDiagnostic2(context.stderr, "Error: Stored schema history is host-owned. Use an inline schema, file, template, or 'llm schemas dsl'.\n", signal);
+      return { exitCode: 2 };
+    }
+    if (argumentsValue.args[0] === "schemas" && argumentsValue.args[1] === "dsl") {
+      const tokens = Array.from({ length: argumentsValue.args.length - 2 }, (_, index) => argumentText(index + 2));
+      const usage3 = "Usage: llm schemas dsl [OPTIONS] INPUT\n";
+      if (tokens.includes("--help") || tokens.includes("-h")) {
+        await emitText(usage3 + "\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 inputs.push(token);
+      }
+      failure ??= inputs.length === 0 ? "Missing argument 'INPUT'." : inputs.length > 1 ? `Got unexpected extra argument (${inputs[1]})` : void 0;
+      if (failure) {
+        await writeDiagnostic2(context.stderr, usage3 + "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] === "collections" || argumentsValue.args[0] === "similar" || argumentsValue.args[0] === "embed-multi" || collections && argumentsValue.args[0] === "embed") {
+      const tokens = Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1));
+      if (!collections) {
+        await writeDiagnostic2(context.stderr, "Error: Collection storage is not configured\n", signal);
+        return { exitCode: 1 };
+      }
+      return { exitCode: await collections.execute({ context: { ...context, signal }, service, command: argumentsValue.args[0], tokens, write, diagnostic: (text) => writeDiagnostic2(context.stderr, text, signal), step, admit: admitInput, maxConfigurationBytes: limits?.maxConfigurationBytes ?? Infinity, maxInputBytes: limits?.maxInputBytes ?? Infinity }) };
+    }
+    if (argumentsValue.args[0] === "embed") {
+      const tokens = Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1));
+      return { exitCode: await embeddingCommand({ ...context, signal }, service, tokens, write, (text) => writeDiagnostic2(context.stderr, text, signal), step, admitInput, limits?.maxConfigurationBytes) };
+    }
+    if (argumentsValue.args[0] === "embed-models") {
+      const tokens = Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1));
+      return { exitCode: await embeddingModelsCommand({ ...context, signal }, service, tokens, emitText, (text) => writeDiagnostic2(context.stderr, text, signal), step, limits?.maxConfigurationBytes) };
+    }
+    if (argumentsValue.args[0] === "templates") {
+      let exitCode = 0;
+      try {
+        exitCode = await createLlmTemplateStore(context, invocationLoaders).command(Array.from({ length: argumentsValue.args.length - 1 }, (_, index) => argumentText(index + 1)), emitText, (text) => writeDiagnostic2(context.stderr, text, signal));
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : "Template failed"}`);
+      }
+      return { exitCode };
+    }
+    const configurationInvocation = argumentsValue.args[0] === "keys" || 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, (text) => writeDiagnostic2(context.stderr, text, signal), admitInput, limits?.maxConfigurationBytes)) 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, limits?.maxConfigurationBytes);
+      return { exitCode: 0 };
+    }
+    const isChat = argumentsValue.args[0] === "chat";
+    const promptOffset = argumentsValue.args[0] === "prompt" || isChat ? 1 : 0;
+    let args = await parse(argumentsValue.args.length - promptOffset, (index) => argumentText(index + promptOffset), step, isChat);
+    if (args.help) {
+      await emitText(chatHelp);
+      return { exitCode: 0 };
+    }
+    if (!args.toolsDebug && context.env.LLM_TOOLS_DEBUG) {
+      const raw = context.env.LLM_TOOLS_DEBUG, value = stripPythonWhitespace(raw).toLowerCase();
+      if (["1", "true", "t", "yes", "y", "on"].includes(value)) args.toolsDebug = true;
+      else if (!["", "0", "false", "f", "no", "n", "off"].includes(value)) throw new LlmPromptUsageError(`Usage: llm prompt [OPTIONS] [PROMPT]
+Try 'llm prompt --help' for help.
+
+Error: Invalid value for '--td' / '--tools-debug': '${raw}' is not a valid boolean. Recognized values: , 0, 1, f, false, n, no, off, on, t, true, y, yes`);
+    }
+    const configuration = createLlmConfiguration(context, limits?.maxConfigurationBytes, invocationLoaders);
+    if (args.model === void 0 && args.queries.length) {
+      try {
+        args.model = (await selectLlmModelByQuery(service.models, args.queries, await configuration.aliases(), signal)).model.id;
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : "Model selection failed"}`);
+      }
+    }
+    const templateStore = createLlmTemplateStore(context, invocationLoaders);
+    const schemaInput = args.schemaMulti ?? args.schema;
+    let schema = schemaInput ? await resolveLlmSchemaInput({ ...context, signal }, schemaInput, {
+      multi: Boolean(args.schemaMulti),
+      maxBytes: input.remaining(true),
+      admitBytes: admitBuffered,
+      loadTemplate: (name) => templateStore.load(name)
+    }) : void 0;
+    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) {
+      if (!isChat && stored.schema_object) schema = stored.schema_object;
+      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);
+    let entry;
+    try {
+      entry = args.save && selected === void 0 ? void 0 : service.resolve(model, args.async && !args.save ? { async: true } : void 0);
+    } catch (error) {
+      if (!args.async || args.save) throw error;
+      let detail = "";
+      for await (const bytes of pythonRepr(error instanceof Error ? error.message : String(error), signal)) {
+        detail += new TextDecoder().decode(bytes);
+        if (detail.length >= 4096) break;
+      }
+      throw new Error("Error: " + detail);
+    }
+    if (!args.save && entry?.model.canStream === false) args.noStream = true;
+    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;
+    if (isChat && args.promptSupplied) throw new LlmPromptUsageError(`Usage: llm chat [OPTIONS]
+Try 'llm chat -h' for help.
+
+Error: Got unexpected extra argument (${args.prompt})`);
+    const loadSelectedTools = async () => {
+      let selectedTools2;
+      try {
+        const definitions = [...stored?.functions && Object.getOwnPropertyDescriptor(stored, "functionsTrusted")?.value !== false ? [stored.functions] : [], ...args.functions];
+        const names = [...stored?.tools ?? [], ...args.toolNames];
+        const dynamicNames = names.filter((name) => !tools.has(name));
+        const loaded = definitions.length || loadTools && dynamicNames.length ? await loadDefinitions(definitions, dynamicNames) : { tools: [] };
+        if (!loadTools) selectedTools2 = [...loaded.tools, ...selectLlmTools(tools, names)];
+        else {
+          selectedTools2 = loaded.tools.filter((tool) => tool.selectionIndex === void 0);
+          const groups = /* @__PURE__ */ new Map();
+          for (const tool of loaded.tools) if (tool.selectionIndex !== void 0) {
+            const group = groups.get(tool.selectionIndex) ?? [];
+            group.push(tool);
+            groups.set(tool.selectionIndex, group);
+          }
+          let dynamicIndex = 0;
+          for (const name of names) {
+            if (tools.has(name)) selectedTools2.push(tools.get(name));
+            else {
+              selectedTools2.push(...groups.get(dynamicIndex) ?? []);
+              dynamicIndex++;
+            }
+          }
+        }
+      } catch (error) {
+        throw new Error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+      }
+      return selectedTools2;
+    };
+    let selectedTools = isChat ? await loadSelectedTools() : void 0;
+    const pendingChatFragments = [];
+    const chat = isChat ? createChatInput({ resolveFragments: async (paths) => {
+      pendingChatFragments.push(...await prepareFragments(paths, false));
+    }, context: { ...context, signal, stdout: { write: (bytes) => write(bytes, true) } }, operation, write: emitText, diagnostic: (text) => writeDiagnostic2(context.stderr, text, signal), admit: (size, materialized) => materialized ? input.materialize(size) : admitInput(size, false) }) : void 0;
+    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;
+        }
+      } }
+    });
+    const admittedFragments = /* @__PURE__ */ new WeakSet(), bufferedFragments = /* @__PURE__ */ new WeakSet();
+    const remoteFragments = /* @__PURE__ */ new WeakSet();
+    const pluginAttachments = [], pluginSourceAttachments = [];
+    const loadFragments = async function* (paths, system) {
+      for (const reference of paths) {
+        await step();
+        if (reference === "-") {
+          if (!chat) {
+            yield textSource("");
+            continue;
+          }
+          const source2 = { bytes: { async *[Symbol.asyncIterator]() {
+            const input2 = chat.approvalInput();
+            while (true) {
+              const next = await input2.next();
+              if (next.done) return;
+              yield next.value;
+            }
+          } }, async dispose() {
+          } };
+          admittedFragments.add(source2);
+          yield source2;
+          continue;
+        }
+        if (reference.startsWith("http://") || reference.startsWith("https://")) {
+          const fetch = context.capabilities?.fetch;
+          if (!fetch) throw new Error("Fragment URL loading is not configured");
+          const source2 = await operation.acquire(() => createLlmUrlFragmentSource({
+            url: reference,
+            fetch,
+            signal,
+            maxBytes: input.remaining(!streamed),
+            admitBytes: (size) => {
+              context.inputBudget?.check(shellInputBytes + size);
+              shellInputBytes += size;
+            }
+          }), (value) => value.dispose());
+          remoteFragments.add(source2);
+          yield source2;
+          continue;
+        }
+        if (getLlmFragmentPrefix(reference) !== void 0) {
+          try {
+            for await (const loaded of loadLlmPluginFragments(reference, fragmentLoaders, { fs: context.fs, cwd: context.cwd, signal, capabilities: context.capabilities, get maxBytes() {
+              return input.remaining(!streamed);
+            } }, !system)) {
+              const source2 = await operation.acquire(() => loaded.source, (value) => value.dispose());
+              if (loaded.type === "text") {
+                yield source2;
+                continue;
+              }
+              input.admitText(loaded.mimeType);
+              if (loaded.id !== void 0) input.admitText(loaded.id);
+              if (!acceptsMimeType(entry.model.attachmentTypes ?? [], loaded.mimeType)) throw new Error(`Model ${entry.model.id} does not accept ${loaded.mimeType}`);
+              const identity = loaded.id === void 0 ? {} : { id: loaded.id };
+              if (streamed) {
+                const spool = await operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal, "input"), (value) => value.close());
+                for await (const bytes of sourceBytes(source2.bytes, signal)) {
+                  admitInput(bytes.byteLength, false);
+                  await spool.write(bytes);
+                }
+                pluginSourceAttachments.push({ mimeType: loaded.mimeType, source: { bytes: spool.replay(), dispose: spool.close }, ...identity });
+              } else {
+                const chunks = [];
+                let size = 0;
+                for await (const bytes2 of sourceBytes(source2.bytes, signal)) {
+                  admitInput(bytes2.byteLength, true);
+                  chunks.push(bytes2.slice());
+                  size += bytes2.byteLength;
+                }
+                const bytes = new Uint8Array(size);
+                let offset = 0;
+                for (const chunk of chunks) {
+                  bytes.set(chunk, offset);
+                  offset += chunk.length;
+                }
+                pluginAttachments.push({ mimeType: loaded.mimeType, bytes, ...identity });
+              }
+            }
+          } catch (error) {
+            signal.throwIfAborted();
+            throw new Error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+          }
+          continue;
+        }
+        const path = pathOf3(context, reference);
+        let source;
+        try {
+          source = await operation.acquire(() => fileSource({ fs: context.fs, path, signal, maxBytes: input.remaining(!streamed) }), (value) => value.dispose());
+        } catch (error) {
+          if (error instanceof FsError6 && error.code === "ENOENT") throw new Error(`Error: Fragment '${reference}' not found`);
+          throw error;
+        }
+        yield source;
+      }
+    };
+    const admitFragment = (size, source) => {
+      if (admittedFragments.has(source)) {
+        if (!streamed && !bufferedFragments.has(source)) input.materialize(size);
+      } else if (remoteFragments.has(source)) input.admit(size, !streamed);
+      else admitInput(size, !streamed);
+    };
+    const prepareFragments = async (paths, system) => {
+      if (!paths.length) return [];
+      let hasText = false;
+      const source = await operation.acquire(() => createLlmFragmentSource({
+        fs: context.fs,
+        directory: context.cwd,
+        signal,
+        system,
+        normalizeNewlines: true,
+        fragments: { async *[Symbol.asyncIterator]() {
+          for await (const source2 of loadFragments(paths, system)) {
+            hasText = true;
+            yield source2;
+          }
+        } },
+        admitBytes: admitFragment,
+        admitSeparator: (size) => input.admit(size, !streamed)
+      }), (value) => value.dispose());
+      if (!hasText) {
+        await source.dispose();
+        return [];
+      }
+      const retained = { ...source, normalizeNewlines: false };
+      admittedFragments.add(retained);
+      bufferedFragments.add(retained);
+      return [retained];
+    };
+    const compose = async (paths, tail, system, prepared = []) => operation.acquire(
+      () => createLlmFragmentSource({ fs: context.fs, directory: context.cwd, signal, fragments: { async *[Symbol.asyncIterator]() {
+        yield* prepared;
+        yield* loadFragments(paths, system);
+      } }, tail, system, normalizeNewlines: true, admitBytes: admitFragment, admitSeparator: (size) => input.admit(size, !streamed) }),
+      (value) => value.dispose()
+    );
+    const chatMessages = [];
+    const initialArgs = args;
+    let chatTurn = 0;
+    let initialPromptFragments = [], initialSystemFragments = [];
+    const initialAttachments = [], initialSourceAttachments = [];
+    if (chat) {
+      validateModelOptions(entry.model, { ...await configuration.modelOptions(entry.model.id), ...args.options });
+      initialPromptFragments = await prepareFragments(args.fragments, false);
+      initialSystemFragments = await prepareFragments(args.systemFragments, true);
+      initialAttachments.push(...pluginAttachments);
+      initialSourceAttachments.push(...pluginSourceAttachments);
+      await emitText(`Chatting with ${entry.model.id}
+Type 'exit' or 'quit' to exit
+Type '!multi' to enter multiple lines, then '!end' to finish
+Type '!edit' to open your default editor and modify the prompt
+Type '!fragment <my_fragment> [<another_fragment> ...]' to insert one or more fragments
+`);
+    }
+    while (true) {
+      if (chat) {
+        pluginAttachments.length = 0;
+        pluginSourceAttachments.length = 0;
+      }
+      const chatPrompt = await chat?.next();
+      const preparedPrompt = [...chatPrompt?.includeInitialFragments ? initialPromptFragments : [], ...pendingChatFragments.splice(0)];
+      const preparedSystem = chatTurn ? [] : initialSystemFragments;
+      if (chat) {
+        if (chatPrompt.includeInitialFragments) {
+          pluginAttachments.push(...initialAttachments);
+          pluginSourceAttachments.push(...initialSourceAttachments);
+        }
+        args = {
+          ...initialArgs,
+          options: { ...initialArgs.options },
+          attachments: [...initialArgs.attachments],
+          fragments: [],
+          systemFragments: []
+        };
+        if (chatTurn) delete args.system;
+        if (stored) {
+          const decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+          args.prompt = "";
+          for await (const bytes of chatPrompt.spool.replay()) {
+            input.materialize(bytes.length);
+            args.prompt += decoder2.decode(bytes, { stream: true });
+          }
+          args.prompt += decoder2.decode();
+          args.promptSupplied = true;
+        }
+      }
+      let stdinIterator;
+      const openStdin = async (approval = false) => approval && chat ? chat.approvalInput() : stdinIterator ??= await operation.acquire(() => chatPrompt ? chatPrompt.spool.replay()[Symbol.asyncIterator]() : context.stdinInput ? { next: () => approval && context.stdinInput.readAvailable ? context.stdinInput.readAvailable(4096, signal, 10) : context.stdinInput.read(approval ? 1 : Math.min(65536, input.remaining(!stagePrompt) + 1), signal) } : context.stdin[Symbol.asyncIterator](), async (resource) => {
+        await resource.return?.();
+      });
+      let promptSpool;
+      let stdinBytes = 0;
+      const fragments = [];
+      const decoder = new TextDecoder("utf-8", { fatal: true });
+      const templateUsesInput = stored !== void 0 && llmTemplateUsesInput(stored);
+      const readTerminalPrompt = !args.promptSupplied && !args.save && !args.attachments.length && !schema && !args.fragments.length;
+      if (!(chat && stored) && (stored === void 0 || templateUsesInput) && (chat || !context.shellPredicates?.terminal(0) || readTerminalPrompt)) {
+        const stdin = await openStdin();
+        while (true) {
+          await step();
+          const result = await interrupted(() => stdin.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");
+          if (!chat) admitInput(chunk.byteLength, !stagePrompt);
+          else if (!stagePrompt) input.materialize(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 (stdinBytes && args.prompt) input.admit(1, !stagePrompt);
+      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 = {
+          ...schema === void 0 ? {} : { schema_object: schema },
+          ...args.model === void 0 ? {} : { model: entry.model.id },
+          ...prompt ? { prompt } : {},
+          ...args.system === void 0 ? {} : { system: args.system },
+          ...args.extract === "last" ? { extract_last: true } : args.extract === "first" ? { extract: true } : {},
+          ...Object.keys(args.params).length ? { defaults: args.params } : {},
+          ...Object.keys(args.options).length ? { options: args.options } : {},
+          ...args.functions.length ? { functions: args.functions.join("\n\n") } : {},
+          ...args.toolNames.length ? { tools: args.toolNames } : {},
+          ...args.fragments.length ? { fragments: args.fragments } : {},
+          ...args.systemFragments.length ? { system_fragments: args.systemFragments } : {},
+          ...attachments2.length ? { attachments: attachments2 } : {},
+          ...attachmentTypes.length ? { attachment_types: attachmentTypes } : {}
+        };
+        await templateStore.save(args.save, saved);
+        return { exitCode: 0 };
+      }
+      if (stored) {
+        try {
+          if (!chat && !args.extract && (stored.extract_last || stored.extract)) {
+            args.extract = stored.extract_last ? "last" : "first";
+            args.noStream = true;
+          }
+          const evaluated = evaluateLlmTemplate(stored, templateUsesInput ? prompt : "", args.params, input.admitText);
+          if (evaluated.prompt && !templateUsesInput && args.prompt) input.admit(1, true);
+          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 (chat && (stored ? ["exit", "quit"].includes(stripPythonWhitespace(prompt)) : chatPrompt.exit)) return { exitCode: 0 };
+      if (!entry) throw new Error("No model selected; use --model or configure defaultModel");
+      args.options = { ...await configuration.modelOptions(entry.model.id), ...chat ? {} : stored?.options, ...args.options };
+      args.attachments = [
+        ...(chat ? [] : stored?.attachments ?? []).map((path) => ({ path })),
+        ...args.attachments.filter((item) => item.mimeType === void 0),
+        ...(chat ? [] : stored?.attachment_types ?? []).map((item) => ({ path: item.value, mimeType: item.type })),
+        ...args.attachments.filter((item) => item.mimeType !== void 0)
+      ];
+      const attachments = [];
+      const sourceAttachments = [];
+      let composedPrompt, composedSystem;
+      const promptFragments = [...chat ? [] : stored?.fragments ?? [], ...args.fragments];
+      const systemFragments = [...chat ? [] : stored?.system_fragments ?? [], ...args.systemFragments];
+      const materialize = async (source) => {
+        const decoder2 = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true });
+        let result = "";
+        for await (const bytes of source.bytes) result += decoder2.decode(bytes, { stream: true });
+        return result + decoder2.decode();
+      };
+      if (promptFragments.length || preparedPrompt.length) {
+        composedPrompt = await compose(promptFragments, promptSpool ? { bytes: promptSpool.replay(), dispose: promptSpool.close } : textSource(prompt), false, preparedPrompt);
+        if (!streamed) prompt = await materialize(composedPrompt);
+      }
+      if (systemFragments.length || preparedSystem.length) {
+        composedSystem = await compose(systemFragments, textSource(args.system ?? ""), true, preparedSystem);
+        if (!streamed) args.system = await materialize(composedSystem);
+      }
+      for (const attachment of args.attachments) {
+        await step();
+        if (attachment.path.includes("://")) {
+          const reference = await resolveUrlAttachment({ ...context, signal }, attachment.path, attachment.mimeType);
+          if (attachment.mimeType === void 0) admitInput(shellValueByteLength3(reference.mimeType), true);
+          if (!acceptsMimeType(entry.model.attachmentTypes ?? [], reference.mimeType)) throw new Error(`Model ${entry.model.id} does not accept ${reference.mimeType}`);
+          if (acceptsMimeType(["image/*"], reference.mimeType)) {
+            if (!entry.model.attachmentUrls) throw new Error(`Model ${entry.model.id} does not support URL attachments`);
+            if (streamed) sourceAttachments.push(reference);
+            else attachments.push(reference);
+          } else {
+            const fetch = context.capabilities?.fetch;
+            if (!fetch) throw new Error("Attachment URL loading is not configured");
+            const source = await operation.acquire(() => createLlmUrlSource({
+              url: reference.url,
+              fetch,
+              signal,
+              maxBytes: input.remaining(!streamed),
+              admitBytes: (bytes2) => admitInput(bytes2, !streamed)
+            }), (source2) => source2.dispose());
+            const identity = acceptsMimeType(["application/pdf"], reference.mimeType) ? { id: await getLlmAttachmentUrlId(reference.url, signal) } : {};
+            if (streamed) sourceAttachments.push({ mimeType: reference.mimeType, source, ...identity });
+            else {
+              const chunks = [];
+              let size = 0;
+              for await (const chunk of source.bytes) {
+                chunks.push(chunk);
+                size += chunk.length;
+              }
+              const bytes2 = new Uint8Array(size);
+              let offset = 0;
+              for (const chunk of chunks) {
+                bytes2.set(chunk, offset);
+                offset += chunk.length;
+              }
+              attachments.push({ mimeType: reference.mimeType, bytes: bytes2, ...identity });
+            }
+          }
+          continue;
+        }
+        const path = pathOf3(context, attachment.path);
+        const stat = await interrupted(() => context.fs.stat(path, { signal }), signal);
+        context.inputBudget?.check(shellInputBytes + stat.size);
+        input.check(stat.size, !streamed);
+        const remainingBytes = Math.min(
+          input.remaining(!streamed),
+          (context.inputBudget?.maxBytes ?? Infinity) - shellInputBytes
+        );
+        if (streamed) {
+          const source = await operation.acquire(() => fileSource({ fs: context.fs, path, signal, maxBytes: remainingBytes, expectedStat: stat }), (source2) => source2.dispose());
+          const chunks = source.bytes[Symbol.asyncIterator]();
+          const first = await interrupted(() => chunks.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(() => chunks.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,
+          ...remainingBytes === Infinity ? {} : { maxBytes: remainingBytes }
+        }), signal);
+        signal.throwIfAborted();
+        if (!(bytes instanceof Uint8Array)) throw new TypeError("Attachment read must return Uint8Array");
+        admitInput(bytes.byteLength, true);
+        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), ...acceptsMimeType(["application/pdf"], mimeType) && !bytes.length ? { id: await attachmentBytesId(bytes, signal) } : {} });
+      }
+      selectedTools ??= await loadSelectedTools();
+      attachments.push(...pluginAttachments);
+      sourceAttachments.push(...pluginSourceAttachments);
+      const resolvedKey = args.key === void 0 ? void 0 : await configuration.resolveKey(args.key);
+      const request = {
+        ...args.async ? { async: true } : {},
+        ...schema === void 0 ? {} : { schema },
+        model: entry.model.id,
+        prompt,
+        ...args.system === void 0 ? {} : { system: args.system },
+        attachments,
+        options: args.options,
+        signal,
+        stream: !args.noStream,
+        ...resolvedKey === void 0 ? {} : { key: resolvedKey }
+      };
+      signal.throwIfAborted();
+      if (args.noStream) outputSpool = await operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal), (spool) => spool.close());
+      if (selectedTools.length || chat) {
+        const debugOutput = args.toolsDebug ? operation.child(context.stderr).output : void 0;
+        const events = promptToolChain({
+          ...chat ? { chatMessages } : {},
+          context: { ...context, signal },
+          operation,
+          service,
+          streamed,
+          tools: selectedTools,
+          ...debugOutput ? { debugWrite: async (bytes) => {
+            admitOutput(bytes.length);
+            await writeOutput(debugOutput, bytes);
+          } } : {},
+          ...args.toolsApprove ? { beforeCall: createToolApproval({ context: { ...context, signal }, openInput: () => openStdin(true), write: (bytes) => write(bytes, true), admitInput: chat ? () => {
+          } : admitInput }) } : {},
+          chainLimit: args.chainLimit,
+          maxOutputBytes: limits?.maxOutputBytes ?? Infinity,
+          remainingInput: () => input.remaining(!streamed),
+          admitInput,
+          textSource,
+          request: {
+            ...args.async ? { async: true } : {},
+            model: request.model,
+            options: request.options,
+            signal,
+            stream: request.stream,
+            ...schema === void 0 ? {} : { schema },
+            ...resolvedKey === void 0 ? {} : { key: resolvedKey },
+            prompt: (streamed ? composedPrompt : void 0) ?? (promptSpool ? { bytes: promptSpool.replay(), dispose: promptSpool.close } : textSource(prompt)),
+            ...streamed && composedSystem ? { system: composedSystem } : args.system === void 0 ? {} : { system: textSource(args.system) },
+            attachments: streamed ? sourceAttachments : attachments.map((attachment) => attachment.url === void 0 ? { mimeType: attachment.mimeType, ...attachment.id === void 0 ? {} : { id: attachment.id }, source: { bytes: { async *[Symbol.asyncIterator]() {
+              yield attachment.bytes;
+            } }, async dispose() {
+            } } } : attachment)
+          }
+        });
+        iterator = (async function* () {
+          try {
+            for await (const event of events) {
+              if (event.type === "text") yield event.text;
+              else if (event.type === "bytes") yield event.data;
+              else if (args.usage) {
+                usageSpool ??= await operation.acquire(() => createLlmSpool(context.fs, context.cwd, signal), (spool) => spool.close());
+                await usageSpool.write(new TextEncoder().encode("Token usage: "));
+                for await (const bytes of serializeLlmTokenUsage(event.response.usage, signal)) await usageSpool.write(bytes);
+                await usageSpool.write(Uint8Array.of(10));
+              }
+            }
+          } catch (error) {
+            signal.throwIfAborted();
+            if (outputFailed) throw error;
+            throw new Error(`Error: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        })()[Symbol.asyncIterator]();
+      } else if (streamed) {
+        const events = service.streamSources({
+          ...args.async ? { async: true } : {},
+          model: request.model,
+          options: request.options,
+          signal,
+          stream: request.stream,
+          prompt: composedPrompt ?? (promptSpool ? { bytes: promptSpool.replay(), dispose: promptSpool.close } : textSource(prompt)),
+          ...schema === void 0 ? {} : { schema },
+          ...composedSystem ? { system: composedSystem } : args.system === void 0 ? {} : { system: textSource(args.system) },
+          ...resolvedKey === void 0 ? {} : { key: resolvedKey },
+          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;
+            else responseUsage = event.response.usage;
+          }
+        })()[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;
+          if (result.value?.usage) responseUsage = result.value.usage;
+          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);
+        if (!args.extract) await write(Uint8Array.of(10));
+      }
+      if (outputSpool) for await (const chunk of outputSpool.replay(args.extract && text ? async (reader) => {
+        const range = await findExtractedRange(reader, args.extract === "last", signal);
+        return range && range.end > range.start ? range : void 0;
+      } : void 0)) await writeOutput(operation.output, chunk);
+      if (args.extract && text) await writeOutput(operation.output, Uint8Array.of(10));
+      if (usageSpool) await pipeBytes2(usageSpool.replay(), context.stderr, signal);
+      else if (args.usage) {
+        await writeDiagnostic2(context.stderr, "Token usage: ", signal);
+        await pipeBytes2(serializeLlmTokenUsage(responseUsage, signal), context.stderr, signal);
+        await writeDiagnostic2(context.stderr, "\n", signal);
+      }
+      if (!chat) return { exitCode: 0 };
+      await outputSpool?.close();
+      outputSpool = void 0;
+      await usageSpool?.close();
+      usageSpool = void 0;
+      await chatPrompt.spool.close();
+      ended = false;
+      iterator = void 0;
+      responseUsage = void 0;
+      chatTurn++;
+    }
+  } catch (error) {
+    context.signal.throwIfAborted();
+    operation.signal.throwIfAborted();
+    controller.abort(error);
+    if (outputFailed) throw error;
+    await operation.close();
+    await writeDiagnostic2(context.stderr, `${error instanceof Error || error instanceof TypeError ? error.message.slice(0, 4096) : "llm provider failed"}
+`, context.signal);
+    return { exitCode: error instanceof LlmModelsUsageError || error instanceof LlmPromptUsageError ? 2 : 1 };
+  } finally {
+    try {
+      await Promise.all([...functionSessions].map((session) => session.close()));
+    } finally {
+      controller.abort(new Error("llm request closed"));
+      await operation.close();
+    }
+  }
+}
+function createLlmCommand(options = {}) {
+  for (const [name, value] of Object.entries(options.limits ?? {})) {
+    if (value === void 0 || value === Infinity) continue;
+    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 maxRemoteBytes = options.maxRemoteTemplateBytes ?? limits?.maxInputBytes ?? Infinity;
+  const templateLoaderOptions = { maxRemoteBytes, ...options.templateLoaders ? { loaders: options.templateLoaders } : {} };
+  const service = options.service ?? createLlmService({ ...options, providers: options.providers ?? [] });
+  const collections = options.collections;
+  return { name: "llm", description: "Query injected language and media models", execute: (context) => execute(context, service, limits, templateLoaderOptions, collections, options.fragmentLoaders ?? /* @__PURE__ */ new Map(), options.tools ?? /* @__PURE__ */ new Map(), options.loadTools) };
+}
+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 {
+  serializeLlmTokenUsage,
+  createLlmToolRegistry,
+  selectLlmTools,
+  LlmCancelToolCall,
+  executeLlmToolCalls,
+  createLlmInputBudget,
+  streamLlmToolChain,
+  getLlmFragmentPrefix,
+  createLlmFragmentLoaders,
+  loadLlmPluginFragments,
+  createLlmUrlSource,
+  createLlmUrlFragmentSource,
+  createLlmFragmentSource,
+  validateLlmTemplateParameters,
+  llmTemplateUsesInput,
+  evaluateLlmTemplate,
+  createLlmTemplateStore,
+  findExtractedRange,
+  parseLlmSchemaDsl,
+  resolveLlmSchemaInput,
+  getLlmModelAliases,
+  selectLlmModelByQuery,
+  llmReferenceVersion,
+  createLlmCommand,
+  createLlmCommands,
+  llmCommands
+};