noumen 0.3.0 → 0.5.0

package/dist/{chunk-4HW6LN6D.js → chunk-WPCYGZOE.js}

@@ -1,6 +1,13 @@
 import {
   applySnipRemovals
 } from "./chunk-42PHHZUA.js";
+import {
+  ToolRegistry,
+  createToolSearchTool,
+  isPathInWorkingDirectories,
+  resolvePermission,
+  resolveToolFlag
+} from "./chunk-XZN4QZLK.js";
 import {
   getAutoCompactThreshold,
   getEffectiveContextWindow,
@@ -12,13 +19,6 @@ import {
 import {
   generateUUID
 } from "./chunk-3HEYCV26.js";
-import {
-  ToolRegistry,
-  createToolSearchTool,
-  isPathInWorkingDirectories,
-  resolvePermission,
-  resolveToolFlag
-} from "./chunk-HL6JCRZJ.js";
 import {
   contentToString,
   hasImageContent,
@@ -178,7 +178,7 @@ var LocalComputer = class {
     this.defaultTimeout = opts?.defaultTimeout ?? 3e4;
   }
   executeCommand(command, opts) {
-    return new Promise((resolve7) => {
+    return new Promise((resolve3) => {
       const child = execCb(
         command,
         {
@@ -189,7 +189,7 @@ var LocalComputer = class {
           shell: process.env.SHELL || "/bin/sh"
         },
         (error, stdout, stderr) => {
-          resolve7({
+          resolve3({
             exitCode: error && "code" in error ? typeof error.code === "number" ? error.code : 1 : child.exitCode ?? 0,
             stdout: stdout ?? "",
             stderr: stderr ?? ""
@@ -250,7 +250,7 @@ var SandboxedLocalComputer = class {
   async executeCommand(command, opts) {
     await this.ensureInitialized();
     const wrappedCommand = await SandboxManager.wrapWithSandbox(command);
-    return new Promise((resolve7) => {
+    return new Promise((resolve3) => {
       const child = execCb2(
         wrappedCommand,
         {
@@ -266,7 +266,7 @@ var SandboxedLocalComputer = class {
             stdout: stdout ?? "",
             stderr: stderr ?? ""
           };
-          Promise.resolve(SandboxManager.cleanupAfterCommand()).then(() => resolve7(result)).catch(() => resolve7(result));
+          Promise.resolve(SandboxManager.cleanupAfterCommand()).then(() => resolve3(result)).catch(() => resolve3(result));
         }
       );
     });
@@ -283,813 +283,7 @@ var SandboxedLocalComputer = class {
   }
 };
 
-// src/virtual/sprites-fs.ts
-import * as path2 from "path";
-var SpritesFs = class {
-  token;
-  spriteName;
-  baseURL;
-  workingDir;
-  constructor(opts) {
-    this.token = opts.token;
-    this.spriteName = opts.spriteName;
-    this.baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(
-      /\/$/,
-      ""
-    );
-    this.workingDir = opts.workingDir ?? "/home/sprite";
-  }
-  fsUrl(endpoint, params) {
-    const url = new URL(
-      `${this.baseURL}/v1/sprites/${this.spriteName}/fs${endpoint}`
-    );
-    if (params) {
-      for (const [k, v] of Object.entries(params)) {
-        url.searchParams.set(k, v);
-      }
-    }
-    return url.toString();
-  }
-  resolvePath(p) {
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      if (p !== this.workingDir && !p.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return p;
-    }
-    const resolved = path2.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  headers() {
-    return {
-      Authorization: `Bearer ${this.token}`
-    };
-  }
-  async readFile(filePath, _opts) {
-    const url = this.fsUrl("/read", { path: this.resolvePath(filePath) });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs readFile failed (${res.status}): ${await res.text()}`
-      );
-    }
-    return res.text();
-  }
-  async readFileBytes(filePath, maxBytes) {
-    const url = this.fsUrl("/read", {
-      path: this.resolvePath(filePath),
-      binary: "true"
-    });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs readFileBytes failed (${res.status}): ${await res.text()}`
-      );
-    }
-    const arrayBuf = await res.arrayBuffer();
-    const buf = Buffer.from(arrayBuf);
-    if (maxBytes !== void 0 && buf.length > maxBytes) {
-      return buf.subarray(0, maxBytes);
-    }
-    return buf;
-  }
-  async writeFile(filePath, content) {
-    const url = this.fsUrl("/write");
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...this.headers(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        path: this.resolvePath(filePath),
-        content
-      })
-    });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs writeFile failed (${res.status}): ${await res.text()}`
-      );
-    }
-  }
-  /**
-   * @warning Not atomic. Concurrent appends may lose data due to
-   * read-then-write TOCTOU. The Sprites API does not expose an append primitive.
-   */
-  async appendFile(filePath, content) {
-    let existing = "";
-    try {
-      existing = await this.readFile(filePath);
-    } catch {
-    }
-    await this.writeFile(filePath, existing + content);
-  }
-  async deleteFile(filePath, opts) {
-    const url = this.fsUrl("/remove");
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...this.headers(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        path: this.resolvePath(filePath),
-        recursive: opts?.recursive ?? false
-      })
-    });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs deleteFile failed (${res.status}): ${await res.text()}`
-      );
-    }
-  }
-  async mkdir(dirPath, opts) {
-    const url = this.fsUrl("/mkdir");
-    const res = await fetch(url, {
-      method: "POST",
-      headers: {
-        ...this.headers(),
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        path: this.resolvePath(dirPath),
-        recursive: opts?.recursive ?? false
-      })
-    });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs mkdir failed (${res.status}): ${await res.text()}`
-      );
-    }
-  }
-  async readdir(dirPath, _opts) {
-    const url = this.fsUrl("/readdir", { path: this.resolvePath(dirPath) });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs readdir failed (${res.status}): ${await res.text()}`
-      );
-    }
-    const data = await res.json();
-    return data.map((entry) => ({
-      name: entry.name,
-      path: entry.path,
-      isDirectory: entry.is_dir,
-      isFile: !entry.is_dir,
-      size: entry.size
-    }));
-  }
-  async exists(filePath) {
-    try {
-      await this.stat(filePath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-  async stat(filePath) {
-    const url = this.fsUrl("/stat", { path: this.resolvePath(filePath) });
-    const res = await fetch(url, { headers: this.headers() });
-    if (!res.ok) {
-      throw new Error(
-        `SpritesFs stat failed (${res.status}): ${await res.text()}`
-      );
-    }
-    const data = await res.json();
-    return {
-      size: data.size,
-      isDirectory: data.is_dir,
-      isFile: !data.is_dir,
-      createdAt: data.created_at ? new Date(data.created_at) : void 0,
-      modifiedAt: data.modified_at ? new Date(data.modified_at) : void 0
-    };
-  }
-};
-
-// src/virtual/sprites-computer.ts
-var SpritesComputer = class {
-  token;
-  spriteName;
-  baseURL;
-  workingDir;
-  constructor(opts) {
-    this.token = opts.token;
-    this.spriteName = opts.spriteName;
-    this.baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(
-      /\/$/,
-      ""
-    );
-    this.workingDir = opts.workingDir ?? "/home/sprite";
-  }
-  headers() {
-    return {
-      Authorization: `Bearer ${this.token}`,
-      "Content-Type": "application/json"
-    };
-  }
-  async executeCommand(command, opts) {
-    const cwd = opts?.cwd ?? this.workingDir;
-    const wrappedCommand = `cd ${this.shellEscape(cwd)} && ${command}`;
-    const url = `${this.baseURL}/v1/sprites/${this.spriteName}/exec`;
-    const res = await fetch(url, {
-      method: "POST",
-      headers: this.headers(),
-      body: JSON.stringify({
-        command: ["bash", "-c", wrappedCommand],
-        timeout: opts?.timeout ?? 3e4,
-        env: opts?.env
-      })
-    });
-    if (!res.ok) {
-      const text = await res.text();
-      return {
-        exitCode: 1,
-        stdout: "",
-        stderr: `Sprites exec failed (${res.status}): ${text}`
-      };
-    }
-    const data = await res.json();
-    return {
-      exitCode: data.exit_code,
-      stdout: data.stdout ?? "",
-      stderr: data.stderr ?? ""
-    };
-  }
-  shellEscape(s) {
-    return `'${s.replace(/'/g, "'\\''")}'`;
-  }
-};
-
-// src/virtual/docker-fs.ts
-import * as path3 from "path";
-var DockerFs = class {
-  container;
-  workingDir;
-  constructor(opts) {
-    this.container = opts.container;
-    this.workingDir = opts.workingDir ?? "/";
-  }
-  resolvePath(p) {
-    if (p.includes("\0")) {
-      throw new Error("Path contains null bytes");
-    }
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      const normalized = path3.normalize(p);
-      if (normalized !== this.workingDir && !normalized.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return normalized;
-    }
-    const resolved = path3.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  async exec(cmd) {
-    const execInstance = await this.container.exec({
-      Cmd: cmd,
-      AttachStdout: true,
-      AttachStderr: true,
-      Tty: false
-    });
-    const stream = await execInstance.start({ hijack: true, stdin: false });
-    const result = await collectExecStream(stream);
-    const inspection = await execInstance.inspect();
-    return { exitCode: inspection.ExitCode, ...result };
-  }
-  async readFile(path6, _opts) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode, stdout, stderr } = await this.exec([
-      "cat",
-      resolved
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs readFile failed: ${stderr.trim() || `exit code ${exitCode}`}`);
-    }
-    return stdout;
-  }
-  async readFileBytes(path6, maxBytes) {
-    const resolved = this.resolvePath(path6);
-    const cmd = maxBytes !== void 0 ? ["head", "-c", String(maxBytes), resolved] : ["cat", resolved];
-    const { exitCode, stdout, stderr } = await this.exec([
-      "bash",
-      "-c",
-      `${cmd.map(shellEscape).join(" ")} | base64`
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs readFileBytes failed: ${stderr.trim() || `exit code ${exitCode}`}`);
-    }
-    return Buffer.from(stdout.trim(), "base64");
-  }
-  async writeFile(path6, content) {
-    const resolved = this.resolvePath(path6);
-    const dir = resolved.substring(0, resolved.lastIndexOf("/"));
-    if (dir) {
-      await this.exec(["mkdir", "-p", dir]);
-    }
-    const encoded = Buffer.from(content, "utf-8").toString("base64");
-    const MAX_INLINE_LEN = 1e5;
-    if (encoded.length <= MAX_INLINE_LEN) {
-      const { exitCode, stderr } = await this.exec([
-        "bash",
-        "-c",
-        `echo ${shellEscape(encoded)} | base64 -d > ${shellEscape(resolved)}`
-      ]);
-      if (exitCode !== 0) {
-        throw new Error(`DockerFs writeFile failed: ${stderr.trim()}`);
-      }
-    } else {
-      const execInstance = await this.container.exec({
-        Cmd: ["bash", "-c", `base64 -d > ${shellEscape(resolved)}`],
-        AttachStdout: true,
-        AttachStderr: true,
-        AttachStdin: true,
-        Tty: false
-      });
-      const stream = await execInstance.start({ hijack: true, stdin: true });
-      const writable = stream;
-      writable.write(encoded);
-      writable.end();
-      const result = await collectExecStream(stream);
-      const inspection = await execInstance.inspect();
-      if (inspection.ExitCode !== 0) {
-        throw new Error(`DockerFs writeFile failed: ${result.stderr.trim()}`);
-      }
-    }
-  }
-  async appendFile(path6, content) {
-    const resolved = this.resolvePath(path6);
-    const dir = resolved.substring(0, resolved.lastIndexOf("/"));
-    if (dir) {
-      await this.exec(["mkdir", "-p", dir]);
-    }
-    const encoded = Buffer.from(content, "utf-8").toString("base64");
-    const { exitCode, stderr } = await this.exec([
-      "bash",
-      "-c",
-      `echo ${shellEscape(encoded)} | base64 -d >> ${shellEscape(resolved)}`
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs appendFile failed: ${stderr.trim()}`);
-    }
-  }
-  async deleteFile(path6, opts) {
-    const resolved = this.resolvePath(path6);
-    const args = opts?.recursive ? ["rm", "-rf", resolved] : ["rm", "-f", resolved];
-    await this.exec(args);
-  }
-  async mkdir(path6, opts) {
-    const resolved = this.resolvePath(path6);
-    const args = opts?.recursive ? ["mkdir", "-p", resolved] : ["mkdir", resolved];
-    await this.exec(args);
-  }
-  async readdir(path6, _opts) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode, stdout, stderr } = await this.exec([
-      "bash",
-      "-c",
-      `find ${shellEscape(resolved)} -maxdepth 1 -mindepth 1 -printf '%y %p\\n' 2>/dev/null`
-    ]);
-    if (exitCode !== 0 && stderr.trim()) {
-      throw new Error(`DockerFs readdir failed: ${stderr.trim()}`);
-    }
-    const entries = [];
-    for (const line of stdout.trim().split("\n")) {
-      if (!line) continue;
-      const spaceIdx = line.indexOf(" ");
-      const type = line.substring(0, spaceIdx);
-      const fullPath = line.substring(spaceIdx + 1);
-      const name = fullPath.substring(fullPath.lastIndexOf("/") + 1);
-      entries.push({
-        name,
-        path: fullPath,
-        isDirectory: type === "d",
-        isFile: type === "f"
-      });
-    }
-    return entries;
-  }
-  async exists(path6) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode } = await this.exec(["test", "-e", resolved]);
-    return exitCode === 0;
-  }
-  async stat(path6) {
-    const resolved = this.resolvePath(path6);
-    const { exitCode, stdout, stderr } = await this.exec([
-      "stat",
-      "-c",
-      "%s	%F	%W	%Y",
-      resolved
-    ]);
-    if (exitCode !== 0) {
-      throw new Error(`DockerFs stat failed: ${stderr.trim() || `exit code ${exitCode}`}`);
-    }
-    const parts = stdout.trim().split("	");
-    const size = parseInt(parts[0], 10);
-    const fileType = parts[1];
-    const createdEpoch = parseInt(parts[2], 10);
-    const modifiedEpoch = parseInt(parts[3], 10);
-    return {
-      size,
-      isDirectory: fileType === "directory",
-      isFile: fileType.startsWith("regular"),
-      createdAt: createdEpoch > 0 ? new Date(createdEpoch * 1e3) : void 0,
-      modifiedAt: modifiedEpoch > 0 ? new Date(modifiedEpoch * 1e3) : void 0
-    };
-  }
-};
-function shellEscape(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function collectExecStream(stream) {
-  return new Promise((resolve7, reject) => {
-    const stdoutBufs = [];
-    const stderrBufs = [];
-    let pending = Buffer.alloc(0);
-    stream.on("data", (chunk) => {
-      let buf = pending.length > 0 ? Buffer.concat([pending, chunk]) : chunk;
-      let offset = 0;
-      while (offset + 8 <= buf.length) {
-        const payloadLen = buf.readUInt32BE(offset + 4);
-        if (offset + 8 + payloadLen > buf.length) break;
-        const streamType = buf[offset];
-        const payload = buf.subarray(offset + 8, offset + 8 + payloadLen);
-        if (streamType === 2) {
-          stderrBufs.push(payload);
-        } else {
-          stdoutBufs.push(payload);
-        }
-        offset += 8 + payloadLen;
-      }
-      pending = offset < buf.length ? buf.subarray(offset) : Buffer.alloc(0);
-    });
-    stream.on("end", () => {
-      resolve7({
-        stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
-        stderr: Buffer.concat(stderrBufs).toString("utf-8")
-      });
-    });
-    stream.on("error", (err) => reject(err));
-  });
-}
-
-// src/virtual/docker-computer.ts
-var DockerComputer = class {
-  container;
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.container = opts.container;
-    this.defaultCwd = opts.defaultCwd ?? "/";
-    this.defaultTimeout = opts.defaultTimeout ?? 3e4;
-  }
-  async executeCommand(command, opts) {
-    const cwd = opts?.cwd ?? this.defaultCwd;
-    const timeout = opts?.timeout ?? this.defaultTimeout;
-    const execOpts = {
-      Cmd: ["bash", "-c", `cd ${shellEscape2(cwd)} && ${command}`],
-      AttachStdout: true,
-      AttachStderr: true,
-      Tty: false
-    };
-    if (opts?.env) {
-      execOpts.Env = Object.entries(opts.env).map(
-        ([k, v]) => `${k}=${v}`
-      );
-    }
-    const exec = await this.container.exec(execOpts);
-    const stream = await exec.start({ hijack: true, stdin: false });
-    const { stdout, stderr } = await collectStream(stream, timeout);
-    const inspection = await exec.inspect();
-    return {
-      exitCode: inspection.ExitCode,
-      stdout,
-      stderr
-    };
-  }
-};
-function shellEscape2(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-function collectStream(stream, timeout) {
-  return new Promise((resolve7, reject) => {
-    const stdoutBufs = [];
-    const stderrBufs = [];
-    let pending = Buffer.alloc(0);
-    const timer = setTimeout(() => {
-      stream.destroy?.();
-      resolve7({
-        stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
-        stderr: Buffer.concat(stderrBufs).toString("utf-8") + "\n[timeout after " + timeout + "ms]"
-      });
-    }, timeout);
-    stream.on("data", (chunk) => {
-      let buf = pending.length > 0 ? Buffer.concat([pending, chunk]) : chunk;
-      let offset = 0;
-      while (offset + 8 <= buf.length) {
-        const payloadLen = buf.readUInt32BE(offset + 4);
-        if (offset + 8 + payloadLen > buf.length) break;
-        const streamType = buf[offset];
-        const payload = buf.subarray(offset + 8, offset + 8 + payloadLen);
-        if (streamType === 2) {
-          stderrBufs.push(payload);
-        } else {
-          stdoutBufs.push(payload);
-        }
-        offset += 8 + payloadLen;
-      }
-      pending = offset < buf.length ? buf.subarray(offset) : Buffer.alloc(0);
-    });
-    stream.on("end", () => {
-      clearTimeout(timer);
-      resolve7({
-        stdout: Buffer.concat(stdoutBufs).toString("utf-8"),
-        stderr: Buffer.concat(stderrBufs).toString("utf-8")
-      });
-    });
-    stream.on("error", (err) => {
-      clearTimeout(timer);
-      reject(err);
-    });
-  });
-}
-
-// src/virtual/e2b-fs.ts
-import * as path4 from "path";
-var E2BFs = class {
-  sandbox;
-  workingDir;
-  constructor(opts) {
-    this.sandbox = opts.sandbox;
-    this.workingDir = opts.workingDir;
-  }
-  resolvePath(p) {
-    if (!this.workingDir) return p;
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      if (p !== this.workingDir && !p.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return p;
-    }
-    const resolved = path4.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  async readFile(path6, _opts) {
-    return this.sandbox.files.read(this.resolvePath(path6), {
-      format: "text"
-    });
-  }
-  async readFileBytes(path6, maxBytes) {
-    const data = await this.sandbox.files.read(this.resolvePath(path6), {
-      format: "bytes"
-    });
-    const buf = Buffer.from(data);
-    if (maxBytes !== void 0 && buf.length > maxBytes) {
-      return buf.subarray(0, maxBytes);
-    }
-    return buf;
-  }
-  async writeFile(path6, content) {
-    await this.sandbox.files.write(this.resolvePath(path6), content);
-  }
-  /**
-   * @warning Not atomic. Concurrent appends may lose data due to
-   * read-then-write TOCTOU. The E2B SDK does not expose an append primitive.
-   */
-  async appendFile(path6, content) {
-    let existing = "";
-    try {
-      existing = await this.readFile(path6);
-    } catch {
-    }
-    await this.writeFile(path6, existing + content);
-  }
-  async deleteFile(path6, _opts) {
-    await this.sandbox.files.remove(this.resolvePath(path6));
-  }
-  async mkdir(path6, _opts) {
-    await this.sandbox.files.makeDir(this.resolvePath(path6));
-  }
-  async readdir(path6, _opts) {
-    const entries = await this.sandbox.files.list(this.resolvePath(path6));
-    return entries.map((entry) => ({
-      name: entry.name,
-      path: entry.path,
-      isDirectory: entry.type === "dir",
-      isFile: entry.type === "file",
-      size: entry.size
-    }));
-  }
-  async exists(path6) {
-    return this.sandbox.files.exists(this.resolvePath(path6));
-  }
-  async stat(path6) {
-    const info = await this.sandbox.files.getInfo(this.resolvePath(path6));
-    return {
-      size: info.size ?? 0,
-      isDirectory: info.type === "dir",
-      isFile: info.type === "file",
-      modifiedAt: info.modifiedTime
-    };
-  }
-};
-
-// src/virtual/e2b-computer.ts
-var E2BComputer = class {
-  sandbox;
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.sandbox = opts.sandbox;
-    this.defaultCwd = opts.defaultCwd;
-    this.defaultTimeout = opts.defaultTimeout ?? 3e4;
-  }
-  async executeCommand(command, opts) {
-    const result = await this.sandbox.commands.run(command, {
-      cwd: opts?.cwd ?? this.defaultCwd,
-      timeout: opts?.timeout ?? this.defaultTimeout,
-      envs: opts?.env
-    });
-    return {
-      exitCode: result.exitCode,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? ""
-    };
-  }
-};
-
-// src/virtual/freestyle-fs.ts
-import * as path5 from "path";
-var FreestyleFs = class {
-  vm;
-  workingDir;
-  constructor(opts) {
-    this.vm = opts.vm;
-    this.workingDir = opts.workingDir;
-  }
-  resolvePath(p) {
-    if (p.includes("\0")) {
-      throw new Error("Path contains null bytes");
-    }
-    if (!this.workingDir) return p;
-    const normalizedBase = this.workingDir.endsWith("/") ? this.workingDir : this.workingDir + "/";
-    if (p.startsWith("/")) {
-      const normalized = path5.normalize(p);
-      if (normalized !== this.workingDir && !normalized.startsWith(normalizedBase)) {
-        throw new Error(`Absolute path "${p}" is outside working directory "${this.workingDir}"`);
-      }
-      return normalized;
-    }
-    const resolved = path5.resolve(this.workingDir, p);
-    if (resolved !== this.workingDir && !resolved.startsWith(normalizedBase)) {
-      throw new Error(`Path "${p}" escapes working directory "${this.workingDir}"`);
-    }
-    return resolved;
-  }
-  async readFile(filePath, _opts) {
-    return this.vm.fs.readTextFile(this.resolvePath(filePath));
-  }
-  async readFileBytes(filePath, maxBytes) {
-    const resolved = this.resolvePath(filePath);
-    const cmd = maxBytes !== void 0 ? `head -c ${maxBytes} ${shellEscape3(resolved)} | base64` : `base64 ${shellEscape3(resolved)}`;
-    const { statusCode, stdout, stderr } = await this.vm.exec(cmd);
-    if (statusCode !== 0) {
-      throw new Error(`FreestyleFs readFileBytes failed: ${stderr?.trim() || `exit code ${statusCode}`}`);
-    }
-    return Buffer.from((stdout ?? "").trim(), "base64");
-  }
-  async writeFile(filePath, content) {
-    await this.vm.fs.writeTextFile(this.resolvePath(filePath), content);
-  }
-  async appendFile(filePath, content) {
-    const resolved = this.resolvePath(filePath);
-    const encoded = Buffer.from(content, "utf-8").toString("base64");
-    const { statusCode, stderr } = await this.vm.exec(
-      `echo ${shellEscape3(encoded)} | base64 -d >> ${shellEscape3(resolved)}`
-    );
-    if (statusCode !== 0) {
-      throw new Error(`FreestyleFs appendFile failed: ${stderr?.trim() || `exit code ${statusCode}`}`);
-    }
-  }
-  async deleteFile(filePath, opts) {
-    const resolved = this.resolvePath(filePath);
-    const flag = opts?.recursive ? "-rf" : "-f";
-    await this.vm.exec(`rm ${flag} ${shellEscape3(resolved)}`);
-  }
-  async mkdir(filePath, opts) {
-    const resolved = this.resolvePath(filePath);
-    const flag = opts?.recursive ? "-p " : "";
-    await this.vm.exec(`mkdir ${flag}${shellEscape3(resolved)}`);
-  }
-  async readdir(dirPath, _opts) {
-    const resolved = this.resolvePath(dirPath);
-    const items = await this.vm.fs.readDir(resolved);
-    return items.map((entry) => ({
-      name: entry.name,
-      path: resolved === "/" ? `/${entry.name}` : `${resolved}/${entry.name}`,
-      isDirectory: entry.kind === "dir" || entry.kind === "directory",
-      isFile: entry.kind === "file"
-    }));
-  }
-  async exists(filePath) {
-    const resolved = this.resolvePath(filePath);
-    const { statusCode } = await this.vm.exec(`test -e ${shellEscape3(resolved)}`);
-    return statusCode === 0;
-  }
-  async stat(filePath) {
-    const resolved = this.resolvePath(filePath);
-    const { statusCode, stdout, stderr } = await this.vm.exec(
-      `stat -c '%s	%F	%W	%Y' ${shellEscape3(resolved)}`
-    );
-    if (statusCode !== 0) {
-      throw new Error(`FreestyleFs stat failed: ${stderr?.trim() || `exit code ${statusCode}`}`);
-    }
-    const parts = (stdout ?? "").trim().split("	");
-    const size = parseInt(parts[0], 10);
-    const fileType = parts[1];
-    const createdEpoch = parseInt(parts[2], 10);
-    const modifiedEpoch = parseInt(parts[3], 10);
-    return {
-      size,
-      isDirectory: fileType === "directory",
-      isFile: fileType.startsWith("regular"),
-      createdAt: createdEpoch > 0 ? new Date(createdEpoch * 1e3) : void 0,
-      modifiedAt: modifiedEpoch > 0 ? new Date(modifiedEpoch * 1e3) : void 0
-    };
-  }
-};
-function shellEscape3(s) {
-  return `'${s.replace(/'/g, "'\\''")}'`;
-}
-
-// src/virtual/freestyle-computer.ts
-var FreestyleComputer = class {
-  vm;
-  defaultCwd;
-  defaultTimeout;
-  constructor(opts) {
-    this.vm = opts.vm;
-    this.defaultCwd = opts.defaultCwd;
-    this.defaultTimeout = opts.defaultTimeout ?? 3e4;
-  }
-  async executeCommand(command, opts) {
-    const result = await this.vm.exec(command, {
-      cwd: opts?.cwd ?? this.defaultCwd,
-      timeout: opts?.timeout ?? this.defaultTimeout
-    });
-    return {
-      exitCode: result.statusCode ?? 1,
-      stdout: result.stdout ?? "",
-      stderr: result.stderr ?? ""
-    };
-  }
-};
-
 // src/virtual/sandbox.ts
-function uninitError() {
-  throw new Error(
-    "Sandbox not initialized \u2014 call init() or pass a pre-created resource"
-  );
-}
-function createFsProxy() {
-  let inner = null;
-  const get = () => inner ?? uninitError();
-  return {
-    setTarget(target) {
-      inner = target;
-    },
-    readFile: (...args) => get().readFile(...args),
-    readFileBytes: (...args) => get().readFileBytes?.(...args),
-    writeFile: (...args) => get().writeFile(...args),
-    appendFile: (...args) => get().appendFile(...args),
-    deleteFile: (...args) => get().deleteFile(...args),
-    mkdir: (...args) => get().mkdir(...args),
-    readdir: (...args) => get().readdir(...args),
-    exists: (...args) => get().exists(...args),
-    stat: (...args) => get().stat(...args)
-  };
-}
-function createComputerProxy() {
-  let inner = null;
-  const get = () => inner ?? uninitError();
-  return {
-    setTarget(target) {
-      inner = target;
-    },
-    executeCommand: (...args) => get().executeCommand(...args)
-  };
-}
 function UnsandboxedLocal(opts) {
   const cwd = opts?.cwd;
   return {
@@ -1121,358 +315,6 @@ function LocalSandbox(opts) {
     dispose: () => computer.dispose()
   };
 }
-function SpritesSandbox(opts) {
-  const baseURL = (opts.baseURL ?? "https://api.sprites.dev").replace(/\/$/, "");
-  const userProvidedName = opts.spriteName;
-  if (userProvidedName) {
-    const fsOpts = { ...opts, spriteName: userProvidedName };
-    return {
-      fs: new SpritesFs(fsOpts),
-      computer: new SpritesComputer(fsOpts),
-      sandboxId: () => userProvidedName
-    };
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let resolvedName;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    let name = reconnectId ?? `${opts.namePrefix ?? "noumen-"}${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-    let needsCreate = !reconnectId;
-    if (reconnectId) {
-      const check = await fetch(`${baseURL}/v1/sprites/${reconnectId}`, {
-        method: "GET",
-        headers: { Authorization: `Bearer ${opts.token}` }
-      });
-      if (!check.ok) {
-        name = `${opts.namePrefix ?? "noumen-"}${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
-        needsCreate = true;
-      }
-    }
-    if (needsCreate) {
-      const res = await fetch(`${baseURL}/v1/sprites`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${opts.token}`,
-          "Content-Type": "application/json"
-        },
-        body: JSON.stringify({ name })
-      });
-      if (!res.ok) {
-        throw new Error(`Sprites auto-create failed (${res.status}): ${await res.text()}`);
-      }
-      autoCreated = true;
-    }
-    resolvedName = name;
-    const childOpts = { ...opts, spriteName: name };
-    fsProxy.setTarget(new SpritesFs(childOpts));
-    computerProxy.setTarget(new SpritesComputer(childOpts));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => resolvedName,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !resolvedName) return;
-      try {
-        const res = await fetch(`${baseURL}/v1/sprites/${resolvedName}`, {
-          method: "DELETE",
-          headers: { Authorization: `Bearer ${opts.token}` }
-        });
-        if (!res.ok && res.status !== 404) {
-          throw new Error(`Sprites dispose failed (${res.status}): ${await res.text()}`);
-        }
-      } catch {
-      }
-    }
-  };
-}
-function DockerSandbox(opts) {
-  if (opts.container) {
-    const c = opts.container;
-    return {
-      fs: new DockerFs({ container: c, workingDir: opts.cwd }),
-      computer: new DockerComputer({
-        container: c,
-        defaultCwd: opts.cwd,
-        defaultTimeout: opts.defaultTimeout
-      }),
-      sandboxId: () => c.id
-    };
-  }
-  if (!opts.image) {
-    throw new Error("DockerSandbox requires either `container` or `image`");
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let containerId;
-  let containerRef;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    const Docker = (await import("dockerode")).default;
-    const docker = new Docker();
-    let container;
-    if (reconnectId) {
-      container = docker.getContainer(reconnectId);
-      try {
-        await container.inspect();
-      } catch {
-        container = await docker.createContainer({
-          Image: opts.image,
-          Cmd: opts.cmd ?? ["sleep", "infinity"],
-          Env: opts.env,
-          Tty: false,
-          ...opts.dockerOptions
-        });
-        await container.start();
-        autoCreated = true;
-      }
-    } else {
-      container = await docker.createContainer({
-        Image: opts.image,
-        Cmd: opts.cmd ?? ["sleep", "infinity"],
-        Env: opts.env,
-        Tty: false,
-        ...opts.dockerOptions
-      });
-      await container.start();
-      autoCreated = true;
-    }
-    containerRef = container;
-    containerId = container.id;
-    fsProxy.setTarget(new DockerFs({ container, workingDir: opts.cwd }));
-    computerProxy.setTarget(new DockerComputer({
-      container,
-      defaultCwd: opts.cwd,
-      defaultTimeout: opts.defaultTimeout
-    }));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => containerId,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !containerRef) return;
-      try {
-        await containerRef.stop();
-      } catch {
-      }
-      try {
-        await containerRef.remove();
-      } catch {
-      }
-    }
-  };
-}
-function E2BSandbox(opts) {
-  if (opts.sandbox) {
-    const s = opts.sandbox;
-    return {
-      fs: new E2BFs({ sandbox: s, workingDir: opts.cwd }),
-      computer: new E2BComputer({
-        sandbox: s,
-        defaultCwd: opts.cwd,
-        defaultTimeout: opts.defaultTimeout
-      }),
-      sandboxId: () => s.sandboxId
-    };
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let resolvedId;
-  let sandboxRef;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    const e2b = await import("e2b");
-    const SandboxClass = e2b.Sandbox ?? e2b.default?.Sandbox;
-    if (!SandboxClass) {
-      throw new Error("Could not resolve Sandbox class from 'e2b' package");
-    }
-    let sandbox;
-    if (reconnectId) {
-      try {
-        sandbox = await SandboxClass.connect(reconnectId, {
-          apiKey: opts.apiKey
-        });
-      } catch {
-        sandbox = await SandboxClass.create({
-          template: opts.template ?? "base",
-          apiKey: opts.apiKey,
-          timeoutMs: opts.timeoutMs
-        });
-        autoCreated = true;
-      }
-    } else {
-      sandbox = await SandboxClass.create({
-        template: opts.template ?? "base",
-        apiKey: opts.apiKey,
-        timeoutMs: opts.timeoutMs
-      });
-      autoCreated = true;
-    }
-    sandboxRef = sandbox;
-    resolvedId = sandbox.sandboxId ?? reconnectId;
-    fsProxy.setTarget(new E2BFs({ sandbox, workingDir: opts.cwd }));
-    computerProxy.setTarget(new E2BComputer({
-      sandbox,
-      defaultCwd: opts.cwd,
-      defaultTimeout: opts.defaultTimeout
-    }));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => resolvedId,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !sandboxRef) return;
-      if (typeof sandboxRef.kill === "function") {
-        await sandboxRef.kill();
-      }
-    }
-  };
-}
-function FreestyleSandbox(opts) {
-  if (opts.vm) {
-    const v = opts.vm;
-    return {
-      fs: new FreestyleFs({ vm: v, workingDir: opts.cwd }),
-      computer: new FreestyleComputer({
-        vm: v,
-        defaultCwd: opts.cwd,
-        defaultTimeout: opts.defaultTimeout
-      }),
-      sandboxId: () => v.vmId
-    };
-  }
-  const fsProxy = createFsProxy();
-  const computerProxy = createComputerProxy();
-  let resolvedId;
-  let vmRef = null;
-  let autoCreated = false;
-  let initPromise = null;
-  async function doInit(reconnectId) {
-    const mod = await import("freestyle-sandboxes");
-    const freestyle = mod.freestyle ?? mod.default?.freestyle;
-    if (!freestyle?.vms) {
-      throw new Error("Could not resolve freestyle client from 'freestyle-sandboxes' package");
-    }
-    let vm;
-    if (reconnectId) {
-      try {
-        const result = await freestyle.vms.get({ vmId: reconnectId });
-        vm = result.vm;
-        resolvedId = reconnectId;
-      } catch {
-        const result = await freestyle.vms.create({
-          ...opts.spec ? { spec: opts.spec } : {},
-          snapshotId: opts.snapshotId,
-          workdir: opts.cwd,
-          idleTimeoutSeconds: opts.idleTimeoutSeconds ?? 600,
-          additionalFiles: opts.additionalFiles,
-          gitRepos: opts.gitRepos
-        });
-        vm = result.vm;
-        resolvedId = result.vmId ?? result.id;
-        autoCreated = true;
-      }
-    } else {
-      const result = await freestyle.vms.create({
-        ...opts.spec ? { spec: opts.spec } : {},
-        snapshotId: opts.snapshotId,
-        workdir: opts.cwd,
-        idleTimeoutSeconds: opts.idleTimeoutSeconds ?? 600,
-        additionalFiles: opts.additionalFiles,
-        gitRepos: opts.gitRepos
-      });
-      vm = result.vm;
-      resolvedId = result.vmId ?? result.id;
-      autoCreated = true;
-    }
-    vmRef = vm;
-    fsProxy.setTarget(new FreestyleFs({ vm, workingDir: opts.cwd }));
-    computerProxy.setTarget(new FreestyleComputer({
-      vm,
-      defaultCwd: opts.cwd,
-      defaultTimeout: opts.defaultTimeout
-    }));
-  }
-  return {
-    fs: fsProxy,
-    computer: computerProxy,
-    sandboxId: () => resolvedId,
-    init(sandboxId) {
-      if (!initPromise) {
-        initPromise = doInit(sandboxId).catch((err) => {
-          initPromise = null;
-          throw err;
-        });
-      }
-      return initPromise;
-    },
-    async dispose() {
-      if (initPromise) {
-        await initPromise.catch(() => {
-        });
-      }
-      if (!autoCreated || !vmRef || !resolvedId) return;
-      try {
-        const strategy = opts.disposeStrategy ?? "suspend";
-        if (strategy === "suspend") {
-          await vmRef.suspend();
-        } else {
-          const mod = await import("freestyle-sandboxes");
-          const freestyle = mod.freestyle ?? mod.default?.freestyle;
-          if (freestyle?.vms) {
-            await freestyle.vms.delete({ vmId: resolvedId });
-          }
-        }
-      } catch {
-      }
-    }
-  };
-}
 
 // src/checkpoint/manager.ts
 import { createHash } from "crypto";
@@ -1704,8 +546,8 @@ var FileCheckpointManager = class {
   restoreStateFromEntries(snapshots) {
     const trackedFiles = /* @__PURE__ */ new Set();
     for (const snap of snapshots) {
-      for (const path6 of Object.keys(snap.trackedFileBackups)) {
-        trackedFiles.add(path6);
+      for (const path2 of Object.keys(snap.trackedFileBackups)) {
+        trackedFiles.add(path2);
       }
     }
     this.state = {
@@ -1719,7 +561,7 @@ var FileCheckpointManager = class {
 // src/hooks/runner.ts
 var DEFAULT_HOOK_TIMEOUT_MS = 3e4;
 function withTimeout(promise, timeoutMs, label) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve3, reject) => {
     const timer = setTimeout(
       () => reject(new Error(`Hook "${label}" timed out after ${timeoutMs}ms`)),
       timeoutMs
@@ -1727,7 +569,7 @@ function withTimeout(promise, timeoutMs, label) {
     promise.then(
       (v) => {
         clearTimeout(timer);
-        resolve7(v);
+        resolve3(v);
       },
       (e) => {
         clearTimeout(timer);
@@ -2991,10 +1833,10 @@ var SessionStorage = class {
     }
   }
   async loadMessages(sessionId) {
-    const path6 = this.getTranscriptPath(sessionId);
-    const exists = await this.fs.exists(path6);
+    const path2 = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path2);
     if (!exists) return [];
-    const content = await this.fs.readFile(path6);
+    const content = await this.fs.readFile(path2);
     const entries = parseJSONL(content);
     let lastBoundaryIdx = -1;
     for (let i = entries.length - 1; i >= 0; i--) {
@@ -3029,10 +1871,10 @@ var SessionStorage = class {
     return messages;
   }
   async loadAllEntries(sessionId) {
-    const path6 = this.getTranscriptPath(sessionId);
-    const exists = await this.fs.exists(path6);
+    const path2 = this.getTranscriptPath(sessionId);
+    const exists = await this.fs.exists(path2);
     if (!exists) return [];
-    const content = await this.fs.readFile(path6);
+    const content = await this.fs.readFile(path2);
     return parseJSONL(content);
   }
   async sessionExists(sessionId) {
@@ -3402,17 +2244,17 @@ function walkAncestors(cwd) {
   }
   return dirs;
 }
-async function tryLoadFile(fs2, path6, scope, out, maxDepth, excludes) {
-  if (isExcluded(path6, excludes)) return;
-  const file = await loadContextFile(fs2, path6, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
+async function tryLoadFile(fs2, path2, scope, out, maxDepth, excludes) {
+  if (isExcluded(path2, excludes)) return;
+  const file = await loadContextFile(fs2, path2, scope, /* @__PURE__ */ new Set(), 0, maxDepth);
   if (file) out.push(file);
 }
-async function loadContextFile(fs2, path6, scope, visited, depth, maxDepth) {
-  const normalized = normalizePath(path6);
+async function loadContextFile(fs2, path2, scope, visited, depth, maxDepth) {
+  const normalized = normalizePath(path2);
   if (visited.has(normalized)) return null;
   let raw;
   try {
-    raw = await fs2.readFile(path6);
+    raw = await fs2.readFile(path2);
   } catch {
     return null;
   }
@@ -3421,9 +2263,9 @@ async function loadContextFile(fs2, path6, scope, visited, depth, maxDepth) {
   const { frontmatter, body } = parseFrontmatter(raw);
   const globs = parsePaths(frontmatter.paths);
   const content = stripHtmlComments(body);
-  const includes = await resolveIncludes(fs2, content, path6, visited, depth, maxDepth);
+  const includes = await resolveIncludes(fs2, content, path2, visited, depth, maxDepth);
   return {
-    path: path6,
+    path: path2,
     scope,
     content,
     ...globs.length > 0 ? { globs } : {},
@@ -3489,15 +2331,15 @@ function stripHtmlComments(content) {
   if (!content.includes("<!--")) return content;
   return content.replace(/<!--[\s\S]*?-->/g, "");
 }
-function isExcluded(path6, excludes) {
+function isExcluded(path2, excludes) {
   if (excludes.length === 0) return false;
   return excludes.some((pattern) => {
-    if (path6 === pattern) return true;
+    if (path2 === pattern) return true;
     if (pattern.includes("*")) {
       const regex = simpleGlobToRegex(pattern);
-      return regex.test(path6);
+      return regex.test(path2);
     }
-    return path6.includes(pattern);
+    return path2.includes(pattern);
   });
 }
 function simpleGlobToRegex(glob) {
@@ -6231,7 +5073,7 @@ async function executeToolsStep(toolCalls, streamingExec, streamingResults, exec
 }
 
 // src/file-state/cache.ts
-import { normalize as normalize4 } from "path";
+import { normalize as normalize2 } from "path";
 var DEFAULT_MAX_ENTRIES = 100;
 var DEFAULT_MAX_BYTES = 25 * 1024 * 1024;
 var FileStateCache = class {
@@ -6243,14 +5085,14 @@ var FileStateCache = class {
     this.maxEntries = config?.maxEntries ?? DEFAULT_MAX_ENTRIES;
     this.maxBytes = config?.maxBytes ?? DEFAULT_MAX_BYTES;
   }
-  key(path6) {
-    return normalize4(path6);
+  key(path2) {
+    return normalize2(path2);
   }
   byteSize(state) {
     return Math.max(1, Buffer.byteLength(state.content, "utf8"));
   }
-  set(path6, state) {
-    const k = this.key(path6);
+  set(path2, state) {
+    const k = this.key(path2);
     const existing = this.entries.get(k);
     if (existing) {
       this.currentBytes -= this.byteSize(existing);
@@ -6266,19 +5108,19 @@ var FileStateCache = class {
     this.entries.set(k, state);
     this.currentBytes += size;
   }
-  get(path6) {
-    const k = this.key(path6);
+  get(path2) {
+    const k = this.key(path2);
     const state = this.entries.get(k);
     if (!state) return void 0;
     this.entries.delete(k);
     this.entries.set(k, state);
     return state;
   }
-  has(path6) {
-    return this.entries.has(this.key(path6));
+  has(path2) {
+    return this.entries.has(this.key(path2));
   }
-  delete(path6) {
-    const k = this.key(path6);
+  delete(path2) {
+    const k = this.key(path2);
     const existing = this.entries.get(k);
     if (existing) {
       this.currentBytes -= this.byteSize(existing);
@@ -6320,8 +5162,8 @@ function getActiveSkills(allSkills, activatedNames) {
     return activatedNames.has(skill.name);
   });
 }
-function matchesAnyGlob(path6, patterns) {
-  return patterns.some((pattern) => globMatch(pattern, path6));
+function matchesAnyGlob(path2, patterns) {
+  return patterns.some((pattern) => globMatch(pattern, path2));
 }
 function globMatch(pattern, str) {
   const regex = globToRegex(pattern);
@@ -6803,8 +5645,8 @@ var StreamingToolExecutor = class {
       }
       if (this.hasExecuting() && !this.hasCompleted()) {
         const executingPromises = this.tools.filter((t) => t.status === "executing" && t.promise).map((t) => t.promise);
-        const progressPromise = new Promise((resolve7) => {
-          this.progressResolve = resolve7;
+        const progressPromise = new Promise((resolve3) => {
+          this.progressResolve = resolve3;
         });
         if (executingPromises.length > 0) {
           await Promise.race([...executingPromises, progressPromise]);
@@ -6847,7 +5689,7 @@ function getRetryDelay(attempt, retryAfterHeader, maxDelayMs = 32e3, baseDelayMs
   return baseDelay + jitter;
 }
 function sleep(ms, signal) {
-  return new Promise((resolve7, reject) => {
+  return new Promise((resolve3, reject) => {
     if (signal?.aborted) {
       reject(new DOMException("Aborted", "AbortError"));
       return;
@@ -6858,7 +5700,7 @@ function sleep(ms, signal) {
     };
     const timer = setTimeout(() => {
       signal?.removeEventListener("abort", onAbort);
-      resolve7();
+      resolve3();
     }, ms);
     signal?.addEventListener("abort", onAbort, { once: true });
   });
@@ -9216,7 +8058,7 @@ var Agent = class {
     if (this.resolvedProvider) return this.resolvedProvider;
     if (!this.providerPromise) {
       this.providerPromise = (async () => {
-        const { resolveProvider: resolveProvider2 } = await import("./resolve-4JA2BBDA.js");
+        const { resolveProvider: resolveProvider2 } = await import("./resolve-GDSHNMG6.js");
         return resolveProvider2(this.providerInput, { model: this.model });
       })();
     }
@@ -10161,18 +9003,18 @@ var FileMemoryProvider = class {
       return "";
     }
   }
-  async loadEntry(path6) {
-    const fullPath = path6.startsWith(this.dir) ? path6 : this.dir + path6;
+  async loadEntry(path2) {
+    const fullPath = path2.startsWith(this.dir) ? path2 : this.dir + path2;
     try {
       const raw = await this.fs.readFile(fullPath);
       const fm = parseFrontmatter2(raw);
       const stat2 = await this.fs.stat(fullPath).catch(() => null);
       return {
-        name: fm.name ?? pathToName(path6),
+        name: fm.name ?? pathToName(path2),
         description: fm.description ?? "",
         type: fm.type ?? "project",
         content: fm.rest,
-        path: path6.startsWith(this.dir) ? path6.slice(this.dir.length) : path6,
+        path: path2.startsWith(this.dir) ? path2.slice(this.dir.length) : path2,
         updatedAt: stat2?.modifiedAt?.toISOString()
       };
     } catch {
@@ -10187,8 +9029,8 @@ var FileMemoryProvider = class {
     await this.fs.writeFile(fullPath, content);
     await this.rebuildIndex();
   }
-  async removeEntry(path6) {
-    const fullPath = path6.startsWith(this.dir) ? path6 : this.dir + path6;
+  async removeEntry(path2) {
+    const fullPath = path2.startsWith(this.dir) ? path2 : this.dir + path2;
     try {
       await this.fs.deleteFile(fullPath);
     } catch {
@@ -10237,20 +9079,8 @@ export {
   LocalFs,
   LocalComputer,
   SandboxedLocalComputer,
-  SpritesFs,
-  SpritesComputer,
-  DockerFs,
-  DockerComputer,
-  E2BFs,
-  E2BComputer,
-  FreestyleFs,
-  FreestyleComputer,
   UnsandboxedLocal,
   LocalSandbox,
-  SpritesSandbox,
-  DockerSandbox,
-  E2BSandbox,
-  FreestyleSandbox,
   createCheckpointState,
   FileCheckpointManager,
   runPreToolUseHooks,
@@ -10362,4 +9192,4 @@ export {
   truncateIndex,
   FileMemoryProvider
 };
-//# sourceMappingURL=chunk-4HW6LN6D.js.map
+//# sourceMappingURL=chunk-WPCYGZOE.js.map