@deepagents/context 1.0.0 → 2.2.0

package/dist/index.js

@@ -2623,6 +2623,8 @@ var SavePipeline = class {
   async persist() {
     let parentId = this.#engine.getActiveBranch().headMessageId;
     const now = Date.now();
+    const messages = [];
+    const pendingMessagesById = /* @__PURE__ */ new Map();
     for (const fragment2 of this.#pending) {
       if (!fragment2.codec) {
         throw new Error(`Fragment "${fragment2.name}" is missing codec.`);
@@ -2630,7 +2632,7 @@ var SavePipeline = class {
       const msgId = fragment2.id ?? crypto.randomUUID();
       let msgParentId = parentId;
       if (!this.#shouldBranch && msgId === parentId) {
-        const existing = await this.#engine.store.getMessage(msgId);
+        const existing = pendingMessagesById.get(msgId) ?? await this.#engine.store.getMessage(msgId);
         if (existing) msgParentId = existing.parentId;
       }
       const messageData = {
@@ -2642,7 +2644,8 @@ var SavePipeline = class {
         data: fragment2.codec.encode(),
         createdAt: now
       };
-      await this.#engine.store.addMessage(messageData);
+      messages.push(messageData);
+      pendingMessagesById.set(messageData.id, messageData);
       parentId = messageData.id;
     }
     if (parentId === null) {
@@ -2650,6 +2653,7 @@ var SavePipeline = class {
         "Pipeline persisted no messages but pending was not empty"
       );
     }
+    await this.#engine.store.addMessages(messages);
     await this.#engine.commitHead(parentId);
     return { headMessageId: parentId };
   }
@@ -2765,6 +2769,18 @@ var ddl_sqlite_default = "-- Context Store DDL for SQLite\n-- This schema implem
 
 // packages/context/src/lib/store/store.ts
 var ContextStore = class {
+  /**
+   * Add multiple messages to the graph.
+   *
+   * Stores can override this for atomic/batched persistence. The default keeps
+   * the single-message contract for implementations that do not need a custom
+   * batch path.
+   */
+  async addMessages(messages) {
+    for (const message2 of messages) {
+      await this.addMessage(message2);
+    }
+  }
 };
 
 // packages/context/src/lib/store/sqlite.store.ts
@@ -2972,7 +2988,7 @@ var SqliteContextStore = class extends ContextStore {
   // ==========================================================================
   // Message Operations (Graph Nodes)
   // ==========================================================================
-  async addMessage(message2) {
+  #insertMessage(message2) {
     if (message2.parentId === message2.id) {
       throw new Error(`Message ${message2.id} cannot be its own parent`);
     }
@@ -2999,6 +3015,17 @@ var SqliteContextStore = class extends ContextStore {
        VALUES (?, ?, ?, ?)`
     ).run(message2.id, message2.chatId, message2.name, content);
   }
+  async addMessage(message2) {
+    this.#insertMessage(message2);
+  }
+  async addMessages(messages) {
+    if (messages.length === 0) return;
+    this.#useTransaction(() => {
+      for (const message2 of messages) {
+        this.#insertMessage(message2);
+      }
+    });
+  }
   async getMessage(messageId) {
     const row = this.#stmt("SELECT * FROM messages WHERE id = ?").get(
       messageId
@@ -4697,7 +4724,7 @@ async function chat(agent2, options = {}) {
       if (isAborted) {
         normalizedMessage.parts = sanitizeAbortedParts(normalizedMessage.parts);
       }
-      const drained = sandbox.drainFileEvents?.() ?? [];
+      const drained = sandbox.drainFileEvents();
       const fileEvents = isAborted ? [] : drained;
       const finalMetadata = await options.finalAssistantMetadata?.(normalizedMessage);
       const mergedMetadata = {
@@ -5454,15 +5481,15 @@ function dateReminder(options) {
       const now = /* @__PURE__ */ new Date();
       const currentDate = formatDateKey(now, tz);
       const currentDay = formatDayOfWeek(now, tz);
-      let diff = "";
+      let diff2 = "";
       if (ctx.lastMessageAt !== void 0) {
         const prev = new Date(ctx.lastMessageAt);
-        diff = formatDiff([
+        diff2 = formatDiff([
           diffLine("date", formatDateKey(prev, tz), currentDate),
           diffLine("day of week", formatDayOfWeek(prev, tz), currentDay)
         ]);
       }
-      return `${diff}Date: ${currentDate}
+      return `${diff2}Date: ${currentDate}
 Day of Week: ${currentDay}`;
     },
     { when: dayChanged(options), asPart: false }
@@ -5474,14 +5501,14 @@ function timeReminder(options) {
       const tz = resolveTz(options, ctx);
       const now = /* @__PURE__ */ new Date();
       const currentTime = formatTime(now, tz);
-      let diff = "";
+      let diff2 = "";
       if (ctx.lastMessageAt !== void 0) {
         const prev = new Date(ctx.lastMessageAt);
-        diff = formatDiff([
+        diff2 = formatDiff([
           diffLine("hour", formatHour(prev, tz), formatHour(now, tz))
         ]);
       }
-      return `${diff}Time: ${currentTime}`;
+      return `${diff2}Time: ${currentTime}`;
     },
     { when: hourChanged(options), asPart: false }
   );
@@ -5492,14 +5519,14 @@ function monthReminder(options) {
       const tz = resolveTz(options, ctx);
       const now = /* @__PURE__ */ new Date();
       const currentMonth = formatMonthName(now, tz);
-      let diff = "";
+      let diff2 = "";
       if (ctx.lastMessageAt !== void 0) {
         const prev = new Date(ctx.lastMessageAt);
-        diff = formatDiff([
+        diff2 = formatDiff([
           diffLine("month", formatMonthName(prev, tz), currentMonth)
         ]);
       }
-      return `${diff}Month: ${currentMonth}`;
+      return `${diff2}Month: ${currentMonth}`;
     },
     { when: monthChanged(options), asPart: false }
   );
@@ -5510,14 +5537,14 @@ function yearReminder(options) {
       const tz = resolveTz(options, ctx);
       const now = /* @__PURE__ */ new Date();
       const currentYear = formatYear(now, tz);
-      let diff = "";
+      let diff2 = "";
       if (ctx.lastMessageAt !== void 0) {
         const prev = new Date(ctx.lastMessageAt);
-        diff = formatDiff([
+        diff2 = formatDiff([
           diffLine("year", formatYear(prev, tz), currentYear)
         ]);
       }
-      return `${diff}Year: ${currentYear}`;
+      return `${diff2}Year: ${currentYear}`;
     },
     { when: yearChanged(options), asPart: false }
   );
@@ -5528,14 +5555,14 @@ function seasonReminder(options) {
       const tz = resolveTz(options, ctx);
       const now = /* @__PURE__ */ new Date();
       const currentSeason = getSeason(getMonthIndex(now, tz));
-      let diff = "";
+      let diff2 = "";
       if (ctx.lastMessageAt !== void 0) {
         const prev = new Date(ctx.lastMessageAt);
-        diff = formatDiff([
+        diff2 = formatDiff([
           diffLine("season", getSeason(getMonthIndex(prev, tz)), currentSeason)
         ]);
       }
-      return `${diff}Season: ${currentSeason}`;
+      return `${diff2}Season: ${currentSeason}`;
     },
     { when: seasonChanged(options), asPart: false }
   );
@@ -5553,11 +5580,11 @@ function localeReminder() {
       const current = getLocaleFromMessage(ctx.currentMessage);
       if (!current) return "";
       const last = getLocaleFromMessage(ctx.lastMessage);
-      const diff = last ? formatDiff([
+      const diff2 = last ? formatDiff([
         diffLine("language", last.language, current.language),
         diffLine("timezone", last.timeZone, current.timeZone)
       ]) : "";
-      return `${diff}Language: ${current.language}
+      return `${diff2}Language: ${current.language}
 Timezone: ${current.timeZone}`;
     },
     { when: whenFn, asPart: false }
@@ -5829,9 +5856,37 @@ function render(tag, ...fragments) {
   return renderer.render([wrapped]);
 }
 
+// packages/context/src/lib/sandbox/abort.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var ambientAbortSignal = new AsyncLocalStorage();
+function runWithAbortSignal(signal, fn) {
+  return ambientAbortSignal.run(signal, fn);
+}
+function withAbortSignal(sandbox) {
+  const decorated = {
+    ...sandbox,
+    async executeCommand(command, options) {
+      const signal = options?.signal ?? ambientAbortSignal.getStore();
+      return sandbox.executeCommand(
+        command,
+        signal ? { ...options, signal } : options
+      );
+    }
+  };
+  if (sandbox.spawn) {
+    const innerSpawn = sandbox.spawn.bind(sandbox);
+    decorated.spawn = (command, options) => {
+      const signal = options?.signal ?? ambientAbortSignal.getStore();
+      return innerSpawn(command, signal ? { ...options, signal } : options);
+    };
+  }
+  return decorated;
+}
+
 // packages/context/src/lib/sandbox/agent-os-sandbox.ts
 import "bash-tool";
-var textDecoder = new TextDecoder();
+import { PassThrough, Readable } from "node:stream";
+var decoder = new TextDecoder();
 var AgentOsSandboxError = class extends Error {
   constructor(message2) {
     super(message2);
@@ -5863,6 +5918,49 @@ async function importAgentOs() {
     );
   }
 }
+var SIGKILL_EXIT_CODE = 9;
+function startKernelProcess(os, command, options) {
+  const { pid } = os.spawn("sh", ["-c", command], options);
+  const stdout = new PassThrough();
+  const stderr = new PassThrough();
+  const unsubOut = os.onProcessStdout(pid, (chunk) => stdout.write(chunk));
+  const unsubErr = os.onProcessStderr(pid, (chunk) => stderr.write(chunk));
+  let killSignalled = false;
+  const exit = os.waitProcess(pid).finally(() => {
+    unsubOut();
+    unsubErr();
+    stdout.end();
+    stderr.end();
+  });
+  return {
+    pid,
+    stdout,
+    stderr,
+    exit,
+    kill: () => {
+      if (killSignalled) return;
+      killSignalled = true;
+      os.killProcess(pid);
+    },
+    wasKilled: (exitCode) => killSignalled && exitCode === SIGKILL_EXIT_CODE
+  };
+}
+async function readAll(stream) {
+  const chunks = [];
+  for await (const chunk of stream) chunks.push(chunk);
+  return Buffer.concat(chunks).toString("utf8");
+}
+function bindAbort(signal, onAbort) {
+  if (!signal) return () => {
+  };
+  if (signal.aborted) {
+    onAbort();
+    return () => {
+    };
+  }
+  signal.addEventListener("abort", onAbort, { once: true });
+  return () => signal.removeEventListener("abort", onAbort);
+}
 async function createAgentOsSandbox(options = {}) {
   const { AgentOs } = await importAgentOs();
   let os;
@@ -5873,27 +5971,56 @@ async function createAgentOsSandbox(options = {}) {
     throw new AgentOsCreationError(err.message, err);
   }
   return {
-    async executeCommand(command) {
+    async executeCommand(command, { signal } = {}) {
+      if (signal?.aborted) {
+        return { stdout: "", stderr: "", exitCode: SIGKILL_EXIT_CODE };
+      }
+      const proc = startKernelProcess(os, command, {});
+      const unbind = bindAbort(signal, proc.kill);
       try {
-        const result = await os.exec(command);
+        const [stdout, stderr, exitCode] = await Promise.all([
+          readAll(proc.stdout),
+          readAll(proc.stderr),
+          proc.exit
+        ]);
+        return { stdout, stderr, exitCode };
+      } finally {
+        unbind();
+      }
+    },
+    spawn(command, { signal, env, cwd } = {}) {
+      if (signal?.aborted) {
+        const empty = () => new ReadableStream({ start: (c) => c.close() });
         return {
-          stdout: result.stdout,
-          stderr: result.stderr,
-          exitCode: result.exitCode
+          stdout: empty(),
+          stderr: empty(),
+          exit: Promise.resolve({
+            code: null,
+            signal: "SIGKILL",
+            success: false
+          })
         };
-      } catch (error) {
-        const err = error;
+      }
+      const proc = startKernelProcess(os, command, { env, cwd });
+      const unbind = bindAbort(signal, proc.kill);
+      const exit = proc.exit.then((code) => {
+        const killed = proc.wasKilled(code);
         return {
-          stdout: err.stdout || "",
-          stderr: err.stderr || err.message || "",
-          exitCode: err.exitCode ?? 1
+          code: killed ? null : code,
+          signal: killed ? "SIGKILL" : null,
+          success: !killed && code === 0
         };
-      }
+      }).finally(unbind);
+      return {
+        stdout: Readable.toWeb(proc.stdout),
+        stderr: Readable.toWeb(proc.stderr),
+        exit
+      };
     },
     async readFile(path5) {
       try {
         const bytes = await os.readFile(path5);
-        return textDecoder.decode(bytes);
+        return decoder.decode(bytes);
       } catch (error) {
         throw new Error(
           `Failed to read file "${path5}": ${error instanceof Error ? error.message : String(error)}`
@@ -5935,8 +6062,8 @@ var BashException = class extends Error {
 };
 
 // packages/context/src/lib/sandbox/bash-meta.ts
-import { AsyncLocalStorage } from "node:async_hooks";
-var store = new AsyncLocalStorage();
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var store = new AsyncLocalStorage2();
 function runWithBashMeta(fn) {
   return store.run({ hidden: {} }, fn);
 }
@@ -5966,6 +6093,160 @@ import {
 } from "bash-tool";
 import z3 from "zod";
 
+// packages/context/src/lib/sandbox/file-events.ts
+var SnapshotFailedError = class extends Error {
+  stderr;
+  constructor(message2, stderr) {
+    super(message2);
+    this.name = "SnapshotFailedError";
+    this.stderr = stderr;
+  }
+};
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+async function snapshot(execute, destination) {
+  const probe = await execute(`[ -d ${shellQuote(destination)} ]`);
+  if (probe.exitCode !== 0) return /* @__PURE__ */ new Map();
+  const list = await execute(
+    `find ${shellQuote(destination)} -type f -print0 | while IFS= read -r -d '' p; do sha256sum "$p"; done`
+  );
+  if (list.exitCode !== 0) {
+    throw new SnapshotFailedError(
+      `snapshot failed for ${destination}`,
+      list.stderr
+    );
+  }
+  const snap = /* @__PURE__ */ new Map();
+  if (!list.stdout) return snap;
+  for (const line of list.stdout.split("\n")) {
+    if (line.length < 66) continue;
+    snap.set(line.slice(66), line.slice(0, 64));
+  }
+  return snap;
+}
+function lazyReadable(innerPromise) {
+  let reader = null;
+  return new ReadableStream({
+    async pull(controller) {
+      if (!reader) {
+        const inner = await innerPromise;
+        reader = inner.getReader();
+      }
+      const { done, value } = await reader.read();
+      if (done) controller.close();
+      else controller.enqueue(value);
+    },
+    async cancel(reason) {
+      if (reader) {
+        await reader.cancel(reason);
+      } else {
+        const inner = await innerPromise;
+        await inner.cancel(reason);
+      }
+    }
+  });
+}
+function diff(before, after) {
+  const events = [];
+  const ts = Date.now();
+  for (const [path5, hash] of after) {
+    const prior = before.get(path5);
+    if (prior === void 0) {
+      events.push({ path: path5, op: "write", timestamp: ts });
+    } else if (prior !== hash) {
+      events.push({ path: path5, op: "modify", timestamp: ts });
+    }
+  }
+  for (const path5 of before.keys()) {
+    if (!after.has(path5)) {
+      events.push({ path: path5, op: "delete", timestamp: ts });
+    }
+  }
+  return events;
+}
+function observeSandboxFileEvents(sandbox, options) {
+  const { destination } = options;
+  if (!destination) {
+    throw new Error("observeSandboxFileEvents: destination is required");
+  }
+  const innerExecute = sandbox.executeCommand.bind(sandbox);
+  const innerReadFile = sandbox.readFile.bind(sandbox);
+  const innerWriteFiles = sandbox.writeFiles.bind(sandbox);
+  const buffer = [];
+  const observe = async (fn) => {
+    const before = await snapshot(innerExecute, destination);
+    const takeAfter = async () => {
+      const after = await snapshot(innerExecute, destination);
+      buffer.push(...diff(before, after));
+    };
+    try {
+      const result = await fn();
+      await takeAfter();
+      return result;
+    } catch (err) {
+      await takeAfter().catch(() => {
+      });
+      throw err;
+    }
+  };
+  const decorated = {
+    async executeCommand(command, options2) {
+      return observe(() => innerExecute(command, options2));
+    },
+    async readFile(path5) {
+      const content = await innerReadFile(path5);
+      buffer.push({ path: path5, op: "read", timestamp: Date.now() });
+      return content;
+    },
+    async writeFiles(files) {
+      await observe(() => innerWriteFiles(files));
+    },
+    dispose: sandbox.dispose.bind(sandbox)
+  };
+  if (sandbox.spawn) {
+    const innerSpawn = sandbox.spawn.bind(sandbox);
+    decorated.spawn = (command, options2) => {
+      const started = (async () => {
+        const before = await snapshot(innerExecute, destination).catch(
+          () => /* @__PURE__ */ new Map()
+        );
+        const child = innerSpawn(command, options2);
+        return { before, child };
+      })();
+      const exit = (async () => {
+        const { before, child } = await started;
+        try {
+          return await child.exit;
+        } finally {
+          try {
+            const after = await snapshot(innerExecute, destination);
+            buffer.push(...diff(before, after));
+          } catch {
+          }
+        }
+      })();
+      const stdoutPromise = started.then((s) => s.child.stdout);
+      const stderrPromise = started.then((s) => s.child.stderr);
+      stdoutPromise.catch(() => {
+      });
+      stderrPromise.catch(() => {
+      });
+      return {
+        stdout: lazyReadable(stdoutPromise),
+        stderr: lazyReadable(stderrPromise),
+        exit
+      };
+    };
+  }
+  return {
+    sandbox: decorated,
+    drain() {
+      return buffer.splice(0, buffer.length);
+    }
+  };
+}
+
 // packages/context/src/lib/sandbox/upload-skills.ts
 import * as path3 from "node:path";
 
@@ -6111,22 +6392,38 @@ async function uploadSkills(sandbox, inputs) {
 
 // packages/context/src/lib/sandbox/bash-tool.ts
 var REASONING_INSTRUCTION = 'Every bash tool call must include a brief non-empty "reasoning" input explaining why the command is needed.';
-async function createBashTool(options = {}) {
-  const { skills: skillInputs = [], extraInstructions, ...rest } = options;
+function withBashExceptionCatch(sandbox) {
+  return {
+    ...sandbox,
+    async executeCommand(command, options) {
+      try {
+        return await sandbox.executeCommand(command, options);
+      } catch (err) {
+        if (err instanceof BashException) return err.format();
+        throw err;
+      }
+    }
+  };
+}
+async function createBashTool(options) {
+  const {
+    skills: skillInputs = [],
+    extraInstructions,
+    sandbox: backend,
+    destination,
+    ...rest
+  } = options;
+  const observer = observeSandboxFileEvents(backend, {
+    destination: destination ?? "/workspace"
+  });
+  const sandbox = withAbortSignal(withBashExceptionCatch(observer.sandbox));
   const combinedInstructions = [extraInstructions, REASONING_INSTRUCTION].filter(Boolean).join("\n\n");
   const toolkit = await externalCreateBashTool({
     ...rest,
+    sandbox,
+    destination,
     extraInstructions: combinedInstructions
   });
-  const innerExecute = toolkit.sandbox.executeCommand.bind(toolkit.sandbox);
-  toolkit.sandbox.executeCommand = async (cmd) => {
-    try {
-      return await innerExecute(cmd);
-    } catch (err) {
-      if (err instanceof BashException) return err.format();
-      throw err;
-    }
-  };
   const upstreamBash = toolkit.bash;
   const originalExecute = upstreamBash.execute;
   const toolBuilder = tool2;
@@ -6141,197 +6438,43 @@ async function createBashTool(options = {}) {
       if (!originalExecute) {
         throw new Error("bash tool execution is not available");
       }
-      return runWithBashMeta(async () => {
-        let result;
-        try {
-          result = await originalExecute({ command }, execOptions);
-        } catch (err) {
-          if (err instanceof BashException) {
-            result = err.format();
-          } else {
-            throw err;
-          }
-        }
-        const state = readBashMeta();
-        if (!state) return result;
-        const hasHidden = Object.keys(state.hidden).length > 0;
-        const hasReminder = state.reminder !== void 0;
-        if (!hasHidden && !hasReminder) return result;
-        return {
-          ...result,
-          ...hasHidden ? { meta: state.hidden } : {},
-          ...hasReminder ? { reminder: state.reminder } : {}
-        };
-      });
+      const { abortSignal } = execOptions;
+      return runWithAbortSignal(
+        abortSignal,
+        () => runWithBashMeta(async () => {
+          const result = await originalExecute({ command }, execOptions);
+          const state = readBashMeta();
+          if (!state) return result;
+          const hasHidden = Object.keys(state.hidden).length > 0;
+          const hasReminder = state.reminder !== void 0;
+          if (!hasHidden && !hasReminder) return result;
+          return {
+            ...result,
+            ...hasHidden ? { meta: state.hidden } : {},
+            ...hasReminder ? { reminder: state.reminder } : {}
+          };
+        })
+      );
     },
     toModelOutput: ({ output }) => {
       if (typeof output !== "object" || output === null) {
         return { type: "json", value: output };
       }
-      const record = output;
-      if (!("meta" in record)) {
-        return { type: "json", value: record };
-      }
-      const { meta: _meta, ...visible } = record;
+      const { meta: _meta, ...visible } = output;
       return { type: "json", value: visible };
     }
   });
-  const skills2 = await uploadSkills(toolkit.sandbox, skillInputs);
+  const skills2 = await uploadSkills(sandbox, skillInputs);
   return {
     ...toolkit,
+    sandbox,
     bash,
     tools: { ...toolkit.tools, bash },
-    skills: skills2
+    skills: skills2,
+    drainFileEvents: () => observer.drain()
   };
 }
 
-// packages/context/src/lib/sandbox/file-events.ts
-var ObservedFs = class {
-  #base;
-  #events = [];
-  readdirWithFileTypes;
-  constructor(base) {
-    this.#base = base;
-    if (base.readdirWithFileTypes) {
-      this.readdirWithFileTypes = (path5) => base.readdirWithFileTypes(path5);
-    }
-  }
-  drain() {
-    const events = this.#events;
-    this.#events = [];
-    return events;
-  }
-  #record(op, path5) {
-    this.#events.push({ path: path5, op, timestamp: Date.now() });
-  }
-  async readFile(path5, options) {
-    const content = await this.#base.readFile(path5, options);
-    this.#record("read", path5);
-    return content;
-  }
-  async readFileBuffer(path5) {
-    const content = await this.#base.readFileBuffer(path5);
-    this.#record("read", path5);
-    return content;
-  }
-  async writeFile(path5, content, options) {
-    const existed = await this.#base.exists(path5);
-    await this.#base.writeFile(path5, content, options);
-    this.#record(existed ? "modify" : "write", path5);
-  }
-  async appendFile(path5, content, options) {
-    const existed = await this.#base.exists(path5);
-    await this.#base.appendFile(path5, content, options);
-    this.#record(existed ? "modify" : "write", path5);
-  }
-  async rm(path5, options) {
-    const toRecord = options?.recursive ? await this.#walk(path5, { includeRoot: true }) : await this.#base.exists(path5) ? [path5] : [];
-    await this.#base.rm(path5, options);
-    for (const p of toRecord) {
-      this.#record("delete", p);
-    }
-  }
-  async cp(src, dest, options) {
-    if (options?.recursive) {
-      const sources = await this.#walk(src, { includeRoot: false });
-      const destChecks = await Promise.all(
-        sources.map(async (srcFile) => {
-          const relative3 = srcFile.slice(src.length);
-          const destFile = this.#joinPath(dest, relative3);
-          return {
-            srcFile,
-            destFile,
-            existed: await this.#base.exists(destFile)
-          };
-        })
-      );
-      await this.#base.cp(src, dest, options);
-      for (const { srcFile, destFile, existed } of destChecks) {
-        this.#record("read", srcFile);
-        this.#record(existed ? "modify" : "write", destFile);
-      }
-      return;
-    }
-    const destExisted = await this.#base.exists(dest);
-    await this.#base.cp(src, dest, options);
-    this.#record("read", src);
-    this.#record(destExisted ? "modify" : "write", dest);
-  }
-  async #walk(root, { includeRoot }) {
-    if (!await this.#base.exists(root)) return [];
-    const stat = await this.#base.stat(root);
-    if (!stat.isDirectory) return [root];
-    const out = [];
-    const visit = async (dir) => {
-      const entries = await this.#base.readdir(dir);
-      for (const name of entries) {
-        const child = this.#joinPath(dir, name);
-        const childStat = await this.#base.stat(child);
-        if (childStat.isDirectory) {
-          await visit(child);
-        } else {
-          out.push(child);
-        }
-      }
-    };
-    await visit(root);
-    if (includeRoot) out.push(root);
-    return out;
-  }
-  #joinPath(a, b) {
-    if (!b) return a;
-    if (b.startsWith("/")) return `${a.replace(/\/$/, "")}${b}`;
-    return a.endsWith("/") ? `${a}${b}` : `${a}/${b}`;
-  }
-  async mv(src, dest) {
-    const destExisted = await this.#base.exists(dest);
-    await this.#base.mv(src, dest);
-    this.#record("delete", src);
-    this.#record(destExisted ? "modify" : "write", dest);
-  }
-  async symlink(target, linkPath) {
-    await this.#base.symlink(target, linkPath);
-    this.#record("write", linkPath);
-  }
-  async link(existingPath, newPath) {
-    await this.#base.link(existingPath, newPath);
-    this.#record("write", newPath);
-  }
-  mkdir(path5, options) {
-    return this.#base.mkdir(path5, options);
-  }
-  exists(path5) {
-    return this.#base.exists(path5);
-  }
-  stat(path5) {
-    return this.#base.stat(path5);
-  }
-  lstat(path5) {
-    return this.#base.lstat(path5);
-  }
-  readdir(path5) {
-    return this.#base.readdir(path5);
-  }
-  readlink(path5) {
-    return this.#base.readlink(path5);
-  }
-  realpath(path5) {
-    return this.#base.realpath(path5);
-  }
-  chmod(path5, mode) {
-    return this.#base.chmod(path5, mode);
-  }
-  utimes(path5, atime, mtime) {
-    return this.#base.utimes(path5, atime, mtime);
-  }
-  resolvePath(base, path5) {
-    return this.#base.resolvePath(base, path5);
-  }
-  getAllPaths() {
-    return this.#base.getAllPaths();
-  }
-};
-
 // packages/context/src/lib/sandbox/binary-bridges.ts
 import { existsSync as existsSync2 } from "fs";
 import { defineCommand } from "just-bash";
@@ -6428,113 +6571,647 @@ function resolveRealCwd(ctx) {
   return realCwd;
 }
 
-// packages/context/src/lib/sandbox/docker-sandbox.ts
+// packages/context/src/lib/sandbox/daytona-sandbox.ts
 import "bash-tool";
-import spawn3 from "nano-spawn";
-import { createHash } from "node:crypto";
-import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
-
-// packages/context/src/lib/sandbox/docker-sandbox-errors.ts
-var DockerSandboxError = class extends Error {
-  containerId;
-  constructor(message2, containerId) {
+import { randomUUID } from "node:crypto";
+import { createRequire } from "node:module";
+var DAYTONA_DEFAULT_DESTINATION = "/home/daytona";
+var DAYTONA_EXIT_POLL_INTERVAL_MS = 250;
+var DAYTONA_EXIT_POLL_TIMEOUT_MS = 3e4;
+var requireOptional = createRequire(import.meta.url);
+var DaytonaSandboxError = class extends Error {
+  constructor(message2, cause) {
     super(message2);
-    this.name = "DockerSandboxError";
-    this.containerId = containerId;
-  }
-};
-var DockerNotAvailableError = class extends DockerSandboxError {
-  constructor() {
-    super("Docker is not available. Ensure Docker daemon is running.");
-    this.name = "DockerNotAvailableError";
-  }
-};
-var ContainerCreationError = class extends DockerSandboxError {
-  image;
-  cause;
-  constructor(message2, image, cause) {
-    super(`Failed to create container from image "${image}": ${message2}`);
-    this.name = "ContainerCreationError";
-    this.image = image;
+    this.name = "DaytonaSandboxError";
     this.cause = cause;
   }
 };
-var PackageInstallError = class extends DockerSandboxError {
-  packages;
-  image;
-  packageManager;
-  stderr;
-  constructor(packages, image, packageManager, stderr, containerId) {
+var DaytonaNotAvailableError = class extends DaytonaSandboxError {
+  constructor(cause) {
     super(
-      `Package installation failed for [${packages.join(", ")}] using ${packageManager} on ${image}: ${stderr}`,
-      containerId
+      "@daytona/sdk is not installed. Install it with: npm install @daytona/sdk",
+      cause
     );
-    this.name = "PackageInstallError";
-    this.packages = packages;
-    this.image = image;
-    this.packageManager = packageManager;
-    this.stderr = stderr;
+    this.name = "DaytonaNotAvailableError";
   }
 };
-var InstallError = class extends DockerSandboxError {
-  target;
-  source;
-  reason;
-  url;
-  constructor(opts) {
-    const where = opts.url ? `${opts.source} (${opts.url})` : opts.source;
-    super(
-      `Failed to install "${opts.target}" via ${where}: ${opts.reason}`,
-      opts.containerId
-    );
-    this.name = "InstallError";
-    this.target = opts.target;
-    this.source = opts.source;
-    this.reason = opts.reason;
-    this.url = opts.url;
+var DaytonaCreationError = class extends DaytonaSandboxError {
+  constructor(message2, cause) {
+    super(`Failed to create Daytona sandbox: ${message2}`, cause);
+    this.name = "DaytonaCreationError";
   }
 };
-var MissingRuntimeError = class extends DockerSandboxError {
-  runtime;
-  required;
-  constructor(runtime, required, details, containerId) {
-    const base = `Required runtime "${runtime}" is not installed (needs: ${required.join(", ")}).`;
-    super(details ? `${base} ${details}` : base, containerId);
-    this.name = "MissingRuntimeError";
-    this.runtime = runtime;
-    this.required = required;
+var DaytonaCommandError = class extends DaytonaSandboxError {
+  constructor(message2, cause) {
+    super(message2, cause);
+    this.name = "DaytonaCommandError";
   }
 };
-var MountPathError = class extends DockerSandboxError {
-  hostPath;
-  containerPath;
-  constructor(hostPath, containerPath) {
-    super(
-      `Mount path does not exist on host: "${hostPath}" -> "${containerPath}"`
-    );
-    this.name = "MountPathError";
-    this.hostPath = hostPath;
-    this.containerPath = containerPath;
+async function createDaytonaSandbox(options = {}) {
+  validateDaytonaOptions(options);
+  const { Daytona } = await importDaytonaSdk();
+  let client;
+  try {
+    client = new Daytona(createDaytonaConfig(options));
+  } catch (error) {
+    const err = toError(error);
+    throw new DaytonaCreationError(err.message, err);
   }
-};
-var DockerfileBuildError = class extends DockerSandboxError {
-  stderr;
-  constructor(stderr) {
-    super(`Dockerfile build failed: ${stderr}`);
-    this.name = "DockerfileBuildError";
-    this.stderr = stderr;
+  const attached = options.sandboxId !== void 0;
+  const deleteOnDispose = options.deleteOnDispose ?? !attached;
+  let sandbox;
+  try {
+    sandbox = attached ? await client.get(options.sandboxId) : await client.create(createDaytonaParams(options), {
+      timeout: options.createTimeout,
+      onSnapshotCreateLogs: options.onSnapshotCreateLogs
+    });
+    if (attached && sandbox.state && sandbox.state !== "started") {
+      await sandbox.start?.(options.startTimeout ?? options.createTimeout);
+    }
+  } catch (error) {
+    const err = toError(error);
+    throw new DaytonaCreationError(err.message, err);
   }
-};
-var ComposeStartError = class extends DockerSandboxError {
-  composeFile;
-  stderr;
-  constructor(composeFile, stderr) {
-    super(`Docker Compose failed to start: ${stderr}`);
-    this.name = "ComposeStartError";
-    this.composeFile = composeFile;
-    this.stderr = stderr;
+  return createDaytonaSandboxMethods({
+    client,
+    sandbox,
+    commandTimeout: options.commandTimeout,
+    deleteOnDispose,
+    deleteTimeout: options.deleteTimeout
+  });
+}
+async function importDaytonaSdk() {
+  try {
+    const mod = requireOptional("@daytona/sdk");
+    if (typeof mod.Daytona !== "function") {
+      throw new DaytonaSandboxError(
+        "@daytona/sdk did not export a Daytona constructor"
+      );
+    }
+    return { Daytona: mod.Daytona };
+  } catch (error) {
+    if (error instanceof DaytonaSandboxError) {
+      throw error;
+    }
+    const err = toError(error);
+    if (isMissingDaytonaSdk(err)) {
+      throw new DaytonaNotAvailableError(err);
+    }
+    throw err;
   }
-};
+}
+function createDaytonaConfig(options) {
+  return compactObject({
+    apiKey: options.apiKey,
+    jwtToken: options.jwtToken,
+    organizationId: options.organizationId,
+    apiUrl: options.apiUrl,
+    target: options.target,
+    otelEnabled: options.otelEnabled,
+    _experimental: options.experimental
+  });
+}
+function createDaytonaParams(options) {
+  const base = compactObject({
+    name: options.name,
+    user: options.user,
+    language: options.language,
+    envVars: options.envVars,
+    labels: options.labels,
+    public: options.public,
+    autoStopInterval: options.autoStopInterval,
+    autoArchiveInterval: options.autoArchiveInterval,
+    autoDeleteInterval: options.autoDeleteInterval,
+    volumes: options.volumes,
+    networkBlockAll: options.networkBlockAll,
+    networkAllowList: options.networkAllowList,
+    ephemeral: options.ephemeral
+  });
+  if (options.image) {
+    return compactObject({
+      ...base,
+      image: options.image,
+      resources: options.resources
+    });
+  }
+  const params = compactObject({
+    ...base,
+    snapshot: options.snapshot
+  });
+  return Object.keys(params).length > 0 ? params : void 0;
+}
+function validateDaytonaOptions(options) {
+  if (options.image && options.snapshot) {
+    throw new DaytonaSandboxError(
+      'Daytona sandbox options cannot include both "image" and "snapshot". Choose one environment source.'
+    );
+  }
+  if (options.resources && !options.image) {
+    throw new DaytonaSandboxError(
+      'Daytona sandbox options can only include "resources" when creating from "image". The Daytona SDK does not apply resources during default or snapshot creation.'
+    );
+  }
+  if (!options.sandboxId) {
+    return;
+  }
+  const creationOnlyFields = [
+    "name",
+    "user",
+    "snapshot",
+    "image",
+    "language",
+    "envVars",
+    "labels",
+    "public",
+    "resources",
+    "volumes",
+    "networkAllowList",
+    "networkBlockAll",
+    "autoStopInterval",
+    "autoArchiveInterval",
+    "autoDeleteInterval",
+    "ephemeral",
+    "onSnapshotCreateLogs"
+  ];
+  const present = creationOnlyFields.filter((field) => {
+    return options[field] !== void 0;
+  });
+  if (present.length > 0) {
+    throw new DaytonaSandboxError(
+      `Daytona sandbox options cannot combine "sandboxId" with creation options: ${present.join(", ")}`
+    );
+  }
+}
+function createDaytonaSandboxMethods(args) {
+  const { client, sandbox, commandTimeout, deleteOnDispose, deleteTimeout } = args;
+  let disposed = false;
+  const executeCommand = async (command, options) => {
+    if (options?.signal?.aborted) {
+      return abortedCommandResult();
+    }
+    let aborted = false;
+    const abort = () => {
+      aborted = true;
+    };
+    options?.signal?.addEventListener("abort", abort, { once: true });
+    try {
+      if (aborted || options?.signal?.aborted) {
+        return abortedCommandResult();
+      }
+      const response = await sandbox.process.executeCommand(
+        command,
+        void 0,
+        void 0,
+        commandTimeout
+      );
+      if (aborted) return abortedCommandResult();
+      return {
+        stdout: response.result ?? response.artifacts?.stdout ?? "",
+        stderr: "",
+        exitCode: response.exitCode ?? 0
+      };
+    } catch (error) {
+      if (aborted) return abortedCommandResult();
+      const err = error;
+      return {
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? err.message ?? String(error),
+        exitCode: err.exitCode ?? 1
+      };
+    } finally {
+      options?.signal?.removeEventListener("abort", abort);
+    }
+  };
+  return {
+    executeCommand,
+    spawn(command, options) {
+      return spawnDaytonaProcess(sandbox, command, {
+        ...options,
+        commandTimeout
+      });
+    },
+    async readFile(path5) {
+      try {
+        const bytes = await sandbox.fs.downloadFile(path5);
+        return Buffer.from(bytes).toString("utf-8");
+      } catch (error) {
+        throw new DaytonaCommandError(
+          `Failed to read file "${path5}": ${toError(error).message}`,
+          toError(error)
+        );
+      }
+    },
+    async writeFiles(files) {
+      try {
+        for (const dir of uniqueParentDirectories(files.map((f) => f.path))) {
+          const result = await executeCommand(`mkdir -p ${shellQuote2(dir)}`);
+          if (result.exitCode !== 0) {
+            throw new DaytonaCommandError(
+              `Failed to create directory "${dir}": ${result.stderr}`
+            );
+          }
+        }
+        await sandbox.fs.uploadFiles(
+          files.map((file) => ({
+            source: Buffer.from(file.content),
+            destination: file.path
+          }))
+        );
+      } catch (error) {
+        if (error instanceof DaytonaSandboxError) throw error;
+        const err = toError(error);
+        throw new DaytonaCommandError(
+          `Failed to write files: ${err.message}`,
+          err
+        );
+      }
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        if (deleteOnDispose) {
+          if (sandbox.delete) await sandbox.delete(deleteTimeout);
+          else if (client.delete) await client.delete(sandbox, deleteTimeout);
+        }
+      } finally {
+        await client[Symbol.asyncDispose]?.().catch(() => {
+        });
+      }
+    }
+  };
+}
+function spawnDaytonaProcess(sandbox, command, options = {}) {
+  const sessionId = createSessionId("spawn");
+  const stdout = createTextReadable();
+  const stderr = createTextReadable();
+  const exit = runSpawnedSession({
+    sandbox,
+    sessionId,
+    command: buildSessionCommand(command, options),
+    signal: options.signal,
+    commandTimeout: options.commandTimeout,
+    stdout,
+    stderr
+  });
+  return {
+    stdout: stdout.stream,
+    stderr: stderr.stream,
+    exit
+  };
+}
+async function runSpawnedSession(args) {
+  const {
+    sandbox,
+    sessionId,
+    command,
+    signal,
+    commandTimeout,
+    stdout,
+    stderr
+  } = args;
+  let sessionCreated = false;
+  let aborted = signal?.aborted ?? false;
+  let resolveAbort;
+  const abortPromise = new Promise((resolve4) => {
+    resolveAbort = () => resolve4("aborted");
+  });
+  const abort = () => {
+    aborted = true;
+    resolveAbort?.();
+    if (sessionCreated) {
+      sandbox.process.deleteSession(sessionId).catch(() => {
+      });
+    }
+  };
+  if (signal) {
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
+  }
+  try {
+    await sandbox.process.createSession(sessionId);
+    sessionCreated = true;
+    if (aborted) return abortedExitInfo();
+    const response = await sandbox.process.executeSessionCommand(
+      sessionId,
+      {
+        command,
+        runAsync: true,
+        suppressInputEcho: true
+      },
+      commandTimeout
+    );
+    const commandId = response.cmdId;
+    if (!commandId) {
+      throw new DaytonaCommandError(
+        "Daytona did not return a command id for the spawned session command."
+      );
+    }
+    if (aborted) return abortedExitInfo();
+    const logsTask = sandbox.process.getSessionCommandLogs(
+      sessionId,
+      commandId,
+      (chunk) => stdout.enqueue(chunk),
+      (chunk) => stderr.enqueue(chunk)
+    );
+    logsTask.catch(() => {
+    });
+    const winner = await Promise.race([
+      logsTask.then(() => "logs"),
+      abortPromise
+    ]);
+    if (winner === "aborted") {
+      await sandbox.process.deleteSession(sessionId).catch(() => {
+      });
+      return abortedExitInfo();
+    }
+    await logsTask;
+    const code = await waitForSessionCommandExitCode({
+      sandbox,
+      sessionId,
+      commandId,
+      timeoutMs: sessionExitPollTimeoutMs(commandTimeout),
+      isAborted: () => aborted
+    });
+    return { code, signal: null, success: code === 0 };
+  } catch (error) {
+    if (aborted) return abortedExitInfo();
+    const err = toError(error);
+    stdout.error(err);
+    stderr.error(err);
+    throw err;
+  } finally {
+    if (signal) {
+      signal.removeEventListener("abort", abort);
+    }
+    stdout.close();
+    stderr.close();
+    if (sessionCreated) {
+      await sandbox.process.deleteSession(sessionId).catch(() => {
+      });
+    }
+  }
+}
+async function waitForSessionCommandExitCode(args) {
+  const { sandbox, sessionId, commandId, timeoutMs, isAborted } = args;
+  const deadline = Date.now() + timeoutMs;
+  while (true) {
+    if (isAborted()) throw new DaytonaCommandError("Daytona command aborted.");
+    const info = await sandbox.process.getSessionCommand(sessionId, commandId);
+    if (typeof info.exitCode === "number") {
+      return info.exitCode;
+    }
+    if (Date.now() >= deadline) {
+      throw new DaytonaCommandError(
+        `Daytona session command "${commandId}" logs closed before an exit code became available.`
+      );
+    }
+    await delay(DAYTONA_EXIT_POLL_INTERVAL_MS);
+  }
+}
+function sessionExitPollTimeoutMs(commandTimeout) {
+  if (commandTimeout === void 0 || commandTimeout === 0) {
+    return DAYTONA_EXIT_POLL_TIMEOUT_MS;
+  }
+  return Math.max(commandTimeout * 1e3, DAYTONA_EXIT_POLL_TIMEOUT_MS);
+}
+function delay(ms) {
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
+}
+function createTextReadable() {
+  const encoder = new TextEncoder();
+  let controller;
+  let closed = false;
+  return {
+    stream: new ReadableStream({
+      start(streamController) {
+        controller = streamController;
+      }
+    }),
+    enqueue(chunk) {
+      if (closed || !chunk) return;
+      controller?.enqueue(encoder.encode(chunk));
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      controller?.close();
+    },
+    error(error) {
+      if (closed) return;
+      closed = true;
+      controller?.error(error);
+    }
+  };
+}
+function buildSessionCommand(command, options) {
+  const cwdPrefix = options.cwd ? `cd ${shellQuote2(options.cwd)} && ` : "";
+  const env = options.env ?? {};
+  const entries = Object.entries(env);
+  if (entries.length === 0) {
+    return `sh -lc ${shellQuote2(`${cwdPrefix}${command}`)}`;
+  }
+  for (const [key] of entries) {
+    validateEnvKey(key);
+  }
+  const exports = entries.map(([key, value]) => `export ${key}=${shellQuote2(value)}`).join("; ");
+  return `sh -lc ${shellQuote2(`${exports}; ${cwdPrefix}${command}`)}`;
+}
+function validateEnvKey(key) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
+    throw new DaytonaSandboxError(
+      `Invalid environment variable key: "${key}". Use shell-compatible environment variable names.`
+    );
+  }
+}
+function createSessionId(kind) {
+  return `deepagents-${kind}-${randomUUID()}`;
+}
+function abortedCommandResult() {
+  return {
+    stdout: "",
+    stderr: "Command aborted",
+    exitCode: 1
+  };
+}
+function abortedExitInfo() {
+  return {
+    code: null,
+    signal: "SIGKILL",
+    success: false
+  };
+}
+function shellQuote2(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function uniqueParentDirectories(paths) {
+  const dirs = /* @__PURE__ */ new Set();
+  for (const path5 of paths) {
+    const index = path5.lastIndexOf("/");
+    if (index > 0) {
+      dirs.add(path5.slice(0, index));
+    }
+  }
+  return [...dirs];
+}
+function compactObject(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) {
+      output[key] = value;
+    }
+  }
+  return output;
+}
+function isMissingDaytonaSdk(error) {
+  const maybeCode = error.code;
+  return maybeCode === "ERR_MODULE_NOT_FOUND" || maybeCode === "MODULE_NOT_FOUND" || error.message.includes("@daytona/sdk");
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// packages/context/src/lib/sandbox/docker-sandbox.ts
+import "bash-tool";
+import spawn3 from "nano-spawn";
+import { spawn as childSpawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "node:fs";
+import { Readable as Readable2 } from "node:stream";
+
+// packages/context/src/lib/sandbox/docker-sandbox-errors.ts
+var DockerSandboxError = class extends Error {
+  containerId;
+  constructor(message2, containerId) {
+    super(message2);
+    this.name = "DockerSandboxError";
+    this.containerId = containerId;
+  }
+};
+var DockerNotAvailableError = class extends DockerSandboxError {
+  constructor() {
+    super("Docker is not available. Ensure Docker daemon is running.");
+    this.name = "DockerNotAvailableError";
+  }
+};
+var ContainerCreationError = class extends DockerSandboxError {
+  image;
+  cause;
+  constructor(message2, image, cause) {
+    super(`Failed to create container from image "${image}": ${message2}`);
+    this.name = "ContainerCreationError";
+    this.image = image;
+    this.cause = cause;
+  }
+};
+var PackageInstallError = class extends DockerSandboxError {
+  packages;
+  image;
+  packageManager;
+  stderr;
+  constructor(packages, image, packageManager, stderr, containerId) {
+    super(
+      `Package installation failed for [${packages.join(", ")}] using ${packageManager} on ${image}: ${stderr}`,
+      containerId
+    );
+    this.name = "PackageInstallError";
+    this.packages = packages;
+    this.image = image;
+    this.packageManager = packageManager;
+    this.stderr = stderr;
+  }
+};
+var InstallError = class extends DockerSandboxError {
+  target;
+  source;
+  reason;
+  url;
+  constructor(opts) {
+    const where = opts.url ? `${opts.source} (${opts.url})` : opts.source;
+    super(
+      `Failed to install "${opts.target}" via ${where}: ${opts.reason}`,
+      opts.containerId
+    );
+    this.name = "InstallError";
+    this.target = opts.target;
+    this.source = opts.source;
+    this.reason = opts.reason;
+    this.url = opts.url;
+  }
+};
+var MissingRuntimeError = class extends DockerSandboxError {
+  runtime;
+  required;
+  constructor(runtime, required, details, containerId) {
+    const base = `Required runtime "${runtime}" is not installed (needs: ${required.join(", ")}).`;
+    super(details ? `${base} ${details}` : base, containerId);
+    this.name = "MissingRuntimeError";
+    this.runtime = runtime;
+    this.required = required;
+  }
+};
+var VolumePathError = class extends DockerSandboxError {
+  source;
+  containerPath;
+  reason;
+  constructor(source, containerPath, reason) {
+    super(
+      `Invalid Docker volume path "${source}" -> "${containerPath}": ${reason}`
+    );
+    this.name = "VolumePathError";
+    this.source = source;
+    this.containerPath = containerPath;
+    this.reason = reason;
+  }
+};
+var VolumeInspectError = class extends DockerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to inspect Docker volume "${volume}": ${reason}`);
+    this.name = "VolumeInspectError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var VolumeCreateError = class extends DockerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to create Docker volume "${volume}": ${reason}`);
+    this.name = "VolumeCreateError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var VolumeRemoveError = class extends DockerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to remove Docker volume "${volume}": ${reason}`);
+    this.name = "VolumeRemoveError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var DockerfileBuildError = class extends DockerSandboxError {
+  stderr;
+  constructor(stderr) {
+    super(`Dockerfile build failed: ${stderr}`);
+    this.name = "DockerfileBuildError";
+    this.stderr = stderr;
+  }
+};
+var ComposeStartError = class extends DockerSandboxError {
+  composeFile;
+  stderr;
+  constructor(composeFile, stderr) {
+    super(`Docker Compose failed to start: ${stderr}`);
+    this.name = "ComposeStartError";
+    this.composeFile = composeFile;
+    this.stderr = stderr;
+  }
+};
 
 // packages/context/src/lib/sandbox/installers/installer.ts
 import "bash-tool";
@@ -6547,7 +7224,7 @@ function isDebianBased(image) {
   const debianPatterns = ["debian", "ubuntu", "node", "python"];
   return debianPatterns.some((pattern) => lower.includes(pattern));
 }
-function shellQuote(s) {
+function shellQuote3(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function createInstallerContext(containerId, image) {
@@ -6595,7 +7272,7 @@ function createInstallerContext(containerId, image) {
   };
   const installPackages = async (packages) => {
     if (packages.length === 0) return;
-    const quoted = packages.map(shellQuote).join(" ");
+    const quoted = packages.map(shellQuote3).join(" ");
     let cmd;
     if (packageManager === "apt-get") {
       cmd = aptUpdated ? `apt-get install -y ${quoted}` : `apt-get update && apt-get install -y ${quoted}`;
@@ -6617,7 +7294,7 @@ function createInstallerContext(containerId, image) {
   const ensureTool = async (checkName, installName) => {
     const cacheKey = installName ?? checkName;
     if (ensuredTools.has(cacheKey)) return;
-    const check = await exec(`which ${shellQuote(checkName)}`);
+    const check = await exec(`which ${shellQuote3(checkName)}`);
     if (check.exitCode === 0) {
       ensuredTools.add(cacheKey);
       return;
@@ -6643,44 +7320,216 @@ function isDockerfileOptions(opts) {
 function isComposeOptions(opts) {
   return "compose" in opts;
 }
+var CONTAINER_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
 var DockerSandboxStrategy = class {
   context;
-  mounts;
+  volumes;
   resources;
   env;
+  name;
+  createdVolumes = /* @__PURE__ */ new Set();
   constructor(args = {}) {
-    const { mounts = [], resources = {}, env = {} } = args;
+    const { volumes = [], resources = {}, env = {}, name } = args;
     for (const key of Object.keys(env)) {
-      if (key.length === 0 || key.includes("=")) {
-        throw new DockerSandboxError(
-          `Invalid environment variable key: "${key}"`
-        );
-      }
+      validateEnvKey2(key);
     }
-    this.mounts = mounts;
+    if (name !== void 0 && !CONTAINER_NAME_PATTERN.test(name)) {
+      throw new DockerSandboxError(
+        `Invalid container name: "${name}". Use only letters, numbers, underscore, period, or hyphen. The "sandbox-" prefix is added automatically.`
+      );
+    }
+    this.volumes = volumes;
     this.resources = resources;
     this.env = env;
+    this.name = name;
   }
   async create() {
-    this.validateMounts();
     const image = await this.getImage();
-    const containerId = await this.startContainer(image);
-    this.context = { containerId, image };
+    let acquired;
     try {
-      await this.configure();
+      acquired = await this.acquireContainer(image);
+      this.context = { containerId: acquired.containerId, image };
+      if (!acquired.attached) {
+        await this.configure();
+      }
     } catch (error) {
-      await this.stopContainer(containerId);
+      if (acquired && !acquired.attached) {
+        await this.stopContainer(acquired.containerId);
+      }
+      await this.cleanupCreatedVolumesAfterFailure(error);
       throw error;
     }
     return this.createSandboxMethods();
   }
-  validateMounts() {
-    for (const mount of this.mounts) {
-      if (!existsSync3(mount.hostPath)) {
-        throw new MountPathError(mount.hostPath, mount.containerPath);
+  namedContainerId() {
+    return `sandbox-${this.name}`;
+  }
+  defaultContainerId() {
+    return `sandbox-${crypto.randomUUID().slice(0, 8)}`;
+  }
+  async acquireContainer(image) {
+    if (!this.name) {
+      const containerId2 = this.defaultContainerId();
+      await this.prepareVolumes();
+      await this.startContainer(image, containerId2);
+      return { containerId: containerId2, attached: false };
+    }
+    const containerId = this.namedContainerId();
+    const probe = await this.inspectContainer(containerId);
+    if (probe === "running") {
+      return { containerId, attached: true };
+    }
+    if (probe === "stopped") {
+      await this.startStoppedContainer(containerId, image);
+      return { containerId, attached: true };
+    }
+    await this.prepareVolumes();
+    try {
+      await this.startContainer(image, containerId);
+      return { containerId, attached: false };
+    } catch (error) {
+      if (error instanceof ContainerCreationError && this.isNameConflictError(error.message)) {
+        await this.cleanupCreatedVolumes();
+        const raced = await this.inspectContainer(containerId);
+        if (raced === "running") {
+          return { containerId, attached: true };
+        }
+        if (raced === "stopped") {
+          await this.startStoppedContainer(containerId, image);
+          return { containerId, attached: true };
+        }
       }
+      throw error;
     }
   }
+  async startStoppedContainer(containerId, image) {
+    try {
+      await spawn3("docker", ["start", containerId]);
+    } catch (error) {
+      const message2 = this.getDockerErrorMessage(error);
+      if (this.isDockerUnavailableError(message2)) {
+        throw new DockerNotAvailableError();
+      }
+      throw new ContainerCreationError(message2, image, error);
+    }
+  }
+  async inspectContainer(containerId) {
+    try {
+      const result = await spawn3("docker", [
+        "container",
+        "inspect",
+        "--format",
+        "{{.State.Status}}",
+        containerId
+      ]);
+      const status = result.stdout.trim();
+      return status === "running" ? "running" : "stopped";
+    } catch (error) {
+      const message2 = this.getDockerErrorMessage(error);
+      if (this.isDockerUnavailableError(message2)) {
+        throw new DockerNotAvailableError();
+      }
+      if (this.isMissingContainerError(message2)) {
+        return "absent";
+      }
+      throw new DockerSandboxError(
+        `Failed to inspect container "${containerId}": ${message2}`
+      );
+    }
+  }
+  isMissingContainerError(message2) {
+    return message2.toLowerCase().includes("no such container");
+  }
+  isNameConflictError(message2) {
+    return message2.toLowerCase().includes("is already in use by container");
+  }
+  async prepareVolumes() {
+    this.validateVolumes();
+    for (const volume of this.volumes) {
+      if (volume.type !== "volume") {
+        continue;
+      }
+      const lifecycle = volume.lifecycle ?? "external";
+      if (lifecycle === "external") {
+        await this.inspectVolume(volume.name);
+        continue;
+      }
+      const exists = await this.volumeExists(volume.name);
+      if (exists) {
+        throw new VolumeCreateError(
+          volume.name,
+          "managed volume already exists"
+        );
+      }
+      await this.createVolume(volume);
+      if (volume.removeOnDispose !== false) {
+        this.createdVolumes.add(volume.name);
+      }
+    }
+  }
+  validateVolumes() {
+    const containerPaths = /* @__PURE__ */ new Set();
+    for (const volume of this.volumes) {
+      const source = volume.type === "bind" ? volume.hostPath : volume.name;
+      if (!volume.containerPath.startsWith("/")) {
+        throw new VolumePathError(
+          source,
+          volume.containerPath,
+          "containerPath must be absolute"
+        );
+      }
+      this.validateMountValue("containerPath", volume.containerPath, volume);
+      if (containerPaths.has(volume.containerPath)) {
+        throw new VolumePathError(
+          source,
+          volume.containerPath,
+          "containerPath must be unique"
+        );
+      }
+      containerPaths.add(volume.containerPath);
+      if (volume.type === "bind") {
+        this.validateMountValue("hostPath", volume.hostPath, volume);
+        if (!existsSync3(volume.hostPath)) {
+          throw new VolumePathError(
+            volume.hostPath,
+            volume.containerPath,
+            "hostPath does not exist on host"
+          );
+        }
+        continue;
+      }
+      if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(volume.name)) {
+        throw new VolumePathError(
+          volume.name,
+          volume.containerPath,
+          "volume name must start with an alphanumeric character and contain only letters, numbers, underscore, period, or hyphen"
+        );
+      }
+      if (volume.subPath) {
+        this.validateMountValue("subPath", volume.subPath, volume);
+      }
+      if ((volume.lifecycle ?? "external") === "external") {
+        if (volume.driver || volume.driverOptions) {
+          throw new VolumePathError(
+            volume.name,
+            volume.containerPath,
+            'driver and driverOptions require lifecycle "managed"'
+          );
+        }
+      }
+    }
+  }
+  validateMountValue(field, value, volume) {
+    if (!value.includes(",")) {
+      return;
+    }
+    const source = volume.type === "bind" ? volume.hostPath : volume.name;
+    throw new VolumePathError(
+      source,
+      volume.containerPath,
+      `${field} must not contain commas`
+    );
+  }
   buildDockerArgs(image, containerId) {
     const { memory = "1g", cpus = 2 } = this.resources;
     const args = [
@@ -6697,15 +7546,106 @@ var DockerSandboxStrategy = class {
     for (const [key, value] of Object.entries(this.env)) {
       args.push("-e", `${key}=${value}`);
     }
-    for (const mount of this.mounts) {
-      const mode = mount.readOnly !== false ? "ro" : "rw";
-      args.push("-v", `${mount.hostPath}:${mount.containerPath}:${mode}`);
+    for (const volume of this.volumes) {
+      args.push("--mount", this.buildVolumeMountArg(volume));
     }
     args.push(image, "tail", "-f", "/dev/null");
     return args;
   }
-  async startContainer(image) {
-    const containerId = `sandbox-${crypto.randomUUID().slice(0, 8)}`;
+  buildVolumeMountArg(volume) {
+    const readOnly = volume.readOnly !== false;
+    const parts = volume.type === "bind" ? ["type=bind", `src=${volume.hostPath}`, `dst=${volume.containerPath}`] : [
+      "type=volume",
+      `src=${volume.name}`,
+      `dst=${volume.containerPath}`,
+      ...volume.subPath ? [`volume-subpath=${volume.subPath}`] : [],
+      ...volume.noCopy ? ["volume-nocopy"] : []
+    ];
+    if (readOnly) {
+      parts.push("readonly");
+    }
+    return parts.join(",");
+  }
+  async inspectVolume(name) {
+    try {
+      await spawn3("docker", ["volume", "inspect", name]);
+    } catch (error) {
+      const reason = this.getDockerErrorMessage(error);
+      if (this.isDockerUnavailableError(reason)) {
+        throw new DockerNotAvailableError();
+      }
+      throw new VolumeInspectError(name, reason);
+    }
+  }
+  async volumeExists(name) {
+    try {
+      await this.inspectVolume(name);
+      return true;
+    } catch (error) {
+      if (error instanceof VolumeInspectError) {
+        if (this.isMissingVolumeInspectError(error.reason)) {
+          return false;
+        }
+        throw error;
+      }
+      throw error;
+    }
+  }
+  async createVolume(volume) {
+    const args = ["volume", "create"];
+    if (volume.driver) {
+      args.push("--driver", volume.driver);
+    }
+    for (const [key, value] of Object.entries(volume.driverOptions ?? {})) {
+      args.push("--opt", `${key}=${value}`);
+    }
+    args.push(volume.name);
+    try {
+      await spawn3("docker", args);
+    } catch (error) {
+      const reason = this.getDockerErrorMessage(error);
+      if (this.isDockerUnavailableError(reason)) {
+        throw new DockerNotAvailableError();
+      }
+      throw new VolumeCreateError(volume.name, reason);
+    }
+  }
+  async cleanupCreatedVolumes() {
+    const volumes = [...this.createdVolumes].reverse();
+    for (const volume of volumes) {
+      try {
+        await spawn3("docker", ["volume", "rm", volume]);
+        this.createdVolumes.delete(volume);
+      } catch (error) {
+        const reason = this.getDockerErrorMessage(error);
+        if (this.isDockerUnavailableError(reason)) {
+          throw new DockerNotAvailableError();
+        }
+        throw new VolumeRemoveError(volume, reason);
+      }
+    }
+  }
+  async cleanupCreatedVolumesAfterFailure(originalError) {
+    try {
+      await this.cleanupCreatedVolumes();
+    } catch (cleanupError) {
+      if (originalError instanceof Error) {
+        const original = originalError;
+        original.suppressed = [...original.suppressed ?? [], cleanupError];
+      }
+    }
+  }
+  getDockerErrorMessage(error) {
+    const err = error;
+    return err.stderr || err.stdout || err.message || String(error);
+  }
+  isDockerUnavailableError(message2) {
+    return message2.includes("Cannot connect") || message2.includes("docker daemon");
+  }
+  isMissingVolumeInspectError(message2) {
+    return message2.toLowerCase().includes("no such volume");
+  }
+  async startContainer(image, containerId) {
     const args = this.buildDockerArgs(image, containerId);
     try {
       await spawn3("docker", args);
@@ -6714,9 +7654,12 @@ var DockerSandboxStrategy = class {
       if (err.message?.includes("Cannot connect") || err.message?.includes("docker daemon") || err.stderr?.includes("Cannot connect")) {
         throw new DockerNotAvailableError();
       }
-      throw new ContainerCreationError(err.message || String(err), image, err);
+      throw new ContainerCreationError(
+        this.getDockerErrorMessage(err),
+        image,
+        err
+      );
     }
-    return containerId;
   }
   async stopContainer(containerId) {
     try {
@@ -6724,15 +7667,13 @@ var DockerSandboxStrategy = class {
     } catch {
     }
   }
-  async exec(command) {
+  async exec(command, options) {
     try {
-      const result = await spawn3("docker", [
-        "exec",
-        this.context.containerId,
-        "sh",
-        "-c",
-        command
-      ]);
+      const result = await spawn3(
+        "docker",
+        ["exec", this.context.containerId, "sh", "-c", command],
+        { signal: options?.signal }
+      );
       return {
         stdout: result.stdout,
         stderr: result.stderr,
@@ -6747,12 +7688,22 @@ var DockerSandboxStrategy = class {
       };
     }
   }
+  spawnProcess(command, options) {
+    const child = childSpawn("docker", [
+      "exec",
+      ...buildDockerExecFlags(options),
+      this.context.containerId,
+      "sh",
+      "-c",
+      command
+    ]);
+    return toSandboxProcess(child, options?.signal);
+  }
   createSandboxMethods() {
     const { containerId } = this.context;
     const sandbox = {
-      executeCommand: async (command) => {
-        return this.exec(command);
-      },
+      executeCommand: async (command, options) => this.exec(command, options),
+      spawn: (command, options) => this.spawnProcess(command, options),
       readFile: async (path5) => {
         const result = await sandbox.executeCommand(`base64 "${path5}"`);
         if (result.exitCode !== 0) {
@@ -6779,16 +7730,74 @@ var DockerSandboxStrategy = class {
       },
       dispose: async () => {
         await this.stopContainer(containerId);
+        await this.cleanupCreatedVolumes();
       }
     };
     return sandbox;
   }
 };
+function validateEnvKey2(key) {
+  if (key.length === 0 || key.includes("=")) {
+    throw new DockerSandboxError(`Invalid environment variable key: "${key}"`);
+  }
+}
+function buildDockerExecFlags(options) {
+  const flags = [];
+  if (options?.cwd) {
+    flags.push("-w", options.cwd);
+  }
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      validateEnvKey2(key);
+      flags.push("-e", `${key}=${value}`);
+    }
+  }
+  return flags;
+}
+function toSandboxProcess(child, abortSignal) {
+  if (!child.stdout || !child.stderr) {
+    child.kill("SIGKILL");
+    throw new DockerSandboxError("docker exec child missing stdio streams");
+  }
+  const onAbort = abortSignal ? () => child.kill("SIGKILL") : void 0;
+  if (abortSignal && onAbort) {
+    if (abortSignal.aborted) onAbort();
+    else abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
+  return {
+    stdout: Readable2.toWeb(child.stdout),
+    stderr: Readable2.toWeb(child.stderr),
+    exit: new Promise((resolve4, reject) => {
+      const settle = () => {
+        child.removeListener("exit", onExitEvent);
+        child.removeListener("error", onError);
+        if (abortSignal && onAbort) {
+          abortSignal.removeEventListener("abort", onAbort);
+        }
+      };
+      const onError = (err) => {
+        settle();
+        reject(err);
+      };
+      const onExitEvent = (code, exitSignal) => {
+        settle();
+        resolve4({ code, signal: exitSignal, success: code === 0 });
+      };
+      child.on("exit", onExitEvent);
+      child.on("error", onError);
+    })
+  };
+}
 var RuntimeStrategy = class extends DockerSandboxStrategy {
   image;
   installers;
   constructor(args = {}) {
-    super({ mounts: args.mounts, resources: args.resources, env: args.env });
+    super({
+      volumes: args.volumes,
+      resources: args.resources,
+      env: args.env,
+      name: args.name
+    });
     this.image = args.image ?? "alpine:latest";
     this.installers = args.installers ?? [];
   }
@@ -6807,7 +7816,12 @@ var DockerfileStrategy = class extends DockerSandboxStrategy {
   dockerfile;
   dockerContext;
   constructor(args) {
-    super({ mounts: args.mounts, resources: args.resources, env: args.env });
+    super({
+      volumes: args.volumes,
+      resources: args.resources,
+      env: args.env,
+      name: args.name
+    });
     this.dockerfile = args.dockerfile;
     this.dockerContext = args.context ?? ".";
     this.imageTag = this.computeImageTag();
@@ -6876,7 +7890,7 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   async getImage() {
     return "";
   }
-  async startContainer(_image) {
+  async startContainer(_image, _containerId) {
     try {
       await spawn3("docker", [
         "compose",
@@ -6894,25 +7908,31 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
       }
       throw new ComposeStartError(this.composeFile, err.stderr || err.message);
     }
+  }
+  defaultContainerId() {
     return this.projectName;
   }
   async configure() {
   }
-  async exec(command) {
+  async exec(command, options) {
     try {
-      const result = await spawn3("docker", [
-        "compose",
-        "-f",
-        this.composeFile,
-        "-p",
-        this.projectName,
-        "exec",
-        "-T",
-        this.service,
-        "sh",
-        "-c",
-        command
-      ]);
+      const result = await spawn3(
+        "docker",
+        [
+          "compose",
+          "-f",
+          this.composeFile,
+          "-p",
+          this.projectName,
+          "exec",
+          "-T",
+          this.service,
+          "sh",
+          "-c",
+          command
+        ],
+        { signal: options?.signal }
+      );
       return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
     } catch (error) {
       const err = error;
@@ -6923,6 +7943,23 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
       };
     }
   }
+  spawnProcess(command, options) {
+    const child = childSpawn("docker", [
+      "compose",
+      "-f",
+      this.composeFile,
+      "-p",
+      this.projectName,
+      "exec",
+      "-T",
+      ...buildDockerExecFlags(options),
+      this.service,
+      "sh",
+      "-c",
+      command
+    ]);
+    return toSandboxProcess(child, options?.signal);
+  }
   async stopContainer(_containerId) {
     try {
       await spawn3("docker", [
@@ -6949,17 +7986,19 @@ async function createDockerSandbox(options = {}) {
     strategy = new DockerfileStrategy({
       dockerfile: options.dockerfile,
       context: options.context,
-      mounts: options.mounts,
+      volumes: options.volumes,
       resources: options.resources,
-      env: options.env
+      env: options.env,
+      name: options.name
     });
   } else {
     strategy = new RuntimeStrategy({
       image: options.image,
       installers: options.installers,
-      mounts: options.mounts,
+      volumes: options.volumes,
       resources: options.resources,
-      env: options.env
+      env: options.env,
+      name: options.name
     });
   }
   return strategy.create();
@@ -6973,57 +8012,6 @@ async function useSandbox(options, fn) {
   }
 }
 
-// packages/context/src/lib/sandbox/container-tool.ts
-async function createContainerTool(options = {}) {
-  let sandboxOptions;
-  let bashOptions;
-  let skillInputs = [];
-  if (isComposeOptions(options)) {
-    const { compose, service, resources, skills: skills2 = [], ...rest } = options;
-    sandboxOptions = { compose, service, resources };
-    bashOptions = rest;
-    skillInputs = skills2;
-  } else if (isDockerfileOptions(options)) {
-    const {
-      dockerfile,
-      context,
-      mounts,
-      resources,
-      env,
-      skills: skills2 = [],
-      ...rest
-    } = options;
-    sandboxOptions = { dockerfile, context, mounts, resources, env };
-    bashOptions = rest;
-    skillInputs = skills2;
-  } else {
-    const {
-      image,
-      installers,
-      mounts,
-      resources,
-      env,
-      skills: skills2 = [],
-      ...rest
-    } = options;
-    sandboxOptions = { image, installers, mounts, resources, env };
-    bashOptions = rest;
-    skillInputs = skills2;
-  }
-  const sandbox = await createDockerSandbox(sandboxOptions);
-  const toolkit = await createBashTool({
-    ...bashOptions,
-    sandbox,
-    skills: skillInputs
-  });
-  return {
-    bash: toolkit.bash,
-    tools: toolkit.tools,
-    sandbox,
-    skills: toolkit.skills
-  };
-}
-
 // packages/context/src/lib/sandbox/installers/package-manager.ts
 var PackageInstaller = class extends Installer {
   kind;
@@ -7096,9 +8084,9 @@ async function downloadAndInstall(ctx, name, url, binaryPath, source = "url") {
 function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
   return `
     set -e
-    NAME=${shellQuote(name)}
-    URL=${shellQuote(url)}
-    BIN_IN_ARCHIVE=${shellQuote(binaryPathInArchive)}
+    NAME=${shellQuote3(name)}
+    URL=${shellQuote3(url)}
+    BIN_IN_ARCHIVE=${shellQuote3(binaryPathInArchive)}
     TMPDIR=$(mktemp -d)
     cd "$TMPDIR"
     curl -fsSL "$URL" -o archive.tar.gz
@@ -7117,8 +8105,8 @@ function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
 }
 function buildRawInstallCmd(name, url) {
   return `
-    NAME=${shellQuote(name)}
-    URL=${shellQuote(url)}
+    NAME=${shellQuote3(name)}
+    URL=${shellQuote3(url)}
     curl -fsSL "$URL" -o "/usr/local/bin/$NAME"
     chmod +x "/usr/local/bin/$NAME"
   `;
@@ -7171,6 +8159,59 @@ async function ensureNodeRuntime(ctx, ensure) {
   }
 }
 
+// packages/context/src/lib/sandbox/installers/bin.ts
+import { basename, posix } from "node:path";
+var NOT_FOUND_EXIT = 11;
+var CHMOD_FAILED_EXIT = 12;
+var BinInstaller = class extends Installer {
+  kind;
+  binary;
+  options;
+  #name;
+  #target;
+  constructor(binary, options = {}) {
+    super();
+    this.binary = binary;
+    this.options = options;
+    this.#name = resolveName(binary, options);
+    this.#target = options.target ?? posix.join("/usr/local/bin", this.#name);
+    this.kind = `bin:${this.#name}`;
+  }
+  async install(ctx) {
+    const b = shellQuote3(this.binary);
+    const t = shellQuote3(this.#target);
+    const dir = shellQuote3(posix.dirname(this.#target));
+    const result = await ctx.exec(
+      `test -f ${b} || { echo "binary not found at ${this.binary}" >&2; exit ${NOT_FOUND_EXIT}; }; if ! test -x ${b}; then chmod +x ${b} || exit ${CHMOD_FAILED_EXIT}; fi; mkdir -p ${dir} && ln -sf ${b} ${t}`
+    );
+    if (result.exitCode === 0) return;
+    throw new InstallError({
+      target: this.#name,
+      source: "bin",
+      reason: explainFailure(result.exitCode, result.stderr, this.binary),
+      containerId: ctx.containerId
+    });
+  }
+};
+function bin(binary, options) {
+  return new BinInstaller(binary, options);
+}
+function explainFailure(exitCode, stderr, binary) {
+  if (exitCode === NOT_FOUND_EXIT) {
+    return `binary not found at ${binary}`;
+  }
+  if (exitCode === CHMOD_FAILED_EXIT && /read-only file system/i.test(stderr)) {
+    return `${binary} is not executable and the bind mount is read-only \u2014 run \`chmod +x\` on the host, or mount with \`readOnly: false\`. (${stderr.trim()})`;
+  }
+  return stderr || `bin installer failed with exit code ${exitCode}`;
+}
+function resolveName(binary, options) {
+  if (options.name) return options.name;
+  const base = basename(binary);
+  const dot = base.lastIndexOf(".");
+  return dot > 0 ? base.slice(0, dot) : base;
+}
+
 // packages/context/src/lib/sandbox/installers/pip.ts
 var PYTHON_BINARIES = ["python3", "pip3"];
 var PipInstaller = class extends Installer {
@@ -7330,8 +8371,11 @@ async function createVirtualSandbox(options) {
     customCommands: options.customCommands
   });
   return {
-    async executeCommand(command) {
-      const result = await bash.exec(command);
+    async executeCommand(command, options2) {
+      const result = await bash.exec(
+        command,
+        options2?.signal ? { signal: options2.signal } : void 0
+      );
       return {
         stdout: result.stdout,
         stderr: result.stderr,
@@ -7348,6 +8392,8 @@ async function createVirtualSandbox(options) {
           typeof file.content === "string" ? file.content : Buffer.from(file.content).toString("utf-8")
         );
       }
+    },
+    async dispose() {
     }
   };
 }
@@ -7429,7 +8475,7 @@ function soul() {
 }
 
 // packages/context/src/lib/store/postgres.store.ts
-import { createRequire } from "node:module";
+import { createRequire as createRequire2 } from "node:module";
 
 // packages/context/src/lib/store/ddl.postgres.ts
 function storeDDL(schema) {
@@ -7541,7 +8587,7 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
   }
   static #requirePg() {
     try {
-      const require2 = createRequire(import.meta.url);
+      const require2 = createRequire2(import.meta.url);
       return require2("pg");
     } catch {
       throw new Error(
@@ -8137,7 +9183,7 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
 };
 
 // packages/context/src/lib/store/sqlserver.store.ts
-import { createRequire as createRequire2 } from "node:module";
+import { createRequire as createRequire3 } from "node:module";
 
 // packages/context/src/lib/store/ddl.sqlserver.ts
 function storeDDL2(schema) {
@@ -8279,7 +9325,7 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
   }
   static #requireMssql() {
     try {
-      const require2 = createRequire2(import.meta.url);
+      const require2 = createRequire3(import.meta.url);
       return require2("mssql");
     } catch {
       throw new Error(
@@ -8989,11 +10035,12 @@ async function persistedWriter(options) {
   } = options;
   let seq = 0;
   let buffer = [];
+  let failedByErrorChunk = false;
   async function flush() {
     if (buffer.length === 0) return;
     const batch = buffer;
     buffer = [];
-    await store2.appendChunks(batch);
+    await appendBatch(batch);
   }
   function makeChunk(part) {
     return {
@@ -9003,9 +10050,19 @@ async function persistedWriter(options) {
       createdAt: Date.now()
     };
   }
+  function isStreamErrorPart(part) {
+    return part.type === "error";
+  }
+  async function appendBatch(batch) {
+    const hasErrorPart = !failedByErrorChunk && batch.map((chunk) => chunk.data).some(isStreamErrorPart);
+    await store2.appendChunks(batch);
+    if (hasErrorPart) {
+      failedByErrorChunk = true;
+    }
+  }
   async function persistChunk(chunk) {
     if (strategy === "immediate") {
-      await store2.appendChunks([chunk]);
+      await appendBatch([chunk]);
     } else {
       buffer.push(chunk);
       if (buffer.length >= flushSize) {
@@ -9035,10 +10092,12 @@ async function persistedWriter(options) {
     flush,
     async complete() {
       await flush();
+      if (failedByErrorChunk) return;
       await store2.updateStreamStatus(streamId, "completed");
     },
     async fail(error) {
       await flush();
+      if (failedByErrorChunk) return;
       await store2.updateStreamStatus(streamId, "failed", { error });
     },
     async cleanup() {
@@ -9048,7 +10107,7 @@ async function persistedWriter(options) {
 }
 
 // packages/context/src/lib/stream/polling-change-source.ts
-import { setTimeout as delay } from "node:timers/promises";
+import { setTimeout as delay2 } from "node:timers/promises";
 
 // packages/context/src/lib/stream/polling-policy.ts
 var DEFAULT_WATCH_POLLING = {
@@ -9093,7 +10152,7 @@ function nextAdaptivePollingDelay(state) {
     state.config.minMs,
     state.config.maxMs
   );
-  const delay2 = applyJitter(
+  const delay3 = applyJitter(
     current,
     state.config.jitterRatio,
     state.config.minMs,
@@ -9104,7 +10163,7 @@ function nextAdaptivePollingDelay(state) {
     state.config.minMs,
     state.config.maxMs
   );
-  return delay2;
+  return delay3;
 }
 function normalizeAdaptivePolling(polling, fallback) {
   const merged = {
@@ -9204,7 +10263,7 @@ function isTerminal(status) {
   return status !== "queued" && status !== "running";
 }
 function waitForDelay(ms, signal) {
-  return delay(ms, true, { signal }).catch((err) => {
+  return delay2(ms, true, { signal }).catch((err) => {
     if (signal.aborted) return false;
     throw err;
   });
@@ -9256,7 +10315,7 @@ function asStaticWordPartText(parts, options = {}) {
 }
 
 // packages/context/src/lib/stream/postgres-notify-change-source.ts
-import { createRequire as createRequire3 } from "node:module";
+import { createRequire as createRequire4 } from "node:module";
 
 // packages/context/src/lib/stream/ddl.stream.postgres-notify.ts
 var DEFAULT_POSTGRES_STREAM_CHANGES_CHANNEL = "deepagents_stream_changes";
@@ -9358,7 +10417,7 @@ var PostgresNotifyChangeSource = class _PostgresNotifyChangeSource {
   }
   static #requirePg() {
     try {
-      const require2 = createRequire3(import.meta.url);
+      const require2 = createRequire4(import.meta.url);
       return require2("pg");
     } catch {
       throw new Error(
@@ -9613,7 +10672,7 @@ function assertIdentifier(value, label) {
 }
 
 // packages/context/src/lib/stream/postgres.stream-store.ts
-import { createRequire as createRequire4 } from "node:module";
+import { createRequire as createRequire5 } from "node:module";
 
 // packages/context/src/lib/stream/ddl.stream.postgres.ts
 function postgresStreamDDL(schema) {
@@ -9649,6 +10708,15 @@ CREATE INDEX IF NOT EXISTS "idx_${schema}_streams_status_created_at_id"
 }
 
 // packages/context/src/lib/stream/stream-store.ts
+function collectStreamFailures(chunks) {
+  const failures = /* @__PURE__ */ new Map();
+  for (const chunk of chunks) {
+    if (chunk.data.type === "error" && !failures.has(chunk.streamId)) {
+      failures.set(chunk.streamId, chunk.data.errorText);
+    }
+  }
+  return [...failures].map(([streamId, error]) => ({ streamId, error }));
+}
 var StreamStore = class {
   async listRunningStreamIds() {
     return this.listStreamIds({ status: "running" });
@@ -9678,7 +10746,7 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
   }
   static #requirePg() {
     try {
-      const require2 = createRequire4(import.meta.url);
+      const require2 = createRequire5(import.meta.url);
       return require2("pg");
     } catch {
       throw new Error(
@@ -9832,13 +10900,31 @@ var PostgresStreamStore = class _PostgresStreamStore extends StreamStore {
       data: chunk.data,
       created_at: chunk.createdAt
     }));
-    await this.#query(
-      `INSERT INTO ${this.#t("stream_chunks")} (stream_id, seq, data, created_at)
+    const params = [JSON.stringify(rows)];
+    const insertSql = `INSERT INTO ${this.#t("stream_chunks")} (stream_id, seq, data, created_at)
        SELECT stream_id, seq, data, created_at
        FROM jsonb_to_recordset($1::jsonb)
-         AS rows(stream_id TEXT, seq INTEGER, data JSONB, created_at BIGINT)`,
-      [JSON.stringify(rows)]
-    );
+         AS rows(stream_id TEXT, seq INTEGER, data JSONB, created_at BIGINT)`;
+    const failures = collectStreamFailures(chunks);
+    if (failures.length === 0) {
+      await this.#query(insertSql, params);
+      return;
+    }
+    await this.#useTransaction(async (client) => {
+      await client.query(insertSql, params);
+      const failedAt = Date.now();
+      for (const failure of failures) {
+        const result = await client.query(
+          `UPDATE ${this.#t("streams")}
+           SET status = $1, finished_at = $2, error = $3
+           WHERE id = $4`,
+          ["failed", failedAt, failure.error, failure.streamId]
+        );
+        if (result.rowCount !== 1) {
+          throw new Error(`Stream "${failure.streamId}" not found`);
+        }
+      }
+    });
   }
   async getChunks(streamId, fromSeq, limit) {
     const params = [streamId];
@@ -10085,6 +11171,7 @@ var SqliteStreamStore = class extends StreamStore {
   }
   async appendChunks(chunks) {
     if (chunks.length === 0) return;
+    const failures = collectStreamFailures(chunks);
     this.#db.exec("BEGIN TRANSACTION");
     try {
       for (const chunk of chunks) {
@@ -10098,6 +11185,15 @@ var SqliteStreamStore = class extends StreamStore {
           chunk.createdAt
         );
       }
+      const failedAt = Date.now();
+      for (const failure of failures) {
+        const result = this.#stmt(
+          "UPDATE streams SET status = ?, finishedAt = ?, error = ? WHERE id = ?"
+        ).run("failed", failedAt, failure.error, failure.streamId);
+        if (result.changes !== 1) {
+          throw new Error(`Stream "${failure.streamId}" not found`);
+        }
+      }
       this.#db.exec("COMMIT");
     } catch (error) {
       this.#db.exec("ROLLBACK");
@@ -10499,14 +11595,20 @@ export {
   AsyncResolver,
   BM25Classifier,
   BashException,
+  BinInstaller,
   ComposeStartError,
   ComposeStrategy,
   ContainerCreationError,
   ContextEngine,
   ContextRenderer,
   ContextStore,
+  DAYTONA_DEFAULT_DESTINATION,
   DEFAULT_CANCEL_POLLING,
   DEFAULT_WATCH_POLLING,
+  DaytonaCommandError,
+  DaytonaCreationError,
+  DaytonaNotAvailableError,
+  DaytonaSandboxError,
   DockerNotAvailableError,
   DockerSandboxError,
   DockerSandboxStrategy,
@@ -10524,9 +11626,7 @@ export {
   MarkdownRenderer,
   MissingRuntimeError,
   ModelsRegistry,
-  MountPathError,
   NpmInstaller,
-  ObservedFs,
   PackageInstallError,
   PackageInstaller,
   PipInstaller,
@@ -10536,6 +11636,7 @@ export {
   PostgresStreamStore,
   PromiseResolver,
   RuntimeStrategy,
+  SnapshotFailedError,
   SqlServerContextStore,
   SqliteContextStore,
   SqliteStreamStore,
@@ -10545,6 +11646,10 @@ export {
   TomlRenderer,
   ToonRenderer,
   UrlBinaryInstaller,
+  VolumeCreateError,
+  VolumeInspectError,
+  VolumePathError,
+  VolumeRemoveError,
   XmlRenderer,
   addUsage,
   advisorPreamble,
@@ -10565,11 +11670,13 @@ export {
   assertCountSpec,
   assistant,
   assistantText,
+  bin,
   buildSubcommandRepair,
   chat,
   checkCount,
   clarification,
   classifies,
+  collectStreamFailures,
   contentIncludes,
   contentMatches,
   contentPattern,
@@ -10578,7 +11685,7 @@ export {
   createAgentOsSandbox,
   createBashTool,
   createBinaryBridges,
-  createContainerTool,
+  createDaytonaSandbox,
   createDockerSandbox,
   createInstallerContext,
   createRepairToolCall,
@@ -10639,6 +11746,7 @@ export {
   not,
   npm,
   nullUsage,
+  observeSandboxFileEvents,
   once,
   or,
   parseFrontmatter,
@@ -10663,11 +11771,12 @@ export {
   resolveTz,
   role,
   runGuardrailChain,
+  runWithAbortSignal,
   runWithBashMeta,
   seasonChanged,
   seasonReminder,
   selfCritique,
-  shellQuote,
+  shellQuote3 as shellQuote,
   skills,
   skillsReminder,
   socraticPrompting,
@@ -10696,6 +11805,7 @@ export {
   user,
   visualizeGraph,
   weekChanged,
+  withAbortSignal,
   withinLastN,
   workflow,
   yearChanged,