@deepagents/context 2.1.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
@@ -5836,7 +5863,7 @@ function runWithAbortSignal(signal, fn) {
   return ambientAbortSignal.run(signal, fn);
 }
 function withAbortSignal(sandbox) {
-  return {
+  const decorated = {
     ...sandbox,
     async executeCommand(command, options) {
       const signal = options?.signal ?? ambientAbortSignal.getStore();
@@ -5846,11 +5873,20 @@ function withAbortSignal(sandbox) {
       );
     }
   };
+  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);
@@ -5882,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;
@@ -5892,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)}`
@@ -6017,6 +6125,28 @@ async function snapshot(execute, destination) {
   }
   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();
@@ -6074,6 +6204,41 @@ function observeSandboxFileEvents(sandbox, options) {
     },
     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() {
@@ -6406,13 +6571,513 @@ function resolveRealCwd(ctx) {
   return realCwd;
 }
 
+// packages/context/src/lib/sandbox/daytona-sandbox.ts
+import "bash-tool";
+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 = "DaytonaSandboxError";
+    this.cause = cause;
+  }
+};
+var DaytonaNotAvailableError = class extends DaytonaSandboxError {
+  constructor(cause) {
+    super(
+      "@daytona/sdk is not installed. Install it with: npm install @daytona/sdk",
+      cause
+    );
+    this.name = "DaytonaNotAvailableError";
+  }
+};
+var DaytonaCreationError = class extends DaytonaSandboxError {
+  constructor(message2, cause) {
+    super(`Failed to create Daytona sandbox: ${message2}`, cause);
+    this.name = "DaytonaCreationError";
+  }
+};
+var DaytonaCommandError = class extends DaytonaSandboxError {
+  constructor(message2, cause) {
+    super(message2, cause);
+    this.name = "DaytonaCommandError";
+  }
+};
+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);
+  }
+  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);
+  }
+  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 } from "node:stream";
+import { Readable as Readable2 } from "node:stream";
 
 // packages/context/src/lib/sandbox/docker-sandbox-errors.ts
 var DockerSandboxError = class extends Error {
@@ -6559,7 +7224,7 @@ function isDebianBased(image) {
   const debianPatterns = ["debian", "ubuntu", "node", "python"];
   return debianPatterns.some((pattern) => lower.includes(pattern));
 }
-function shellQuote2(s) {
+function shellQuote3(s) {
   return `'${s.replace(/'/g, `'\\''`)}'`;
 }
 function createInstallerContext(containerId, image) {
@@ -6607,7 +7272,7 @@ function createInstallerContext(containerId, image) {
   };
   const installPackages = async (packages) => {
     if (packages.length === 0) return;
-    const quoted = packages.map(shellQuote2).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}`;
@@ -6629,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 ${shellQuote2(checkName)}`);
+    const check = await exec(`which ${shellQuote3(checkName)}`);
     if (check.exitCode === 0) {
       ensuredTools.add(cacheKey);
       return;
@@ -6666,7 +7331,7 @@ var DockerSandboxStrategy = class {
   constructor(args = {}) {
     const { volumes = [], resources = {}, env = {}, name } = args;
     for (const key of Object.keys(env)) {
-      validateEnvKey(key);
+      validateEnvKey2(key);
     }
     if (name !== void 0 && !CONTAINER_NAME_PATTERN.test(name)) {
       throw new DockerSandboxError(
@@ -7071,7 +7736,7 @@ var DockerSandboxStrategy = class {
     return sandbox;
   }
 };
-function validateEnvKey(key) {
+function validateEnvKey2(key) {
   if (key.length === 0 || key.includes("=")) {
     throw new DockerSandboxError(`Invalid environment variable key: "${key}"`);
   }
@@ -7083,7 +7748,7 @@ function buildDockerExecFlags(options) {
   }
   if (options?.env) {
     for (const [key, value] of Object.entries(options.env)) {
-      validateEnvKey(key);
+      validateEnvKey2(key);
       flags.push("-e", `${key}=${value}`);
     }
   }
@@ -7100,8 +7765,8 @@ function toSandboxProcess(child, abortSignal) {
     else abortSignal.addEventListener("abort", onAbort, { once: true });
   }
   return {
-    stdout: Readable.toWeb(child.stdout),
-    stderr: Readable.toWeb(child.stderr),
+    stdout: Readable2.toWeb(child.stdout),
+    stderr: Readable2.toWeb(child.stderr),
     exit: new Promise((resolve4, reject) => {
       const settle = () => {
         child.removeListener("exit", onExitEvent);
@@ -7347,60 +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,
-      volumes,
-      resources,
-      env,
-      name,
-      skills: skills2 = [],
-      ...rest
-    } = options;
-    sandboxOptions = { dockerfile, context, volumes, resources, env, name };
-    bashOptions = rest;
-    skillInputs = skills2;
-  } else {
-    const {
-      image,
-      installers,
-      volumes,
-      resources,
-      env,
-      name,
-      skills: skills2 = [],
-      ...rest
-    } = options;
-    sandboxOptions = { image, installers, volumes, resources, env, name };
-    bashOptions = rest;
-    skillInputs = skills2;
-  }
-  const backend = await createDockerSandbox(sandboxOptions);
-  const toolkit = await createBashTool({
-    ...bashOptions,
-    sandbox: backend,
-    skills: skillInputs
-  });
-  return {
-    bash: toolkit.bash,
-    tools: toolkit.tools,
-    sandbox: toolkit.sandbox,
-    skills: toolkit.skills,
-    drainFileEvents: toolkit.drainFileEvents
-  };
-}
-
 // packages/context/src/lib/sandbox/installers/package-manager.ts
 var PackageInstaller = class extends Installer {
   kind;
@@ -7473,9 +8084,9 @@ async function downloadAndInstall(ctx, name, url, binaryPath, source = "url") {
 function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
   return `
     set -e
-    NAME=${shellQuote2(name)}
-    URL=${shellQuote2(url)}
-    BIN_IN_ARCHIVE=${shellQuote2(binaryPathInArchive)}
+    NAME=${shellQuote3(name)}
+    URL=${shellQuote3(url)}
+    BIN_IN_ARCHIVE=${shellQuote3(binaryPathInArchive)}
     TMPDIR=$(mktemp -d)
     cd "$TMPDIR"
     curl -fsSL "$URL" -o archive.tar.gz
@@ -7494,8 +8105,8 @@ function buildTarGzInstallCmd(name, url, binaryPathInArchive) {
 }
 function buildRawInstallCmd(name, url) {
   return `
-    NAME=${shellQuote2(name)}
-    URL=${shellQuote2(url)}
+    NAME=${shellQuote3(name)}
+    URL=${shellQuote3(url)}
     curl -fsSL "$URL" -o "/usr/local/bin/$NAME"
     chmod +x "/usr/local/bin/$NAME"
   `;
@@ -7548,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 {
@@ -7811,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) {
@@ -7923,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(
@@ -8519,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) {
@@ -8661,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(
@@ -9371,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 {
@@ -9385,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) {
@@ -9417,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() {
@@ -9430,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 = {
@@ -9475,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,
@@ -9486,7 +10163,7 @@ function nextAdaptivePollingDelay(state) {
     state.config.minMs,
     state.config.maxMs
   );
-  return delay2;
+  return delay3;
 }
 function normalizeAdaptivePolling(polling, fallback) {
   const merged = {
@@ -9586,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;
   });
@@ -9638,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";
@@ -9740,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(
@@ -9995,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) {
@@ -10031,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" });
@@ -10060,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(
@@ -10214,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];
@@ -10467,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) {
@@ -10480,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");
@@ -10881,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,
@@ -10950,11 +11670,13 @@ export {
   assertCountSpec,
   assistant,
   assistantText,
+  bin,
   buildSubcommandRepair,
   chat,
   checkCount,
   clarification,
   classifies,
+  collectStreamFailures,
   contentIncludes,
   contentMatches,
   contentPattern,
@@ -10963,7 +11685,7 @@ export {
   createAgentOsSandbox,
   createBashTool,
   createBinaryBridges,
-  createContainerTool,
+  createDaytonaSandbox,
   createDockerSandbox,
   createInstallerContext,
   createRepairToolCall,
@@ -11054,7 +11776,7 @@ export {
   seasonChanged,
   seasonReminder,
   selfCritique,
-  shellQuote2 as shellQuote,
+  shellQuote3 as shellQuote,
   skills,
   skillsReminder,
   socraticPrompting,