@poe-platform/safe-bash 0.1.822 → 0.1.824

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

@@ -1,1466 +0,0 @@
-import {
-  createPythonPackageEnvironment,
-  pythonDocumentPackages
-} from "./chunk-R4NPYXQX.js";
-import {
-  pythonShellDispatchActive
-} from "./chunk-NHAG4DWL.js";
-import {
-  PythonInvocationError,
-  parsePythonInvocation
-} from "./chunk-5EFNQ6FY.js";
-import {
-  pythonLlmProvider
-} from "./chunk-YYRVGXJH.js";
-import {
-  PythonFailure,
-  isPythonFailureCategory,
-  reportPythonFailure
-} from "./chunk-TO6UNFEF.js";
-import {
-  createPythonHostBridge
-} from "./chunk-EPYJSPOY.js";
-
-// packages/safe-bash-command-python/src/executor.ts
-import { PythonFileSystem, PythonStatTranslator } from "@poe-platform/safe-fs/core";
-import { validateExitCode } from "../../safe-bash-contracts/command.js";
-import { openCommandFile } from "../../safe-bash-contracts/filesystem-descriptor.js";
-
-// packages/safe-bash-command-python/src/reply.ts
-import { FsError } from "../../safe-bash-contracts/errors.js";
-function encodePythonReply(value, maxBytes) {
-  let used = 0;
-  const ancestors = /* @__PURE__ */ new Set();
-  const reserve = (bytes) => {
-    used += bytes;
-    if (used > maxBytes) throw new FsError("EFBIG", { syscall: "python reply" });
-  };
-  const string = (text) => {
-    if (text.length + 2 > maxBytes - used) throw new FsError("EFBIG", { syscall: "python reply" });
-    reserve(2);
-    for (let index = 0; index < text.length; index++) {
-      const code = text.charCodeAt(index);
-      if (code < 32) reserve([8, 9, 10, 12, 13].includes(code) ? 2 : 6);
-      else if (code === 34 || code === 92) reserve(2);
-      else if (code < 128) reserve(1);
-      else if (code < 2048) reserve(2);
-      else if (code >= 55296 && code <= 56319 && text.charCodeAt(index + 1) >= 56320 && text.charCodeAt(index + 1) <= 57343) {
-        reserve(4);
-        index++;
-      } else reserve(code >= 55296 && code <= 57343 ? 6 : 3);
-    }
-    return text;
-  };
-  const own = (input, depth) => {
-    if (depth > 64) throw new FsError("EFBIG", { syscall: "python reply" });
-    if (input === null || input === void 0) {
-      reserve(4);
-      return null;
-    }
-    if (typeof input === "string") return string(input);
-    if (typeof input === "number") {
-      reserve(Number.isFinite(input) ? String(input).length : 4);
-      return input;
-    }
-    if (typeof input === "boolean") {
-      reserve(input ? 4 : 5);
-      return input;
-    }
-    if (typeof input !== "object") throw new TypeError("Invalid Python reply value");
-    if (ancestors.has(input)) throw new TypeError("Cyclic Python reply value");
-    ancestors.add(input);
-    try {
-      if (input instanceof Uint8Array || Array.isArray(input)) {
-        if (input.length > maxBytes - used) throw new FsError("EFBIG", { syscall: "python reply" });
-        reserve(2);
-        const output2 = [];
-        for (let index = 0; index < input.length; index++) {
-          if (index) reserve(1);
-          const descriptor = Object.getOwnPropertyDescriptor(input, String(index));
-          if (descriptor && !("value" in descriptor)) throw new TypeError("Accessor Python reply");
-          output2.push(own(descriptor?.value, depth + 1));
-        }
-        return output2;
-      }
-      reserve(2);
-      const output = /* @__PURE__ */ Object.create(null);
-      let count = 0;
-      let visited = 0;
-      for (const key in input) {
-        if (!Object.hasOwn(input, key)) continue;
-        if (++visited > maxBytes) throw new FsError("EFBIG", { syscall: "python reply" });
-        const descriptor = Object.getOwnPropertyDescriptor(input, key);
-        if (!("value" in descriptor)) throw new TypeError("Accessor Python reply");
-        if (descriptor.value === void 0 || typeof descriptor.value === "function") continue;
-        if (count++) reserve(1);
-        string(key);
-        reserve(1);
-        output[key] = own(descriptor.value, depth + 1);
-      }
-      return output;
-    } finally {
-      ancestors.delete(input);
-    }
-  };
-  const owned = own(value, 0);
-  return new TextEncoder().encode(JSON.stringify(owned));
-}
-
-// packages/safe-bash-command-python/src/installation.ts
-var pythonInstallationHelp = `Usage: python -m pip install [-r FILE | --requirement FILE] PACKAGE ...
-Installs compatible wheels and dependencies using the configured Pyodide installer.
-PACKAGE is a package requirement or a canonical filesystem wheel path.
-Supported options: -r, --requirement, -h, --help, --.
-All other pip options and commands are unsupported, including --upgrade,
---force-reinstall, --no-index, --no-deps, --target, --user, --prefix, --root, --editable,
---index-url, --extra-index-url, --find-links, --trusted-host, --require-hashes,
---constraint, --dry-run, --quiet, --verbose and cache/build/configuration flags.
-Configure transport and integrity through the Python package SDK configuration.
-`;
-function parsePythonInstallation(args) {
-  let pipArgs;
-  scan: for (let index = 0; index < args.length; index++) {
-    const option = args[index];
-    if (option === "--" || option === "-" || !option.startsWith("-") || option.startsWith("--")) return void 0;
-    for (let offset = 1; offset < option.length; offset++) {
-      const flag = option[offset];
-      if ("h?V".includes(flag)) return void 0;
-      if ("cmWX".includes(flag)) {
-        const operand = option.slice(offset + 1) || args[++index];
-        if (flag === "c") return void 0;
-        if (flag === "m") {
-          if (operand !== "pip") return void 0;
-          pipArgs = args.slice(index + 1);
-          break scan;
-        }
-        break;
-      }
-    }
-  }
-  if (!pipArgs) return void 0;
-  const packages = [];
-  const requirements = [];
-  if (pipArgs.length === 0) return { packages, requirements, help: true };
-  if (pipArgs[0] === "--help" || pipArgs[0] === "-h") {
-    if (pipArgs.length > 1) throw new PythonInvocationError("unsupported pip option or argument after help: " + pipArgs[1]);
-    return { packages, requirements, help: true };
-  }
-  if (pipArgs[0] !== "install") throw new PythonInvocationError("unsupported pip command " + pipArgs[0]);
-  let operands = false;
-  let help = false;
-  for (let index = 1; index < pipArgs.length; index++) {
-    const option = pipArgs[index];
-    if (operands || !option.startsWith("-")) {
-      packages.push(option);
-      continue;
-    }
-    if (option === "--") {
-      operands = true;
-      continue;
-    }
-    if (option === "--help" || option === "-h") {
-      help = true;
-      continue;
-    }
-    if (option === "-r" || option === "--requirement" || option.startsWith("--requirement=") || option.startsWith("-r")) {
-      const path = option.startsWith("--requirement=") ? option.slice("--requirement=".length) : option !== "-r" && option.startsWith("-r") ? option.slice(2) : pipArgs[++index];
-      if (!path || path.startsWith("-")) throw new PythonInvocationError(option + " requires a path");
-      requirements.push(path);
-      continue;
-    }
-    throw new PythonInvocationError("unsupported pip option " + option);
-  }
-  if (!help && packages.length === 0 && requirements.length === 0) throw new PythonInvocationError("pip install requires at least one package or requirements file");
-  return { packages, requirements, help };
-}
-
-// packages/safe-bash-command-python/src/executor.ts
-import { readBytes, writeBytes } from "../../safe-bash-contracts/io.js";
-import { createOutputOperation } from "../../safe-bash-contracts/output.js";
-import { inheritYieldCheckpoint, yieldTurn } from "../../safe-bash-contracts/yield.js";
-
-// packages/safe-bash-command-python/src/llm-functions-loader.ts
-import { createLlmSpool, createLlmToolRegistry } from "../../safe-bash-command-llm/index.js";
-import { toByteSource } from "../../safe-bash-contracts/index.js";
-
-// packages/safe-bash-command-python/src/llm-functions-program.ts
-var pythonLlmFunctionsProgram = /* @__PURE__ */ (() => String.raw`
-import asyncio, codecs, inspect, json
-import safe_host
-from _poe_llm_capability import bridge
-from llm.cli import _tools_from_code, _gather_tools
-from llm import ToolOutput, Tool, Toolbox, get_tools, get_plugins
-from llm.models import _wrap_tools, _get_instance
-from llm_safe_host import _attachment_type
-
-
-def send(op, **fields):
-    return safe_host.call("llm_tools", dict(op=op, **fields))
-
-
-def load_definition(definition):
-    if "\n" in definition or not definition.endswith(".py"):
-        send("admit", size=len(definition.encode("utf-8")))
-        return definition
-    decoder = codecs.getincrementaldecoder("utf-8")()
-    chunks = []
-    try:
-        with open(definition, "rb") as source:
-            for chunk in iter(lambda: source.read(4096), b""):
-                send("admit", size=len(chunk))
-                chunks.append(decoder.decode(chunk))
-            chunks.append(decoder.decode(b"", final=True))
-    except FileNotFoundError:
-        from click import ClickException
-        raise ClickException("File not found: " + definition)
-    code = "".join(chunks).replace("\r\n", "\n").replace("\r", "\n")
-    return code + "\n" if "\n" not in code and code.endswith(".py") else code
-
-
-def write_text(identifier, value):
-    for offset in range(0, len(value), 4096):
-        send("text", id=identifier, text=value[offset:offset + 4096])
-
-
-def write_attachment(identifier, attachment):
-    mime = _attachment_type(attachment)
-    if attachment.content:
-        descriptor = dict(mimeType=mime, id=attachment.id())
-        handle = send("attachment", id=identifier, descriptor=descriptor)
-        content = memoryview(attachment.content)
-        for offset in range(0, len(content), 4096):
-            send("bytes", id=identifier, attachment=handle, bytes=list(content[offset:offset + 4096]))
-    elif attachment.path:
-        handle = send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id()))
-        with open(attachment.path, "rb") as source:
-            for chunk in iter(lambda: source.read(4096), b""):
-                send("bytes", id=identifier, attachment=handle, bytes=list(chunk))
-    elif attachment.url:
-        send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id(), url=attachment.url))
-    else:
-        send("attachment", id=identifier, descriptor=dict(mimeType=mime, id=attachment.id()))
-
-
-async def main():
-    definitions = send("definitions")
-    selection = send("selection")
-    names = selection.get("names", [])
-    discovery = selection.get("discovery", False)
-    tools = []
-    try:
-        plugin_query = selection.get("pluginQuery")
-        if plugin_query is not None:
-            plugins = get_plugins(plugin_query["all"])
-            hooks = set(plugin_query["hooks"])
-            if hooks:
-                plugins = [plugin for plugin in plugins if hooks.intersection(plugin["hooks"])]
-            send("plugins", plugins=plugins)
-        registered = get_tools() if discovery and not names else {}
-        functions = []
-        for definition in definitions:
-            functions.extend(_tools_from_code(load_definition(definition)))
-        if discovery:
-            if names:
-                registered = {tool.name: tool for tool in functions + _gather_tools(names, [])}
-            else:
-                for tool in functions:
-                    registered[tool.name] = tool
-            entries = [(key, tool, None) for key, tool in registered.items()]
-        else:
-            entries = [(tool.name, tool, None) for tool in functions]
-            for selection_index, selected in enumerate(_gather_tools(names, [])):
-                entries.extend((tool.name, tool, selection_index) for tool in _wrap_tools([selected]))
-        for key, tool, selection_index in entries:
-            if not isinstance(tool, Tool):
-                methods = []
-                for method in tool.method_tools():
-                    methods.append(dict(name=method.name, description=method.description,
-                        inputSchema=method.input_schema,
-                        signature=str(inspect.signature(method.implementation)).replace("(self, ", "(").replace("(self)", "()")))
-                send("toolbox", name=key, tools=methods)
-                continue
-            index = len(tools)
-            tools.append(tool)
-            send("register", index=index, name=tool.name, registryKey=key, description=tool.description,
-                 plugin=tool.plugin, selectionIndex=selection_index, inputSchema=tool.input_schema,
-                 signature=str(inspect.signature(tool.implementation)),
-                 asynchronous=inspect.iscoroutinefunction(tool.implementation))
-    except Exception as error:
-        send("failed", message=getattr(error, "message", str(error)))
-        return
-    send("ready", prepare=any(isinstance(_get_instance(tool.implementation), Toolbox) for tool in tools))
-    pending = set()
-    cancelled = False
-
-    async def execute(command):
-        identifier = command["id"]
-        try:
-            if command.get("prepare"):
-                asynchronous = command.get("asynchronous", False)
-                flag = "_async_prepared" if asynchronous else "_prepared"
-                instances = []
-                for tool in {tool.name: tool for tool in tools}.values():
-                    instance = _get_instance(tool.implementation)
-                    if isinstance(instance, Toolbox) and not getattr(instance, flag, False):
-                        instances.append(instance)
-                for instance in instances:
-                    if asynchronous:
-                        await instance.prepare_async()
-                    else:
-                        instance.prepare()
-                    setattr(instance, flag, True)
-                send("done", id=identifier)
-                return
-            output = tools[command["tool"]].implementation(**command["arguments"])
-            if inspect.isawaitable(output):
-                output = await output
-            attachments = []
-            if isinstance(output, ToolOutput):
-                attachments, output = output.attachments, output.output
-            if not isinstance(output, str):
-                output = json.dumps(output, default=repr)
-            write_text(identifier, output)
-            for attachment in attachments:
-                write_attachment(identifier, attachment)
-            send("done", id=identifier)
-        except Exception as error:
-            send("error", id=identifier, message=str(error))
-
-    def completed(task):
-        pending.discard(task)
-        # Host transport failures already reject all outstanding calls. Retrieve
-        # the exception so a completed task cannot leak an unobserved failure.
-        if not task.cancelled():
-            task.exception()
-
-    try:
-        while True:
-            command = await bridge.wait("begin", capability="llm_tools", value=dict(op="next"))
-            if command is None:
-                break
-            if command.get("cancel"):
-                cancelled = True
-                break
-            task = asyncio.create_task(execute(command))
-            pending.add(task)
-            task.add_done_callback(completed)
-        if pending and not cancelled:
-            await asyncio.gather(*pending)
-    finally:
-        for task in pending:
-            task.cancel()
-        if pending:
-            await asyncio.gather(*pending, return_exceptions=True)
-
-asyncio.run(main())
-`)();
-
-// packages/safe-bash-command-python/src/llm-functions-loader.ts
-function deferred() {
-  let resolve, reject;
-  const promise = new Promise((yes, no) => {
-    resolve = yes;
-    reject = no;
-  });
-  return { promise, resolve, reject };
-}
-function record(value) {
-  if (!value || typeof value !== "object" || Array.isArray(value)) throw new TypeError("Invalid Python tool protocol");
-  return value;
-}
-function createPythonLlmToolLoader(options) {
-  if (!options.createExecutor) throw new TypeError("Python tool loading requires an asynchronous executor");
-  const capabilitiesByArguments = /* @__PURE__ */ new WeakMap();
-  const command = createPythonExecutorCommands({ ...options, createCapabilities: (current) => {
-    const capabilities = options.createCapabilities?.(current) ?? {};
-    if (capabilities.llm_tools) throw new Error("Python tool capability is reserved");
-    const capability = capabilitiesByArguments.get(current.args);
-    if (!capability) throw new Error("Unknown Python tool invocation");
-    return { ...capabilities, llm_tools: capability };
-  } })[0];
-  return async ({ context, definitions, toolNames = [], discovery = false, pluginQuery, maxInputBytes, maxOutputBytes }) => {
-    if (!Array.isArray(definitions) || definitions.some((value) => typeof value !== "string")) throw new TypeError("Python tool definitions must be strings");
-    if (!Array.isArray(toolNames) || toolNames.some((value) => typeof value !== "string") || typeof discovery !== "boolean") throw new TypeError("Invalid Python tool selection");
-    if (pluginQuery && (typeof pluginQuery.all !== "boolean" || !Array.isArray(pluginQuery.hooks) || pluginQuery.hooks.some((value) => typeof value !== "string"))) throw new TypeError("Invalid Python plugin query");
-    for (const limit of [maxInputBytes, maxOutputBytes]) if (limit !== Infinity && (!Number.isSafeInteger(limit) || limit < 0)) throw new RangeError("Invalid Python tool byte limit");
-    context.signal.throwIfAborted();
-    const controller = new AbortController();
-    const runtimeController = new AbortController();
-    const signal = AbortSignal.any([context.signal, controller.signal]);
-    const ready = deferred();
-    const tools = [];
-    const toolboxes = [];
-    let plugins;
-    const spools = /* @__PURE__ */ new Set();
-    const jobs = /* @__PURE__ */ new Map();
-    const queue = [];
-    let waiter;
-    let serial = 0, controls = 0, loaded = false, initializationFailed = false, closed = false, closing;
-    const encoder = new TextEncoder();
-    const fail = (error) => {
-      ready.reject(error);
-      queue.length = 0;
-      if (waiter) {
-        waiter.resolve({ cancel: true });
-        waiter = void 0;
-      } else queue.push({ cancel: true });
-      for (const job of jobs.values()) job.result.reject(error);
-      jobs.clear();
-      controller.abort(error);
-    };
-    const aborted = () => fail(signal.reason);
-    signal.addEventListener("abort", aborted, { once: true });
-    const spool = async () => {
-      const value = await createLlmSpool(context.fs, context.cwd, signal);
-      spools.add(value);
-      if (closed || signal.aborted) {
-        await value.close();
-        spools.delete(value);
-        signal.throwIfAborted();
-        throw new Error("Python tool session is closed");
-      }
-      return value;
-    };
-    const source = (value) => ({ bytes: value.replay(), async dispose() {
-      try {
-        await value.close();
-      } finally {
-        spools.delete(value);
-      }
-    } });
-    const invoke = async (fields, callContext) => {
-      signal.throwIfAborted();
-      callContext.signal.throwIfAborted();
-      if (closed) throw new Error("Python tool session is closed");
-      const stop = () => fail(callContext.signal.reason);
-      callContext.signal.addEventListener("abort", stop, { once: true });
-      let output;
-      try {
-        output = await spool();
-        callContext.signal.throwIfAborted();
-        const result = deferred(), id = ++serial;
-        jobs.set(id, { result, output, attachments: [], files: /* @__PURE__ */ new Map(), bytes: 0, limit: Math.min(callContext.maxBytes, maxOutputBytes) });
-        const request = { id, ...fields };
-        if (waiter) {
-          waiter.resolve(request);
-          waiter = void 0;
-        } else queue.push(request);
-        return await result.promise;
-      } catch (error) {
-        if (output) {
-          await output.close();
-          spools.delete(output);
-        }
-        throw error;
-      } finally {
-        callContext.signal.removeEventListener("abort", stop);
-      }
-    };
-    const prepare = async (callContext, mode) => {
-      const result = await invoke({ prepare: true, asynchronous: mode.async }, callContext);
-      await result.source?.dispose();
-    };
-    const dispatch = async (value) => {
-      const message = record(value);
-      if (message.op !== "next" && message.op !== "failed") signal.throwIfAborted();
-      if (message.op === "definitions") return [...definitions];
-      if (message.op === "selection") return { names: [...toolNames], discovery, ...pluginQuery ? { pluginQuery: { all: pluginQuery.all, hooks: [...pluginQuery.hooks] } } : {} };
-      if (message.op === "admit") {
-        if (typeof message.size !== "number" || !Number.isSafeInteger(message.size) || message.size < 0) throw new TypeError("Invalid Python definition byte count");
-        controls += message.size;
-        if (controls > maxInputBytes) {
-          const error = new RangeError("Python tool definition byte limit exceeded");
-          fail(error);
-          throw error;
-        }
-        return null;
-      }
-      if (message.op === "failed") {
-        initializationFailed = true;
-        fail(new Error(String(message.message)));
-        return null;
-      }
-      if (message.op === "register" || message.op === "toolbox" || message.op === "plugins") {
-        controls += encoder.encode(JSON.stringify(message)).length;
-        if (controls > maxInputBytes) throw new RangeError("Python tool definition byte limit exceeded");
-      }
-      if (message.op === "plugins") {
-        if (loaded || plugins || !pluginQuery || !Array.isArray(message.plugins)) throw new TypeError("Invalid Python plugin discovery");
-        plugins = Object.freeze(message.plugins.map((value2) => {
-          const plugin = record(value2);
-          if (typeof plugin.name !== "string" || !Array.isArray(plugin.hooks) || plugin.hooks.some((hook) => typeof hook !== "string") || plugin.version !== void 0 && typeof plugin.version !== "string") throw new TypeError("Invalid Python plugin metadata");
-          return Object.freeze({ name: plugin.name, hooks: Object.freeze(plugin.hooks), ...typeof plugin.version === "string" ? { version: plugin.version } : {} });
-        }));
-        return null;
-      }
-      if (message.op === "toolbox") {
-        if (loaded || typeof message.name !== "string" || !Array.isArray(message.tools)) throw new TypeError("Invalid Python toolbox registration");
-        const methods = message.tools.map((value2) => {
-          const method = record(value2);
-          const tool = {
-            name: String(method.name),
-            inputSchema: record(method.inputSchema),
-            ...typeof method.description === "string" ? { description: method.description } : {},
-            ...typeof method.signature === "string" ? { signature: method.signature } : {}
-          };
-          if (typeof method.name !== "string") throw new TypeError("Invalid Python toolbox method");
-          createLlmToolRegistry([tool]);
-          return tool;
-        });
-        toolboxes.push({ name: message.name, tools: methods });
-        return null;
-      }
-      if (message.op === "register") {
-        if (loaded || message.index !== tools.length || typeof message.name !== "string" || typeof message.signature !== "string" || typeof message.asynchronous !== "boolean") throw new TypeError("Invalid Python tool registration");
-        const index = tools.length;
-        const tool = {
-          name: message.name,
-          inputSchema: record(message.inputSchema),
-          signature: message.signature,
-          ...typeof message.description === "string" ? { description: message.description } : {},
-          ...typeof message.plugin === "string" ? { plugin: message.plugin } : {},
-          ...typeof message.registryKey === "string" ? { registryKey: message.registryKey } : {},
-          ...typeof message.selectionIndex === "number" ? { selectionIndex: message.selectionIndex } : {},
-          async: message.asynchronous,
-          async implementation(args, callContext) {
-            return invoke({ tool: index, arguments: args }, callContext);
-          }
-        };
-        createLlmToolRegistry([tool]);
-        tools.push(tool);
-        return null;
-      }
-      if (message.op === "ready") {
-        if (loaded) throw new Error("Python tools already loaded");
-        if (message.prepare === true) for (let index = 0; index < tools.length; index++) tools[index] = { ...tools[index], prepare };
-        loaded = true;
-        ready.resolve();
-        return null;
-      }
-      if (message.op === "next") {
-        if (signal.aborted) return { cancel: true };
-        if (!loaded || waiter) throw new Error("Invalid Python tool request queue");
-        if (queue.length) return queue.shift();
-        waiter = deferred();
-        return waiter.promise;
-      }
-      if (typeof message.id !== "number") throw new TypeError("Invalid Python tool call identity");
-      const job = jobs.get(message.id);
-      if (!job) throw new Error("Unknown Python tool call");
-      if (message.op === "text" || message.op === "bytes") {
-        let bytes, target = job.output;
-        if (message.op === "text") {
-          if (typeof message.text !== "string" || message.text.length > 8192) throw new TypeError("Invalid Python tool output window");
-          bytes = encoder.encode(message.text);
-          if (bytes.length > 16384) throw new TypeError("Invalid Python tool output window");
-        } else {
-          if (!Array.isArray(message.bytes) || message.bytes.length > 4096 || message.bytes.some((value2) => typeof value2 !== "number" || !Number.isInteger(value2) || value2 < 0 || value2 > 255)) throw new TypeError("Invalid Python attachment window");
-          if (typeof message.attachment !== "number" || !job.files.has(message.attachment)) throw new Error("Unknown Python attachment");
-          target = job.files.get(message.attachment);
-          bytes = Uint8Array.from(message.bytes);
-        }
-        if (bytes.length > job.limit - job.bytes) throw new RangeError("Python tool output byte limit exceeded");
-        job.bytes += bytes.length;
-        await target.write(bytes);
-        return null;
-      }
-      if (message.op === "attachment") {
-        const metadata = record(message.descriptor);
-        if (typeof metadata.mimeType !== "string" || typeof metadata.id !== "string" || metadata.url !== void 0 && typeof metadata.url !== "string") throw new TypeError("Invalid Python tool attachment");
-        const size = encoder.encode(JSON.stringify(metadata)).length;
-        if (size > job.limit - job.bytes) throw new RangeError("Python tool attachment metadata limit exceeded");
-        job.bytes += size;
-        const index = job.attachments.length;
-        if (metadata.url !== void 0) job.attachments.push({ mimeType: metadata.mimeType, id: metadata.id, url: metadata.url });
-        else {
-          const file = await spool();
-          job.files.set(index, file);
-          job.attachments.push({ mimeType: metadata.mimeType, id: metadata.id, source: source(file) });
-        }
-        return index;
-      }
-      if (message.op === "error") {
-        jobs.delete(message.id);
-        await Promise.all([job.output, ...job.files.values()].map(async (value2) => {
-          await value2.close();
-          spools.delete(value2);
-        }));
-        job.result.reject(new Error(String(message.message)));
-        return null;
-      }
-      if (message.op === "done") {
-        jobs.delete(message.id);
-        job.result.resolve({ source: source(job.output), attachments: job.attachments });
-        return null;
-      }
-      throw new TypeError("Invalid Python tool operation");
-    };
-    const capability = { async call(value) {
-      try {
-        return await dispatch(value);
-      } catch (error) {
-        fail(error);
-        throw error;
-      }
-    } };
-    const { registerCleanup: ignoredParentCleanup, ...isolatedContext } = context;
-    const invocation = { ...isolatedContext, signal: runtimeController.signal, command: "python", args: ["-c", pythonLlmFunctionsProgram], stdin: toByteSource("") };
-    capabilitiesByArguments.set(invocation.args, capability);
-    const running = Promise.resolve().then(() => command.execute(invocation)).then(
-      (result) => {
-        if (!closed) fail(new Error(`Python tool interpreter exited with status ${result.exitCode}`));
-      },
-      (error) => {
-        if (!closed) fail(error);
-      }
-    );
-    const close = () => closing ??= (async () => {
-      closed = true;
-      if (loaded && !signal.aborted && !jobs.size) {
-        if (waiter) {
-          waiter.resolve(null);
-          waiter = void 0;
-        } else queue.push(null);
-      } else {
-        controller.abort(new Error("Python tool session closed"));
-        if (!loaded && !initializationFailed) runtimeController.abort(signal.reason);
-      }
-      await running;
-      capabilitiesByArguments.delete(invocation.args);
-      controller.abort(new Error("Python tool session closed"));
-      signal.removeEventListener("abort", aborted);
-      await Promise.all([...spools].map((value) => value.close()));
-      spools.clear();
-    })();
-    context.registerCleanup?.(close);
-    try {
-      signal.throwIfAborted();
-      await ready.promise;
-      return { tools: Object.freeze(tools), toolboxes: Object.freeze(toolboxes), ...plugins ? { plugins } : {}, close };
-    } catch (error) {
-      await close();
-      throw error;
-    }
-  };
-}
-
-// packages/safe-bash-command-python/src/llm-manifest.ts
-var pythonLlmManifest = {
-  "llm": "0.27.1",
-  "pyodide": "314.0.6",
-  "distributions": [
-    {
-      "name": "llm",
-      "version": "0.27.1",
-      "url": "https://files.pythonhosted.org/packages/6c/67/47585c961ff2299749e519891681025c2685b75801e3f784ee232853c5b0/llm-0.27.1-py3-none-any.whl",
-      "sha256": "a884a575062fbea8c2b129708a80e146fa9682bd1c444d8d7b028196107de727",
-      "bytes": 82500,
-      "expandedBytes": 348753,
-      "nativeModules": [],
-      "file": "llm-0.27.1-py3-none-any.whl"
-    },
-    {
-      "name": "pydantic",
-      "version": "2.12.5",
-      "url": "https://files.pythonhosted.org/packages/5a/87/b70ad306ebb6f9b585f114d0ac2137d792b48be34d732d60e597c2f8465a/pydantic-2.12.5-py3-none-any.whl",
-      "sha256": "e561593fccf61e8a20fc46dfc2dfe075b8be7d0188df33f221ad1f0139180f9d",
-      "bytes": 463580,
-      "expandedBytes": 1851456,
-      "nativeModules": [],
-      "file": "pydantic-2.12.5-py3-none-any.whl"
-    },
-    {
-      "name": "pydantic-core",
-      "version": "2.41.5",
-      "url": "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
-      "sha256": "9802bd7a5e6679ec4c13be778f19f021e6147459c89cc916b913f7970f86dddb",
-      "bytes": 1310163,
-      "expandedBytes": 4592549,
-      "nativeModules": [
-        {
-          "path": "pydantic_core/_pydantic_core.cpython-314-wasm32-emscripten.so",
-          "bytes": 4275289,
-          "sha256": "94477475eb48c67b6b25fd47a7955c1d01479f7971522aff90215bb517be8246"
-        }
-      ],
-      "file": "pydantic_core-2.41.5-cp314-cp314-pyemscripten_2026_0_wasm32.whl"
-    },
-    {
-      "name": "httpx",
-      "version": "0.28.1",
-      "url": "https://files.pythonhosted.org/packages/2a/39/e50c7c3a983047577ee07d2a9e53faf5a69493943ec3f6a384bdc792deb2/httpx-0.28.1-py3-none-any.whl",
-      "sha256": "d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad",
-      "bytes": 73517,
-      "expandedBytes": 295303,
-      "nativeModules": [],
-      "file": "httpx-0.28.1-py3-none-any.whl"
-    },
-    {
-      "name": "click",
-      "version": "8.1.8",
-      "url": "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl",
-      "sha256": "63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2",
-      "bytes": 98188,
-      "expandedBytes": 355272,
-      "nativeModules": [],
-      "file": "click-8.1.8-py3-none-any.whl"
-    },
-    {
-      "name": "sqlite-utils",
-      "version": "3.38",
-      "url": "https://files.pythonhosted.org/packages/4d/eb/f8e8e827805f810838efff3311cccd2601238c5fa3fc35c1f878709e161b/sqlite_utils-3.38-py3-none-any.whl",
-      "sha256": "8a27441015c3b2ef475f555861f7a2592f73bc60d247af9803a11b65fc605bf9",
-      "bytes": 68183,
-      "expandedBytes": 278821,
-      "nativeModules": [],
-      "file": "sqlite_utils-3.38-py3-none-any.whl"
-    },
-    {
-      "name": "sqlite-migrate",
-      "version": "0.1b0",
-      "url": "https://files.pythonhosted.org/packages/df/92/994545b912e6d6feb40323047f02ca039321e690aa2c27afcd5c4105e37b/sqlite_migrate-0.1b0-py3-none-any.whl",
-      "sha256": "a4125e35e1de3dc56b6b6ec60e9833ce0ce20192b929ddcb2d4246c5098859c6",
-      "bytes": 9986,
-      "expandedBytes": 25349,
-      "nativeModules": [],
-      "file": "sqlite_migrate-0.1b0-py3-none-any.whl"
-    },
-    {
-      "name": "python-ulid",
-      "version": "3.0.0",
-      "url": "https://files.pythonhosted.org/packages/63/4e/cc2ba2c0df2589f35a4db8473b8c2ba9bbfc4acdec4a94f1c78934d2350f/python_ulid-3.0.0-py3-none-any.whl",
-      "sha256": "e4c4942ff50dbd79167ad01ac725ec58f924b4018025ce22c858bfcff99a5e31",
-      "bytes": 11194,
-      "expandedBytes": 30439,
-      "nativeModules": [],
-      "file": "python_ulid-3.0.0-py3-none-any.whl"
-    },
-    {
-      "name": "condense-json",
-      "version": "0.1.3",
-      "url": "https://files.pythonhosted.org/packages/28/5f/63badd4924358fad1efa6defd66eef700ccf8783c0e44098987f867e8b1f/condense_json-0.1.3-py3-none-any.whl",
-      "sha256": "e0a3d42db4f44a89e74af8737d8e517e97420be0f7e5437087f4decfd38c3366",
-      "bytes": 8432,
-      "expandedBytes": 21056,
-      "nativeModules": [],
-      "file": "condense_json-0.1.3-py3-none-any.whl"
-    },
-    {
-      "name": "puremagic",
-      "version": "1.30",
-      "url": "https://files.pythonhosted.org/packages/91/ed/1e347d85d05b37a8b9a039ca832e5747e1e5248d0bd66042783ef48b4a37/puremagic-1.30-py3-none-any.whl",
-      "sha256": "5eeeb2dd86f335b9cfe8e205346612197af3500c6872dffebf26929f56e9d3c1",
-      "bytes": 43304,
-      "expandedBytes": 185153,
-      "nativeModules": [],
-      "file": "puremagic-1.30-py3-none-any.whl"
-    },
-    {
-      "name": "anyio",
-      "version": "4.15.1",
-      "url": "https://files.pythonhosted.org/packages/12/b8/4bd346e22b28902df4d651910f5242c28d84e4a5c2435ca5c3f797ed7e2e/anyio-4.15.1-py3-none-any.whl",
-      "sha256": "6152fdbbf9a77fdec97731721bebf7c4c44f7c29b424b0065826173efc7ed101",
-      "bytes": 132079,
-      "expandedBytes": 539217,
-      "nativeModules": [],
-      "file": "anyio-4.15.1-py3-none-any.whl"
-    },
-    {
-      "name": "httpcore",
-      "version": "1.0.9",
-      "url": "https://files.pythonhosted.org/packages/7e/f5/f66802a942d491edb555dd61e3a9961140fd64c90bce1eafd741609d334d/httpcore-1.0.9-py3-none-any.whl",
-      "sha256": "2d400746a40668fc9dec9810239072b40b4484b640a8c38fd654a024c7a1bf55",
-      "bytes": 78784,
-      "expandedBytes": 288016,
-      "nativeModules": [],
-      "file": "httpcore-1.0.9-py3-none-any.whl"
-    },
-    {
-      "name": "typing-extensions",
-      "version": "4.16.0",
-      "url": "https://files.pythonhosted.org/packages/49/d3/b8441a820a491ddfc024b0b0cf0393375b75ea13866d9c66727e54c2fc80/typing_extensions-4.16.0-py3-none-any.whl",
-      "sha256": "481caa481374e813c1b176ada14e97f1f67a4539ce9cfeb3f350d78d6370c2e8",
-      "bytes": 45571,
-      "expandedBytes": 182767,
-      "nativeModules": [],
-      "file": "typing_extensions-4.16.0-py3-none-any.whl"
-    },
-    {
-      "name": "annotated-types",
-      "version": "0.8.0",
-      "url": "https://files.pythonhosted.org/packages/99/91/8acff4f5e50511b911bbccb72b8628a49c68ce14148cd9f6431094859a90/annotated_types-0.8.0-py3-none-any.whl",
-      "sha256": "f072f4d804ea359e4eaf198b1af7a8b0943881a87f31bb764f8bf219bb9419e0",
-      "bytes": 13427,
-      "expandedBytes": 36347,
-      "nativeModules": [],
-      "file": "annotated_types-0.8.0-py3-none-any.whl"
-    },
-    {
-      "name": "click-default-group",
-      "version": "1.2.4",
-      "url": "https://files.pythonhosted.org/packages/2c/1a/aff8bb287a4b1400f69e09a53bd65de96aa5cee5691925b38731c67fc695/click_default_group-1.2.4-py2.py3-none-any.whl",
-      "sha256": "9b60486923720e7fc61731bdb32b617039aba820e22e1c88766b1125592eaa5f",
-      "bytes": 4123,
-      "expandedBytes": 8671,
-      "nativeModules": [],
-      "file": "click_default_group-1.2.4-py2.py3-none-any.whl"
-    },
-    {
-      "name": "h11",
-      "version": "0.16.0",
-      "url": "https://files.pythonhosted.org/packages/04/4b/29cac41a4d98d144bf5f6d33995617b185d14b22401f75ca86f384e87ff1/h11-0.16.0-py3-none-any.whl",
-      "sha256": "63cf8bbe7522de3bf65932fda1d9c2772064ffb3dae62d55932da54b31cb6c86",
-      "bytes": 37515,
-      "expandedBytes": 103935,
-      "nativeModules": [],
-      "file": "h11-0.16.0-py3-none-any.whl"
-    },
-    {
-      "name": "idna",
-      "version": "3.20",
-      "url": "https://files.pythonhosted.org/packages/58/a2/bb081bab032533a855d44de1d56f8e8426114ff1ba5d1f07a438a0a654f8/idna-3.20-py3-none-any.whl",
-      "sha256": "ab7ae7122974553370f0bdb919e1a960b2cd1bc1ef0276416d896db81c14582c",
-      "bytes": 69583,
-      "expandedBytes": 342091,
-      "nativeModules": [],
-      "file": "idna-3.20-py3-none-any.whl"
-    },
-    {
-      "name": "typing-inspection",
-      "version": "0.4.4",
-      "url": "https://files.pythonhosted.org/packages/67/81/4add07e5172b7ac40d8ed5ff580409a7801a4fe26d529bdd915401dabfbe/typing_inspection-0.4.4-py3-none-any.whl",
-      "sha256": "65b8397ba37ccbce054456aaccddfc91e6e3083c92824df348d96ca832f3f147",
-      "bytes": 14750,
-      "expandedBytes": 54538,
-      "nativeModules": [],
-      "file": "typing_inspection-0.4.4-py3-none-any.whl"
-    },
-    {
-      "name": "certifi",
-      "version": "2026.7.22",
-      "url": "https://files.pythonhosted.org/packages/0b/a7/71ac2cff56fec219ed242bb11b8efb69fcc4bec75db06fb7bfe35de520e6/certifi-2026.7.22-py3-none-any.whl",
-      "sha256": "62f22742b58a1a33014a2b6b706588a8d7e2a88ae7bd1a6ebe8c992928483775",
-      "bytes": 136983,
-      "expandedBytes": 248921,
-      "nativeModules": [],
-      "file": "certifi-2026.7.22-py3-none-any.whl"
-    },
-    {
-      "name": "pluggy",
-      "version": "1.6.0",
-      "url": "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl",
-      "sha256": "e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746",
-      "bytes": 20538,
-      "expandedBytes": 65823,
-      "nativeModules": [],
-      "file": "pluggy-1.6.0-py3-none-any.whl"
-    },
-    {
-      "name": "python-dateutil",
-      "version": "2.9.0.post0",
-      "url": "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl",
-      "sha256": "a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427",
-      "bytes": 229892,
-      "expandedBytes": 441579,
-      "nativeModules": [],
-      "file": "python_dateutil-2.9.0.post0-py2.py3-none-any.whl"
-    },
-    {
-      "name": "six",
-      "version": "1.17.0",
-      "url": "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl",
-      "sha256": "4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274",
-      "bytes": 11050,
-      "expandedBytes": 37975,
-      "nativeModules": [],
-      "file": "six-1.17.0-py2.py3-none-any.whl"
-    },
-    {
-      "name": "pyyaml",
-      "version": "6.0.3",
-      "url": "https://cdn.jsdelivr.net/pyodide/v314.0.6/full/pyyaml-6.0.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl",
-      "sha256": "b1447216501f0d3aef290558fe33691dd51b0839e70f9a970defb12b36d82df8",
-      "bytes": 111318,
-      "expandedBytes": 439274,
-      "nativeModules": [
-        {
-          "path": "yaml/_yaml.cpython-314-wasm32-emscripten.so",
-          "bytes": 214986,
-          "sha256": "a3b18ccfd3c043f10f4ae4044bea14079f14a30707bf5c6ddf1f6dc61abaffc1"
-        }
-      ],
-      "file": "pyyaml-6.0.3-cp314-cp314-pyemscripten_2026_0_wasm32.whl"
-    },
-    {
-      "name": "sniffio",
-      "version": "1.3.1",
-      "url": "https://files.pythonhosted.org/packages/e9/44/75a9c9421471a6c4805dbf2356f7c181a29c1879239abab1ea2cc8f38b40/sniffio-1.3.1-py3-none-any.whl",
-      "sha256": "2f6da418d1f1e0fddd844478f41680e794e6051915791a034ff65e5f100525a2",
-      "bytes": 10235,
-      "expandedBytes": 22921,
-      "nativeModules": [],
-      "file": "sniffio-1.3.1-py3-none-any.whl"
-    },
-    {
-      "name": "sqlite-fts4",
-      "version": "1.0.3",
-      "url": "https://files.pythonhosted.org/packages/51/29/0096e8b1811aaa78cfb296996f621f41120c21c2f5cd448ae1d54979d9fc/sqlite_fts4-1.0.3-py3-none-any.whl",
-      "sha256": "0359edd8dea6fd73c848989e1e2b1f31a50fe5f9d7272299ff0e8dbaa62d035f",
-      "bytes": 9972,
-      "expandedBytes": 28735,
-      "nativeModules": [],
-      "file": "sqlite_fts4-1.0.3-py3-none-any.whl"
-    },
-    {
-      "name": "tabulate",
-      "version": "0.10.0",
-      "url": "https://files.pythonhosted.org/packages/99/55/db07de81b5c630da5cbf5c7df646580ca26dfaefa593667fc6f2fe016d2e/tabulate-0.10.0-py3-none-any.whl",
-      "sha256": "f0b0622e567335c8fabaaa659f1b33bcb6ddfe2e496071b743aa113f8774f2d3",
-      "bytes": 39814,
-      "expandedBytes": 150857,
-      "nativeModules": [],
-      "file": "tabulate-0.10.0-py3-none-any.whl"
-    }
-  ]
-};
-
-// packages/safe-bash-command-python/src/llm-packages.ts
-var pythonLlmPackages = pythonLlmManifest;
-function installPythonLlmPackages(runtime, assets) {
-  if (runtime.version !== pythonLlmManifest.pyodide) throw new Error("LLM packages require the pinned Python runtime");
-  if (assets.length !== pythonLlmManifest.distributions.length) throw new Error("Incomplete Python LLM package assets");
-  const root = "/lib/python3.14/site-packages";
-  const wheelRoot = root + "/llm-wheels";
-  runtime.FS.mkdirTree(wheelRoot);
-  const paths = [];
-  for (const distribution of pythonLlmManifest.distributions) {
-    const asset = assets.find((asset2) => asset2.file === distribution.file);
-    if (!asset || asset.bytes.byteLength !== distribution.bytes) throw new Error("Invalid Python LLM package asset: " + distribution.file);
-    if (distribution.nativeModules.length || ["llm", "puremagic"].includes(distribution.name)) {
-      runtime.unpackArchive(asset.bytes, "zip", { extractDir: root });
-    } else {
-      const path = wheelRoot + "/" + distribution.file;
-      runtime.FS.writeFile(path, asset.bytes);
-      paths.push(path);
-    }
-  }
-  runtime.FS.writeFile(root + "/readline.py", new TextEncoder().encode(
-    '"""Readline key bindings for the non-terminal Worker input stream."""\ndef parse_and_bind(binding):\n import sys\n if sys.stdin.isatty():\n  raise OSError("Terminal line editing is unavailable in this runtime")\n'
-  ));
-  runtime.FS.writeFile(root + "/llm_safe_host.py", new TextEncoder().encode(pythonLlmProvider));
-  const metadata = root + "/llm_safe_host-0.1.dist-info";
-  runtime.FS.mkdirTree(metadata);
-  runtime.FS.writeFile(metadata + "/METADATA", new TextEncoder().encode("Metadata-Version: 2.1\nName: llm-safe-host\nVersion: 0.1\n"));
-  runtime.FS.writeFile(metadata + "/entry_points.txt", new TextEncoder().encode("[llm]\nsafe_host = llm_safe_host\n"));
-  runtime.globals.set("_safe_llm_wheel_paths", JSON.stringify(paths));
-  try {
-    runtime.runPython(String.raw`
-import json, sys
-sys.path.extend(json.loads(_safe_llm_wheel_paths))
-def _install_safe_llm_import():
-    if any(getattr(finder, "_safe_llm_provider", False) for finder in sys.meta_path):
-        return
-    def configure_plugins(module):
-        module.DEFAULT_PLUGINS = ("llm.default_plugins.default_tools",)
-        module.LLM_LOAD_PLUGINS = "llm-safe-host"
-
-    def configure_provider(module):
-        configure_plugins(module.plugins)
-        module.plugins.load_plugins()
-        from llm_safe_host import restrict_providers
-        restrict_providers()
-
-    class HostLlmFinder:
-        _safe_llm_provider = True
-        def find_spec(self, fullname, path=None, target=None):
-            if fullname not in ("llm", "llm.plugins"):
-                return None
-            for finder in tuple(sys.meta_path):
-                if finder is self:
-                    continue
-                spec = finder.find_spec(fullname, path, target)
-                if spec is None:
-                    continue
-                original = spec.loader
-                class HostLlmLoader:
-                    def create_module(self, spec):
-                        return original.create_module(spec)
-                    def exec_module(self, module):
-                        original.exec_module(module)
-                        if fullname == "llm.plugins":
-                            configure_plugins(module)
-                        else:
-                            configure_provider(module)
-                    def __getattr__(self, name):
-                        return getattr(original, name)
-                spec.loader = HostLlmLoader()
-                return spec
-            return None
-
-    sys.meta_path.insert(0, HostLlmFinder())
-    if "llm" in sys.modules:
-        configure_provider(sys.modules["llm"])
-_install_safe_llm_import()
-del _install_safe_llm_import
-`);
-  } finally {
-    runtime.globals.delete("_safe_llm_wheel_paths");
-  }
-}
-
-// packages/safe-bash-command-python/src/executor.ts
-var PythonInputChunkError = class extends RangeError {
-};
-function createPythonExecutorCommands(options) {
-  if (!options || typeof options.createWorker === "function" === (typeof options.createExecutor === "function") || options.createWorker !== void 0 && typeof options.createWorker !== "function" || options.createExecutor !== void 0 && typeof options.createExecutor !== "function") throw new PythonFailure("executor-unavailable");
-  if (options.createCapabilities && !options.createExecutor) throw new TypeError("Python host capabilities require an asynchronous executor");
-  if (options.onDiagnostic !== void 0 && typeof options.onDiagnostic !== "function") throw new TypeError("Python onDiagnostic must be a function");
-  if (options.environment && options.provisioning) throw new TypeError("A borrowed Python environment cannot be combined with provisioning options");
-  const maxTransferBytes = options.maxTransferBytes ?? Infinity;
-  const transferChunkBytes = Math.min(maxTransferBytes, 65536);
-  const maxOpenFiles = options.maxOpenFiles;
-  const maxConcurrentWorkers = options.maxConcurrentWorkers ?? Infinity;
-  const maxInputChunkBytes = options.maxInputChunkBytes ?? Infinity;
-  if (maxConcurrentWorkers !== Infinity && (!Number.isSafeInteger(maxConcurrentWorkers) || maxConcurrentWorkers < 1)) throw new RangeError("Invalid Python worker concurrency limit");
-  if (maxInputChunkBytes !== Infinity && (!Number.isSafeInteger(maxInputChunkBytes) || maxInputChunkBytes < 1)) throw new RangeError("Invalid Python input chunk limit");
-  let activeWorkers = 0;
-  for (const size of [maxTransferBytes, maxOpenFiles, options.maxDirectoryEntries]) if (size !== void 0 && size !== Infinity && (!Number.isSafeInteger(size) || size < 1)) throw new RangeError("Invalid Python resource limit");
-  const runtimeMount = options.runtimeMount ?? "/.pyodide-runtime";
-  if (!runtimeMount.startsWith("/") || runtimeMount === "/" || runtimeMount.slice(1).includes("/") || runtimeMount.includes("\0") || runtimeMount.split("/").some((part) => part === ".." || part === ".")) throw new TypeError("Python runtime mount must be an absolute top-level canonical path");
-  const environment = options.environment ?? createPythonPackageEnvironment(options.provisioning);
-  const execute = async (context) => {
-    if (pythonShellDispatchActive(context.executionScope)) {
-      await writeBytes(context.stderr, new TextEncoder().encode("python: nested Python execution is unavailable while the parent interpreter is suspended\n"), context.signal);
-      return { exitCode: 1 };
-    }
-    let installation;
-    try {
-      parsePythonInvocation(context.args, context.env);
-      installation = parsePythonInstallation(context.args);
-    } catch (error) {
-      if (!(error instanceof PythonInvocationError)) throw error;
-      await writeBytes(context.stderr, new TextEncoder().encode("python: " + error.message + "\n"), context.signal);
-      return { exitCode: 2 };
-    }
-    if (installation?.help) {
-      await writeBytes(context.stdout, new TextEncoder().encode(pythonInstallationHelp), context.signal);
-      return { exitCode: 0 };
-    }
-    context.signal.throwIfAborted();
-    if (activeWorkers >= maxConcurrentWorkers) {
-      const failure = reportPythonFailure("capacity", void 0, options.onDiagnostic);
-      await writeBytes(context.stderr, new TextEncoder().encode("python: " + failure.message + "\n"), context.signal);
-      return { exitCode: 1 };
-    }
-    const controller = new AbortController();
-    const signal = AbortSignal.any([context.signal, controller.signal]);
-    inheritYieldCheckpoint(context.signal, signal);
-    const fileContext = { ...context, descriptorCleanup: "caller" };
-    const metadata = new PythonStatTranslator();
-    const service = new PythonFileSystem(context.fs, {
-      cwd: context.cwd,
-      signal,
-      maxTransferBytes,
-      ...maxOpenFiles === void 0 ? {} : { maxOpenFiles },
-      ...options.maxDirectoryEntries === void 0 ? {} : { maxDirectoryEntries: options.maxDirectoryEntries },
-      open: (path, settings) => openCommandFile(fileContext, path, settings)
-    });
-    let hostBridge;
-    let stdoutOperation;
-    let stderrOperation;
-    let endpoint;
-    let executor;
-    let packages;
-    let unsubscribe;
-    let admitted = false;
-    let closed = false;
-    let closing;
-    const pending = /* @__PURE__ */ new Set();
-    const input = readBytes(context.stdin, signal)[Symbol.asyncIterator]();
-    let fragment;
-    let offset = 0;
-    let inputBytes = 0;
-    let rejectRun;
-    const close = () => {
-      if (closing) return closing;
-      let finish;
-      let fail;
-      closing = new Promise((resolve, reject) => {
-        finish = resolve;
-        fail = reject;
-      });
-      closed = true;
-      controller.abort(new Error("Python invocation retired"));
-      void (async () => {
-        signal.removeEventListener("abort", aborted);
-        const subscription = Promise.resolve().then(() => unsubscribe?.());
-        const termination = Promise.resolve().then(() => executor ? executor.terminate() : endpoint?.terminate());
-        const filesystemRetirement = termination.finally(() => service.close());
-        const results = await Promise.allSettled([subscription, termination, filesystemRetirement, hostBridge?.close(), stdoutOperation?.close(), stderrOperation?.close(), ...pending]);
-        await input.return?.(void 0);
-        fragment = void 0;
-        if (packages) environment.finish(packages);
-        if (results[1]?.status === "fulfilled" && admitted) {
-          activeWorkers--;
-          admitted = false;
-        }
-        for (const result2 of results) if (result2.status === "rejected") throw result2.reason;
-      })().then(() => {
-        if (admitted) {
-          activeWorkers--;
-          admitted = false;
-        }
-        finish();
-      }, (reason) => {
-        fail(reportPythonFailure("cleanup", reason, options.onDiagnostic));
-      });
-      return closing;
-    };
-    const aborted = () => {
-      rejectRun?.(signal.reason);
-    };
-    context.registerCleanup?.(close);
-    let primary;
-    let ready = false;
-    const filesystemDiagnostics = /* @__PURE__ */ new Set();
-    let result = 1;
-    try {
-      signal.throwIfAborted();
-      activeWorkers++;
-      admitted = true;
-      const outputContext = { signal, ...context.registerCleanup ? { registerCleanup: context.registerCleanup } : {} };
-      stdoutOperation = createOutputOperation(outputContext, context.stdout);
-      stderrOperation = createOutputOperation(outputContext, context.stderr);
-      const diagnoseFilesystemFailure = async (operation, error) => {
-        if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "ENOTSUP") return;
-        const category = operation === "open" ? "filesystem-open" : operation === "read" ? "filesystem-read" : operation === "write" || operation === "ftruncate" ? "filesystem-write" : operation === "readdir" ? "filesystem-directory" : "filesystem-operation";
-        if (!filesystemDiagnostics.has(category)) {
-          filesystemDiagnostics.add(category);
-          const failure = reportPythonFailure(category, error, options.onDiagnostic);
-          await writeBytes(stderrOperation.output, new TextEncoder().encode("python: " + failure.message + "\n"), signal);
-        }
-      };
-      const dispatch = async (request) => {
-        if (request.op === "close") return service.dispatch(request);
-        signal.throwIfAborted();
-        if (request.op.startsWith("package-")) return environment.dispatch(request.op, request.args, { fs: context.fs, cwd: context.cwd, signal });
-        if (request.op === "stdin") {
-          const length = request.args[0];
-          if (!Number.isSafeInteger(length) || length < 1 || length > maxTransferBytes) throw new RangeError("Invalid Python input request");
-          let pulls = 0;
-          while (!fragment || offset === fragment.length) {
-            if (++pulls % 128 === 0) await yieldTurn(signal);
-            const next = await input.next();
-            if (next.done) return [];
-            inputBytes += next.value.length;
-            context.inputBudget?.check(inputBytes);
-            if (next.value.length > maxInputChunkBytes) throw new PythonInputChunkError("Python input chunk exceeds maxInputChunkBytes");
-            fragment = Uint8Array.from(next.value);
-            offset = 0;
-          }
-          const end = Math.min(fragment.length, offset + length);
-          const bytes = Array.from(fragment.subarray(offset, end));
-          offset = end;
-          return bytes;
-        }
-        if (request.op === "stdout" || request.op === "stderr") {
-          const bytes = request.args[0];
-          if (!Array.isArray(bytes) || bytes.length > maxTransferBytes || bytes.some((value2) => !Number.isInteger(value2) || value2 < 0 || value2 > 255)) throw new TypeError("Invalid Python output bytes");
-          const operation = request.op === "stdout" ? stdoutOperation : stderrOperation;
-          await writeBytes(operation.output, Uint8Array.from(bytes), signal);
-          return bytes.length;
-        }
-        const value = await service.dispatch(request);
-        return request.op === "stat" || request.op === "lstat" || request.op === "fstat" ? metadata.translate(value) : value;
-      };
-      if (options.createCapabilities) {
-        const capabilityInput = { async *[Symbol.asyncIterator]() {
-          while (true) {
-            const bytes = await dispatch({ op: "stdin", args: [transferChunkBytes] });
-            if (!bytes.length) break;
-            yield Uint8Array.from(bytes);
-          }
-        } };
-        hostBridge = createPythonHostBridge(options.createCapabilities({ ...context, stdin: capabilityInput, signal }), { ...options.capabilityLimits, signal });
-      }
-      options.onProgress?.({ phase: "initializing", command: context.command });
-      const preparation = environment.prepare({
-        fs: context.fs,
-        cwd: context.cwd,
-        signal,
-        requirements: [...options.packages ?? [], ...options.packageProfile ? pythonDocumentPackages : [], ...installation?.packages ?? []],
-        requirementFiles: [...options.requirements ?? [], ...installation?.requirements ?? []]
-      }).then((value) => {
-        packages = value;
-      });
-      pending.add(preparation);
-      try {
-        await preparation;
-      } finally {
-        pending.delete(preparation);
-      }
-      signal.throwIfAborted();
-      if (options.createExecutor) {
-        try {
-          executor = options.createExecutor();
-        } catch (reason) {
-          throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : "startup", reason, options.onDiagnostic);
-        }
-        if (!executor || typeof executor.run !== "function" || typeof executor.terminate !== "function") throw reportPythonFailure("executor-unavailable", void 0, options.onDiagnostic);
-        let requesting = false;
-        let running = true;
-        const start = {
-          invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } },
-          ...hostBridge ? { host: hostBridge } : {},
-          runtimeMount,
-          maxTransferBytes,
-          signal,
-          ...packages ? { packages } : {},
-          installOnly: !!installation,
-          onReady() {
-            if (closed || !running || signal.aborted || ready) return;
-            ready = true;
-            try {
-              options.onProgress?.({ phase: "ready", command: context.command });
-            } catch (reason) {
-              running = false;
-              rejectRun?.(reason);
-              throw reason;
-            }
-          },
-          async dispatch(request) {
-            if (!request || typeof request.op !== "string" || !Array.isArray(request.args)) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
-            const releasing = request.op === "close";
-            if (!releasing) signal.throwIfAborted();
-            if (closed && !releasing || !running || requesting) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
-            requesting = true;
-            const operation = Promise.resolve().then(() => dispatch(request)).catch(async (error) => {
-              if (releasing) throw error;
-              signal.throwIfAborted();
-              if (error instanceof PythonInputChunkError) rejectRun?.(error);
-              if (request.op.startsWith("package-")) throw Object.assign(reportPythonFailure("runtime-assets", error, options.onDiagnostic), { code: "EPACKAGE" });
-              await diagnoseFilesystemFailure(request.op, error);
-              throw error;
-            });
-            const tracked2 = operation.then(() => {
-            }, () => {
-            });
-            pending.add(tracked2);
-            try {
-              return await operation;
-            } finally {
-              requesting = false;
-              pending.delete(tracked2);
-            }
-          }
-        };
-        const execution = Promise.resolve().then(() => {
-          signal.throwIfAborted();
-          return executor.run(start);
-        }).catch((reason) => {
-          running = false;
-          if (signal.aborted) throw signal.reason;
-          throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : ready ? "runtime" : "startup", reason, options.onDiagnostic);
-        }).then((status) => {
-          running = false;
-          if (requesting) throw reportPythonFailure("transport-unavailable", void 0, options.onDiagnostic);
-          try {
-            return validateExitCode(status);
-          } catch (reason) {
-            throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
-          }
-        });
-        const tracked = execution.then(() => {
-        }, () => {
-        });
-        pending.add(tracked);
-        void tracked.then(() => pending.delete(tracked));
-        result = await new Promise((resolve, reject) => {
-          rejectRun = reject;
-          signal.addEventListener("abort", aborted, { once: true });
-          if (signal.aborted) aborted();
-          execution.then(resolve, reject);
-        });
-      } else {
-        let shared;
-        try {
-          shared = new SharedArrayBuffer(8 + transferChunkBytes * 6 + 65536);
-        } catch (reason) {
-          throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
-        }
-        const control = new Int32Array(shared, 0, 2);
-        const payload = new Uint8Array(shared, 8);
-        const reply = (value, status) => {
-          if (closed) return;
-          let bytes;
-          try {
-            bytes = encodePythonReply(value, payload.length);
-          } catch (error) {
-            if (typeof error !== "object" || error === null || !("code" in error) || error.code !== "EFBIG") throw error;
-            bytes = encodePythonReply({ code: "EFBIG" }, payload.length);
-            status = 2;
-          }
-          payload.set(bytes);
-          try {
-            Atomics.store(control, 1, bytes.length);
-            Atomics.store(control, 0, status);
-            Atomics.notify(control, 0);
-          } catch (reason) {
-            throw reportPythonFailure("transport-unavailable", reason, options.onDiagnostic);
-          }
-        };
-        try {
-          endpoint = options.createWorker();
-        } catch (reason) {
-          throw reportPythonFailure(reason instanceof PythonFailure ? reason.category : "startup", reason, options.onDiagnostic);
-        }
-        signal.throwIfAborted();
-        result = await new Promise((resolve, reject) => {
-          let settled = false;
-          const fail = (reason) => {
-            settled = true;
-            reject(reason);
-          };
-          rejectRun = fail;
-          signal.addEventListener("abort", aborted, { once: true });
-          const transportFailure = (reason) => {
-            fail(reportPythonFailure("transport-unavailable", reason, options.onDiagnostic));
-          };
-          try {
-            unsubscribe = endpoint.subscribe((value) => {
-              if (closed || settled) return;
-              if (typeof value !== "object" || value === null) {
-                transportFailure(new TypeError("Invalid Python worker message"));
-                return;
-              }
-              const message = value;
-              if (message.type === "ready") {
-                ready = true;
-                try {
-                  options.onProgress?.({ phase: "ready", command: context.command });
-                } catch (error) {
-                  fail(error);
-                }
-                return;
-              }
-              if (message.type === "exit") {
-                if (pending.size) {
-                  transportFailure(new TypeError("Python worker exited with an outstanding request"));
-                  return;
-                }
-                try {
-                  const status = validateExitCode(message.exitCode);
-                  settled = true;
-                  resolve(status);
-                } catch (error) {
-                  transportFailure(error);
-                }
-                return;
-              }
-              if (message.type === "error") {
-                fail(reportPythonFailure(isPythonFailureCategory(message.category) ? message.category : ready ? "runtime" : "startup", message.message, options.onDiagnostic));
-                return;
-              }
-              if (typeof message.op !== "string" || !Array.isArray(message.args) || pending.size) {
-                transportFailure(new TypeError("Invalid concurrent Python worker request"));
-                return;
-              }
-              const work = dispatch({ op: message.op, args: message.args }).then(
-                (value2) => {
-                  pending.delete(work);
-                  reply(value2, 1);
-                },
-                async (error) => {
-                  if (signal.aborted) {
-                    pending.delete(work);
-                    fail(signal.reason);
-                    return;
-                  }
-                  if (typeof message.op === "string" && message.op.startsWith("package-")) {
-                    const failure = reportPythonFailure("runtime-assets", error, options.onDiagnostic);
-                    pending.delete(work);
-                    reply({ code: "EPACKAGE", message: failure.message }, 2);
-                    return;
-                  }
-                  if (typeof error !== "object" || error === null || !("code" in error) || typeof error.code !== "string") {
-                    pending.delete(work);
-                    fail(error);
-                    return;
-                  }
-                  await diagnoseFilesystemFailure(message.op, error);
-                  pending.delete(work);
-                  reply({ code: error.code }, 2);
-                }
-              );
-              pending.add(work);
-              void work.catch((reason) => {
-                pending.delete(work);
-                fail(reason);
-              });
-            }, transportFailure);
-          } catch (reason) {
-            transportFailure(reason);
-          }
-          if (settled) return;
-          const start = { type: "start", shared, invocation: { command: context.command, args: [...context.args], cwd: context.cwd, env: { ...context.env } }, runtimeMount, maxTransferBytes: transferChunkBytes, ...packages ? { packages } : {}, installOnly: !!installation };
-          signal.throwIfAborted();
-          try {
-            endpoint.postMessage(start);
-          } catch (reason) {
-            transportFailure(reason);
-          }
-        });
-      }
-    } catch (reason) {
-      if (!signal.aborted && reason instanceof PythonInputChunkError) {
-        try {
-          await writeBytes(stderrOperation.output, new TextEncoder().encode("python: " + reason.message + "\n"), signal);
-        } catch (error) {
-          primary = { reason: error };
-        }
-      } else if (!signal.aborted && typeof reason === "object" && reason !== null && "code" in reason && reason.code === "EPACKAGE") {
-        primary = { reason: reportPythonFailure("runtime-assets", reason, options.onDiagnostic) };
-      } else primary = { reason };
-    }
-    try {
-      await close();
-    } catch (reason) {
-      primary ??= { reason };
-    }
-    try {
-      options.onProgress?.({ phase: "finished", command: context.command });
-    } catch (reason) {
-      primary ??= { reason };
-    }
-    context.signal.throwIfAborted();
-    if (primary) {
-      if (!(primary.reason instanceof PythonFailure)) throw primary.reason;
-      const failure = primary.reason;
-      await writeBytes(context.stderr, new TextEncoder().encode("python: " + failure.message + "\n"), context.signal);
-      return { exitCode: 1 };
-    }
-    return { exitCode: result };
-  };
-  return ["python", "python3"].map((name) => ({ name, description: "Python with an explicit interpreter executor and canonical filesystem", execute }));
-}
-function pythonExecutorCommands(options) {
-  if (!options || typeof options.createWorker === "function" === (typeof options.createExecutor === "function")) throw new PythonFailure("executor-unavailable");
-  if (options?.environment && options.provisioning) throw new TypeError("A borrowed Python environment cannot be combined with provisioning options");
-  const { provisioning, ...configuration } = options;
-  const environment = options.environment ?? createPythonPackageEnvironment(provisioning);
-  const commands = createPythonExecutorCommands({ ...configuration, environment });
-  return { name: "python-commands", ...options.environment ? {} : { dispose: environment.dispose }, setup(host) {
-    if (!options.replace) {
-      for (const command of commands) if (host.commands.has(command.name)) throw new Error(`Command already registered: ${command.name}`);
-    }
-    for (const command of commands) host.commands.register(command, { replace: options.replace ?? false });
-  } };
-}
-
-export {
-  createPythonLlmToolLoader,
-  pythonLlmPackages,
-  installPythonLlmPackages,
-  createPythonExecutorCommands,
-  pythonExecutorCommands
-};