@deepagents/context 4.0.0 → 4.2.0

package/dist/index.js

@@ -1186,7 +1186,7 @@ function isOutputAvailableToolPart(part) {
   return isStaticToolUIPart(part) && part.state === "output-available";
 }
 function isToolOutputReminderEnvelope(value) {
-  return isRecord(value) && "result" in value && typeof value.systemReminder === "string" && value.systemReminder.startsWith(SYSTEM_REMINDER_OPEN_TAG);
+  return isRecord(value) && isRecord(value.meta) && value.meta.reminder === true && "result" in value && typeof value.systemReminder === "string";
 }
 function stripTextByRanges(text, ranges) {
   if (ranges.length === 0) {
@@ -1309,7 +1309,8 @@ function applyInlineReminder(message2, value) {
   };
 }
 function applyPartReminder(message2, value) {
-  const part = { type: "text", text: value };
+  const reminderText = formatTaggedReminder(value);
+  const part = { type: "text", text: reminderText };
   message2.parts.push(part);
   const partIndex = message2.parts.length - 1;
   return {
@@ -1318,13 +1319,10 @@ function applyPartReminder(message2, value) {
     target: "user",
     partIndex,
     start: 0,
-    end: value.length,
+    end: reminderText.length,
     mode: "part"
   };
 }
-function resolveReminderText(item, ctx) {
-  return resolveReminder(item, ctx)?.text ?? "";
-}
 function normalizeReminderResolution(value) {
   if (typeof value === "string") {
     return value.trim().length === 0 ? null : { text: value };
@@ -1374,7 +1372,19 @@ function applyRemindersToToolOutput(output, texts) {
   if (texts.length === 0) return output;
   return {
     result: output === void 0 ? null : output,
-    systemReminder: formatTaggedReminder(texts.join("\n"))
+    systemReminder: formatTaggedReminder(texts.join("\n")),
+    meta: { reminder: true }
+  };
+}
+function toToolReminderModelOutput(output, projectResult) {
+  if (!isToolOutputReminderEnvelope(output)) return null;
+  const projected = projectResult(output.result);
+  return {
+    type: "json",
+    value: {
+      result: isRecord(projected) ? projected.value : projected,
+      systemReminder: output.systemReminder
+    }
   };
 }
 function mergeReminderMetadata(message2, addedReminders) {
@@ -1585,6 +1595,7 @@ var Agent = class _Agent {
       ),
       toolChoice: this.#options.toolChoice,
       onStepFinish: (step) => {
+        if (!this.#options.logging) return;
         const toolCall2 = step.toolCalls.at(-1);
         if (toolCall2) {
           console.log(
@@ -1662,6 +1673,7 @@ var Agent = class _Agent {
       experimental_context: contextVariables,
       toolChoice: this.#options.toolChoice,
       onStepFinish: (step) => {
+        if (!this.#options.logging) return;
         const toolCall2 = step.toolCalls.at(-1);
         if (toolCall2) {
           console.log(
@@ -1916,12 +1928,23 @@ function wrapToolsWithOutputReminders(tools, context) {
       wrapped[name] = toolDef;
       continue;
     }
+    const originalToModelOutput = toolDef.toModelOutput;
     wrapped[name] = {
       ...toolDef,
       execute: async (input, options) => {
         const result = await execute.call(toolDef, input, options);
         if (isAsyncIterable(result)) return result;
-        return context.applyToolOutputReminders(result);
+        return context.applyToolOutputReminders(result, {
+          toolName: name,
+          input
+        });
+      },
+      toModelOutput: (args) => {
+        const project = (output) => originalToModelOutput ? originalToModelOutput({
+          ...args,
+          output
+        }) : defaultToolModelOutput(output);
+        return toToolReminderModelOutput(args.output, project) ?? project(args.output);
       }
     };
   }
@@ -1930,6 +1953,9 @@ function wrapToolsWithOutputReminders(tools, context) {
 function isAsyncIterable(value) {
   return typeof value === "object" && value !== null && Symbol.asyncIterator in value && typeof value[Symbol.asyncIterator] === "function";
 }
+function defaultToolModelOutput(output) {
+  return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: output ?? null };
+}
 function agent(options) {
   return new Agent(options);
 }
@@ -3835,7 +3861,6 @@ var ContextEngine = class _ContextEngine {
     const reminders = matched.map((m) => ({
       text: m.resolved.text,
       asPart: m.config.asPart,
-      target: "user",
       metadata: m.resolved.metadata
     }));
     const carrier = {
@@ -3895,26 +3920,35 @@ var ContextEngine = class _ContextEngine {
    * Evaluate `target: 'tool-output'` reminders against a tool's raw result and
    * return the (possibly wrapped) output.
    *
-   * Called by the agent's tool wrapper right after each `execute()` resolves —
-   * upstream of both the model and the store, so the next model step and the
-   * persisted chain see the exact same wrapped value (store/prompt parity).
+   * Called by the agent's tool wrapper right after each `execute()` resolves.
+   * The wrapper passes the executing `call`, surfaced as
+   * {@link WhenContext.executingTool}, so a predicate can gate on the live
+   * tool's name/input/result — the only point at which the call being wrapped
+   * is observable.
+   * The store keeps the wrapped value with a host-only marker; the model-facing
+   * projection strips that marker while preserving `result` + `systemReminder`.
    *
    * Returns the output unchanged when no tool-output reminder fires. Without a
    * persisted user message there is no turn context to evaluate against
    * (e.g. asTool forks that set a pending user without saving), so the output
    * passes through untouched.
    */
-  async applyToolOutputReminders(output) {
+  async applyToolOutputReminders(output, call) {
     const configs = this.#remindersFor("tool-output");
     if (configs.length === 0) return output;
     await this.#ensureInitialized();
     const chain = await this.#getChainContext();
     const currentMessage = chain.lastMessage;
     if (!currentMessage) return output;
-    const matched = await evaluateFiredReminders(
-      configs,
-      this.#buildWhenCtx(chain, currentMessage)
-    );
+    const whenCtx = this.#buildWhenCtx(chain, currentMessage);
+    if (call) {
+      whenCtx.executingTool = {
+        name: call.toolName,
+        input: call.input,
+        output
+      };
+    }
+    const matched = await evaluateFiredReminders(configs, whenCtx);
     if (matched.length === 0) return output;
     return applyRemindersToToolOutput(
       output,
@@ -6112,14 +6146,15 @@ function bindAbort(signal, onAbort) {
 }
 async function createAgentOsSandbox(options = {}) {
   const { AgentOs } = await importAgentOs();
+  const { readiness, ...kernelOptions } = options;
   let os;
   try {
-    os = await AgentOs.create(options);
+    os = await AgentOs.create(kernelOptions);
   } catch (error) {
     const err = error instanceof Error ? error : new Error(String(error));
     throw new AgentOsCreationError(err.message, err);
   }
-  return {
+  const sandbox = {
     async executeCommand(command, { signal } = {}) {
       if (signal?.aborted) {
         return { stdout: "", stderr: "", exitCode: SIGKILL_EXIT_CODE };
@@ -6199,6 +6234,16 @@ async function createAgentOsSandbox(options = {}) {
       return this.dispose();
     }
   };
+  if (readiness) {
+    try {
+      await readiness(sandbox);
+    } catch (error) {
+      await sandbox.dispose().catch(() => {
+      });
+      throw error;
+    }
+  }
+  return sandbox;
 }
 async function useAgentOsSandbox(options, fn) {
   const sandbox = await createAgentOsSandbox(options);
@@ -6209,1740 +6254,2281 @@ async function useAgentOsSandbox(options, fn) {
   }
 }
 
-// packages/context/src/lib/sandbox/bash-exception.ts
-var BashException = class extends Error {
-};
-
-// packages/context/src/lib/sandbox/bash-meta.ts
-import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
-var store = new AsyncLocalStorage2();
-function runWithBashMeta(fn) {
-  return store.run({ hidden: {} }, fn);
-}
-function useBashMeta() {
-  const state = store.getStore();
-  if (!state) return null;
-  return {
-    setHidden(patch) {
-      state.hidden = { ...state.hidden, ...patch };
-    },
-    setReminder(text) {
-      state.reminder = text;
-    },
-    clearReminder() {
-      state.reminder = void 0;
-    }
-  };
-}
-function readBashMeta() {
-  return store.getStore();
-}
-
-// packages/context/src/lib/sandbox/bash-tool.ts
-import { tool as tool2 } from "ai";
-import {
-  createBashTool as externalCreateBashTool
-} from "bash-tool";
-import z3 from "zod";
+// packages/context/src/lib/sandbox/apple-container-sandbox.ts
+import "bash-tool";
+import spawn3 from "nano-spawn";
+import { spawn as childSpawn2 } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-// packages/context/src/lib/sandbox/upload-skills.ts
-import * as path3 from "node:path";
+// packages/context/src/lib/sandbox/container-sandbox-errors.ts
+var ContainerSandboxError = class extends Error {
+  containerId;
+  constructor(message2, containerId) {
+    super(message2);
+    this.name = "ContainerSandboxError";
+    this.containerId = containerId;
+  }
+};
 
-// packages/context/src/lib/skills/loader.ts
-import * as fs from "node:fs";
-import * as path from "node:path";
-import YAML from "yaml";
-function parseFrontmatter(content) {
-  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
-  const match = content.match(frontmatterRegex);
-  if (!match) {
-    throw new Error("Invalid SKILL.md: missing or malformed frontmatter");
+// packages/context/src/lib/sandbox/apple-container-sandbox-errors.ts
+var AppleContainerSandboxError = class extends ContainerSandboxError {
+  constructor(message2, containerId) {
+    super(message2, containerId);
+    this.name = "AppleContainerSandboxError";
   }
-  const [, yamlContent, body] = match;
-  const frontmatter = YAML.parse(yamlContent);
-  if (!frontmatter.name || typeof frontmatter.name !== "string") {
-    throw new Error('Invalid SKILL.md: frontmatter must have a "name" field');
+};
+var ContainerServiceNotRunningError = class extends AppleContainerSandboxError {
+  constructor() {
+    super(
+      "Apple container service is not running. Start it with `container system start` (first run also needs `container system kernel set --recommended`)."
+    );
+    this.name = "ContainerServiceNotRunningError";
   }
-  if (!frontmatter.description || typeof frontmatter.description !== "string") {
-    throw new Error(
-      'Invalid SKILL.md: frontmatter must have a "description" field'
+};
+var AppleContainerCreationError = class extends AppleContainerSandboxError {
+  image;
+  cause;
+  constructor(message2, image, cause) {
+    super(`Failed to create container from image "${image}": ${message2}`);
+    this.name = "AppleContainerCreationError";
+    this.image = image;
+    this.cause = cause;
+  }
+};
+var AppleContainerImageBuildError = class extends AppleContainerSandboxError {
+  stderr;
+  constructor(stderr) {
+    super(`Container image build failed: ${stderr}`);
+    this.name = "AppleContainerImageBuildError";
+    this.stderr = stderr;
+  }
+};
+var AppleContainerVolumePathError = class extends AppleContainerSandboxError {
+  source;
+  containerPath;
+  reason;
+  constructor(source, containerPath, reason) {
+    super(
+      `Invalid container volume path "${source}" -> "${containerPath}": ${reason}`
     );
+    this.name = "AppleContainerVolumePathError";
+    this.source = source;
+    this.containerPath = containerPath;
+    this.reason = reason;
   }
-  return {
-    frontmatter,
-    body: body.trim()
-  };
+};
+var AppleContainerVolumeInspectError = class extends AppleContainerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to inspect container volume "${volume}": ${reason}`);
+    this.name = "AppleContainerVolumeInspectError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var AppleContainerVolumeCreateError = class extends AppleContainerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to create container volume "${volume}": ${reason}`);
+    this.name = "AppleContainerVolumeCreateError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+var AppleContainerVolumeRemoveError = class extends AppleContainerSandboxError {
+  volume;
+  reason;
+  constructor(volume, reason) {
+    super(`Failed to remove container volume "${volume}": ${reason}`);
+    this.name = "AppleContainerVolumeRemoveError";
+    this.volume = volume;
+    this.reason = reason;
+  }
+};
+
+// packages/context/src/lib/sandbox/container-sandbox.ts
+import "bash-tool";
+import spawn2 from "nano-spawn";
+import { spawn as childSpawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+
+// packages/context/src/lib/sandbox/cli-process.ts
+import { Readable as Readable2 } from "node:stream";
+
+// packages/context/src/lib/sandbox/shell-quote.ts
+function shellQuote(s) {
+  return `'${s.replace(/'/g, `'\\''`)}'`;
 }
-function loadSkillMetadata(skillMdPath) {
-  const content = fs.readFileSync(skillMdPath, "utf-8");
-  const parsed = parseFrontmatter(content);
-  const skillDir = path.dirname(skillMdPath);
+
+// packages/context/src/lib/sandbox/cli-process.ts
+function toSandboxProcess(child, abortSignal) {
+  if (!child.stdout || !child.stderr) {
+    child.kill("SIGKILL");
+    throw new Error("exec child process is missing stdout/stderr streams");
+  }
+  const onAbort = () => child.kill("SIGKILL");
+  if (abortSignal) {
+    if (abortSignal.aborted) onAbort();
+    else abortSignal.addEventListener("abort", onAbort, { once: true });
+  }
   return {
-    name: parsed.frontmatter.name,
-    description: parsed.frontmatter.description,
-    path: skillDir,
-    skillMdPath
+    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);
+        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);
+    })
   };
 }
-function discoverSkillsInDirectory(directory) {
-  const skills2 = [];
-  const expandedDir = directory.startsWith("~") ? path.join(process.env.HOME || "", directory.slice(1)) : directory;
-  if (!fs.existsSync(expandedDir)) {
-    return skills2;
+var BASE64_WRITE_CHUNK = 32768;
+function base64WriteCommands(path5, content) {
+  const base64 = Buffer.from(content).toString("base64");
+  const quotedPath = shellQuote(path5);
+  const commands = [];
+  for (let offset = 0; offset < base64.length; offset += BASE64_WRITE_CHUNK) {
+    const chunk = base64.slice(offset, offset + BASE64_WRITE_CHUNK);
+    const redirect = offset === 0 ? ">" : ">>";
+    commands.push(
+      `printf '%s' ${shellQuote(chunk)} | base64 -d ${redirect} ${quotedPath}`
+    );
   }
-  const entries = fs.readdirSync(expandedDir, { withFileTypes: true });
-  for (const entry of entries) {
-    if (!entry.isDirectory()) continue;
-    const skillMdPath = path.join(expandedDir, entry.name, "SKILL.md");
-    if (!fs.existsSync(skillMdPath)) continue;
-    try {
-      const metadata = loadSkillMetadata(skillMdPath);
-      skills2.push(metadata);
-    } catch (error) {
-      console.warn(`Warning: Failed to load skill at ${skillMdPath}:`, error);
-    }
+  if (commands.length === 0) {
+    commands.push(`printf '' > ${quotedPath}`);
   }
-  return skills2;
+  return commands;
 }
-
-// packages/context/src/lib/sandbox/walk.ts
-import { readFile, readdir } from "node:fs/promises";
-import * as path2 from "node:path";
-function expandHome(input) {
-  if (!input.startsWith("~")) return input;
-  const home = process.env.HOME ?? "";
-  return path2.join(home, input.slice(1));
-}
-async function walkDirectory(root) {
-  const absoluteRoot = path2.resolve(expandHome(root));
-  const files = [];
-  async function walk(current) {
-    let entries;
-    try {
-      entries = await readdir(current, { withFileTypes: true });
-    } catch {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name.startsWith(".")) continue;
-      if (entry.isSymbolicLink()) continue;
-      const entryPath = path2.join(current, entry.name);
-      if (entry.isDirectory()) {
-        await walk(entryPath);
-      } else if (entry.isFile()) {
-        const content = await readFile(entryPath);
-        const relative3 = path2.relative(absoluteRoot, entryPath).split(path2.sep).join("/");
-        files.push({ path: entryPath, relativePath: relative3, content });
-      }
-    }
-  }
-  await walk(absoluteRoot);
-  return files;
+function base64ReadCommand(path5) {
+  return `base64 ${shellQuote(path5)}`;
 }
 
-// packages/context/src/lib/sandbox/upload-skills.ts
-function expandHome2(input) {
-  if (!input.startsWith("~")) return input;
-  const home = process.env.HOME ?? "";
-  return path3.join(home, input.slice(1));
-}
-function joinSandbox(base, relative3) {
-  if (!relative3) return base;
-  const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
-  return `${normalizedBase}/${relative3}`;
-}
-function discoverSkillMappings(inputs) {
-  if (inputs.length === 0) return [];
-  const discoveredByName = /* @__PURE__ */ new Map();
-  for (const { host, sandbox: sandboxBase } of inputs) {
-    const absoluteHost = path3.resolve(expandHome2(host));
-    for (const skill of discoverSkillsInDirectory(host)) {
-      const absoluteSkillMd = path3.resolve(skill.skillMdPath);
-      const relative3 = path3.relative(absoluteHost, absoluteSkillMd).split(path3.sep).join("/");
-      discoveredByName.set(skill.name, {
-        name: skill.name,
-        description: skill.description,
-        host: skill.skillMdPath,
-        sandbox: joinSandbox(sandboxBase, relative3)
-      });
-    }
-  }
-  return Array.from(discoveredByName.values());
-}
-async function uploadSkills(sandbox, inputs) {
-  if (inputs.length === 0) return [];
-  const skills2 = discoverSkillMappings(inputs);
-  const filesToUpload = [];
-  for (const { host, sandbox: sandboxBase } of inputs) {
-    const walked = await walkDirectory(host);
-    for (const file of walked) {
-      filesToUpload.push({
-        path: joinSandbox(sandboxBase, file.relativePath),
-        content: file.content
-      });
-    }
+// packages/context/src/lib/sandbox/installers/installer.ts
+import "bash-tool";
+import spawn from "nano-spawn";
+
+// packages/context/src/lib/sandbox/docker-sandbox-errors.ts
+var DockerSandboxError = class extends ContainerSandboxError {
+  constructor(message2, containerId) {
+    super(message2, containerId);
+    this.name = "DockerSandboxError";
   }
-  if (filesToUpload.length > 0) {
-    await sandbox.writeFiles(filesToUpload);
+};
+var DockerNotAvailableError = class extends DockerSandboxError {
+  constructor() {
+    super("Docker is not available. Ensure Docker daemon is running.");
+    this.name = "DockerNotAvailableError";
   }
-  return skills2;
-}
+};
+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/bash-tool.ts
-var REASONING_INSTRUCTION = 'Every bash tool call must include a brief non-empty "reasoning" input explaining why the command is needed.';
-function withBashExceptionCatch(sandbox) {
+// packages/context/src/lib/sandbox/installers/installer.ts
+var Installer = class {
+};
+function isDebianBased(image) {
+  const lower = image.toLowerCase();
+  if (lower.includes("alpine")) return false;
+  const debianPatterns = ["debian", "ubuntu", "node", "python"];
+  return debianPatterns.some((pattern) => lower.includes(pattern));
+}
+function createInstallerContext(containerId, image) {
+  const packageManager = isDebianBased(image) ? "apt-get" : "apk";
+  let archPromise = null;
+  const ensuredTools = /* @__PURE__ */ new Set();
+  let aptUpdated = false;
+  const exec = async (command) => {
+    try {
+      const result = await spawn("docker", [
+        "exec",
+        containerId,
+        "sh",
+        "-c",
+        command
+      ]);
+      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+    } catch (error) {
+      const err = error;
+      return {
+        stdout: err.stdout ?? "",
+        stderr: err.stderr ?? err.message ?? "",
+        exitCode: err.exitCode ?? 1
+      };
+    }
+  };
+  const arch = async () => {
+    if (!archPromise) {
+      const attempt = (async () => {
+        const result = await exec("uname -m");
+        if (result.exitCode !== 0) {
+          throw new DockerSandboxError(
+            `Failed to detect container architecture: ${result.stderr}`,
+            containerId
+          );
+        }
+        return result.stdout.trim();
+      })();
+      archPromise = attempt.catch((err) => {
+        archPromise = null;
+        throw err;
+      });
+    }
+    return archPromise;
+  };
+  const installPackages = async (packages) => {
+    if (packages.length === 0) return;
+    const quoted = packages.map(shellQuote).join(" ");
+    let cmd;
+    if (packageManager === "apt-get") {
+      cmd = aptUpdated ? `apt-get install -y ${quoted}` : `apt-get update && apt-get install -y ${quoted}`;
+    } else {
+      cmd = `apk add --no-cache ${quoted}`;
+    }
+    const result = await exec(cmd);
+    if (result.exitCode !== 0) {
+      throw new PackageInstallError(
+        packages,
+        image,
+        packageManager,
+        result.stderr,
+        containerId
+      );
+    }
+    if (packageManager === "apt-get") aptUpdated = true;
+  };
+  const ensureTool = async (checkName, installName) => {
+    const cacheKey = installName ?? checkName;
+    if (ensuredTools.has(cacheKey)) return;
+    const check = await exec(`which ${shellQuote(checkName)}`);
+    if (check.exitCode === 0) {
+      ensuredTools.add(cacheKey);
+      return;
+    }
+    await installPackages([installName ?? checkName]);
+    ensuredTools.add(cacheKey);
+  };
   return {
-    ...sandbox,
-    async executeCommand(command, options) {
+    containerId,
+    image,
+    packageManager,
+    arch,
+    exec,
+    installPackages,
+    ensureTool
+  };
+}
+
+// packages/context/src/lib/sandbox/container-sandbox.ts
+var CONTAINER_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
+var ContainerSandboxStrategy = class {
+  context;
+  engine;
+  opts;
+  volumes;
+  name;
+  workdir;
+  createdVolumes = /* @__PURE__ */ new Set();
+  constructor(opts, engine) {
+    this.opts = opts;
+    this.engine = engine;
+    const { volumes = [], env = {}, name, workdir = "/workspace" } = opts;
+    for (const key of Object.keys(env)) {
+      if (key.length === 0 || key.includes("=")) {
+        throw this.engine.errors.generic(
+          `Invalid environment variable key: "${key}"`
+        );
+      }
+    }
+    if (name !== void 0 && !CONTAINER_NAME_PATTERN.test(name)) {
+      throw this.engine.errors.generic(
+        `Invalid container name: "${name}". Use only letters, numbers, underscore, period, or hyphen. The "sandbox-" prefix is added automatically.`
+      );
+    }
+    this.volumes = volumes;
+    this.name = name;
+    this.workdir = workdir;
+  }
+  async create() {
+    const image = await this.getImage();
+    let acquired;
+    try {
+      acquired = await this.acquireContainer(image);
+      this.context = { containerId: acquired.containerId, image };
+      if (!acquired.attached) {
+        await this.engine.ensureWorkdir(this.context.containerId, this.workdir);
+        await this.configure();
+      }
+    } catch (error) {
+      if (acquired && !acquired.attached) {
+        await this.stopContainer(acquired.containerId);
+      }
+      await this.cleanupCreatedVolumesAfterFailure(error);
+      throw error;
+    }
+    const sandbox = this.createSandboxMethods();
+    if (this.opts.readiness) {
       try {
-        return await sandbox.executeCommand(command, options);
-      } catch (err) {
-        if (err instanceof BashException) return err.format();
-        throw err;
+        await this.opts.readiness(sandbox);
+      } catch (error) {
+        await sandbox.dispose().catch(() => {
+        });
+        throw error;
+      }
+    }
+    return sandbox;
+  }
+  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 (this.engine.isNameConflict(this.engine.errorMessage(error))) {
+        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 function createBashTool(options) {
-  const {
-    skills: skillInputs = [],
-    extraInstructions,
-    sandbox: backend,
-    destination,
-    ...rest
-  } = options;
-  const sandbox = withAbortSignal(withBashExceptionCatch(backend));
-  const combinedInstructions = [extraInstructions, REASONING_INSTRUCTION].filter(Boolean).join("\n\n");
-  const toolkit = await externalCreateBashTool({
-    ...rest,
-    sandbox,
-    destination,
-    extraInstructions: combinedInstructions
-  });
-  const upstreamBash = toolkit.bash;
-  const originalExecute = upstreamBash.execute;
-  const toolBuilder = tool2;
-  const bash = toolBuilder({
-    ...upstreamBash,
-    description: upstreamBash.description ?? "",
-    inputSchema: z3.object({
-      command: z3.string().describe("The bash command to execute"),
-      reasoning: z3.string().trim().describe("Brief reason for executing this command")
-    }),
-    execute: async ({ command }, execOptions) => {
-      if (!originalExecute) {
-        throw new Error("bash tool execution is not available");
+  }
+  async startStoppedContainer(containerId, image) {
+    try {
+      await spawn2(this.engine.cli, ["start", containerId]);
+    } catch (error) {
+      const message2 = this.engineErrorMessage(error);
+      if (this.isServiceDown(message2)) {
+        throw this.engine.errors.serviceNotAvailable();
       }
-      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 } : {}
-          };
-        })
+      throw this.engine.errors.creation(message2, image, error);
+    }
+  }
+  async inspectContainer(containerId) {
+    try {
+      const result = await spawn2(
+        this.engine.cli,
+        this.engine.inspectArgs(containerId)
       );
-    },
-    toModelOutput: ({ output }) => {
-      if (typeof output !== "object" || output === null) {
-        return { type: "json", value: output };
+      return this.engine.parseStatus(result.stdout.trim());
+    } catch (error) {
+      const message2 = this.engineErrorMessage(error);
+      if (this.isServiceDown(message2)) {
+        throw this.engine.errors.serviceNotAvailable();
       }
-      const { meta: _meta, ...visible } = output;
-      return { type: "json", value: visible };
+      if (this.engine.isMissingContainer(message2)) {
+        return "absent";
+      }
+      throw this.engine.errors.generic(
+        `Failed to inspect container "${containerId}": ${message2}`
+      );
     }
-  });
-  const upstreamWriteFile = toolkit.tools.writeFile;
-  const originalWriteExecute = upstreamWriteFile.execute;
-  const writeFileBuilder = tool2;
-  const writeFile = writeFileBuilder({
-    ...upstreamWriteFile,
-    execute: async (input, options2) => {
-      if (!originalWriteExecute) {
-        throw new Error("writeFile tool execution is not available");
+  }
+  async prepareVolumes() {
+    this.validateVolumes();
+    for (const volume of this.volumes) {
+      if (volume.type !== "volume") {
+        continue;
       }
-      try {
-        return await originalWriteExecute(input, options2);
-      } catch (err) {
-        if (err instanceof BashException) return err.format();
-        throw err;
+      const lifecycle = volume.lifecycle ?? "external";
+      if (lifecycle === "external") {
+        await this.inspectVolume(volume.name);
+        continue;
+      }
+      const exists = await this.volumeExists(volume.name);
+      if (exists) {
+        throw this.engine.errors.volumeCreate(
+          volume.name,
+          "managed volume already exists"
+        );
+      }
+      await this.createVolume(volume);
+      if (volume.removeOnDispose !== false) {
+        this.createdVolumes.add(volume.name);
       }
     }
-  });
-  const skills2 = await uploadSkills(backend, skillInputs);
-  return {
-    ...toolkit,
-    sandbox,
-    bash,
-    tools: { ...toolkit.tools, bash, writeFile },
-    skills: skills2
-  };
-}
-
-// packages/context/src/lib/sandbox/binary-bridges.ts
-import { existsSync as existsSync2 } from "fs";
-import { defineCommand } from "just-bash";
-import spawn from "nano-spawn";
-import * as path4 from "path";
-function createBinaryBridges(...binaries) {
-  return binaries.map((input) => {
-    const config = typeof input === "string" ? { name: input } : input;
-    const { name, binaryPath = name, allowedArgs } = config;
-    return defineCommand(name, async (args, ctx) => {
-      if (allowedArgs) {
-        const invalidArg = args.find((arg) => !allowedArgs.test(arg));
-        if (invalidArg) {
-          return {
-            stdout: "",
-            stderr: `${name}: argument '${invalidArg}' not allowed by security policy`,
-            exitCode: 1
-          };
-        }
+  }
+  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 this.engine.errors.volumePath(
+          source,
+          volume.containerPath,
+          "containerPath must be absolute"
+        );
       }
-      try {
-        const realCwd = resolveRealCwd(ctx);
-        const resolvedArgs = args.map((arg) => {
-          if (arg.startsWith("-")) {
-            return arg;
-          }
-          const hasExtension = path4.extname(arg) !== "";
-          const hasPathSep = arg.includes(path4.sep) || arg.includes("/");
-          const isRelative = arg.startsWith(".");
-          if (hasExtension || hasPathSep || isRelative) {
-            return path4.resolve(realCwd, arg);
-          }
-          return arg;
-        });
-        const mergedEnv = {
-          ...process.env,
-          ...Object.fromEntries(ctx.env),
-          // ctx.env is a Map, convert to object
-          PATH: process.env.PATH
-          // Always use host PATH for binary bridges
-        };
-        const result = await spawn(binaryPath, resolvedArgs, {
-          cwd: realCwd,
-          env: mergedEnv
-        });
-        return {
-          stdout: result.stdout,
-          stderr: result.stderr,
-          exitCode: 0
-        };
-      } catch (error) {
-        if (error && typeof error === "object") {
-          const err = error;
-          const cause = err.cause;
-          if (cause?.code === "ENOENT") {
-            return {
-              stdout: "",
-              stderr: `${name}: ${binaryPath} not found`,
-              exitCode: 127
-            };
-          }
+      this.validateMountValue("containerPath", volume.containerPath, volume);
+      if (containerPaths.has(volume.containerPath)) {
+        throw this.engine.errors.volumePath(
+          source,
+          volume.containerPath,
+          "containerPath must be unique"
+        );
+      }
+      containerPaths.add(volume.containerPath);
+      if (volume.type === "bind") {
+        this.validateMountValue("hostPath", volume.hostPath, volume);
+        if (!existsSync(volume.hostPath)) {
+          throw this.engine.errors.volumePath(
+            volume.hostPath,
+            volume.containerPath,
+            "hostPath does not exist on host"
+          );
         }
-        if (error && typeof error === "object" && "exitCode" in error) {
-          const subprocessError = error;
-          return {
-            stdout: subprocessError.stdout ?? "",
-            stderr: subprocessError.stderr ?? "",
-            exitCode: subprocessError.exitCode ?? 1
-          };
+        continue;
+      }
+      if (!/^[A-Za-z0-9][A-Za-z0-9_.-]*$/.test(volume.name)) {
+        throw this.engine.errors.volumePath(
+          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 this.engine.errors.volumePath(
+            volume.name,
+            volume.containerPath,
+            'driver and driverOptions require lifecycle "managed"'
+          );
         }
-        return {
-          stdout: "",
-          stderr: `${name}: ${error instanceof Error ? error.message : String(error)}`,
-          exitCode: 127
-        };
       }
-    });
-  });
-}
-function resolveRealCwd(ctx) {
-  const fs2 = ctx.fs;
-  let realCwd;
-  if (fs2.root) {
-    realCwd = path4.join(fs2.root, ctx.cwd);
-  } else if (typeof fs2.getMountPoint === "function" && typeof fs2.toRealPath === "function") {
-    const real = fs2.toRealPath(ctx.cwd);
-    realCwd = real ?? process.cwd();
-  } else {
-    realCwd = process.cwd();
+    }
+  }
+  validateMountValue(field, value, volume) {
+    if (!value.includes(",")) {
+      return;
+    }
+    const source = volume.type === "bind" ? volume.hostPath : volume.name;
+    throw this.engine.errors.volumePath(
+      source,
+      volume.containerPath,
+      `${field} must not contain commas`
+    );
+  }
+  buildRunArgs(image, containerId) {
+    return this.engine.runArgs(image, containerId, this.opts, this.workdir);
+  }
+  async inspectVolume(name) {
+    try {
+      await spawn2(this.engine.cli, ["volume", "inspect", name]);
+    } catch (error) {
+      const reason = this.engineErrorMessage(error);
+      if (this.isServiceDown(reason)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.volumeInspect(name, reason);
+    }
+  }
+  async volumeExists(name) {
+    try {
+      await this.inspectVolume(name);
+      return true;
+    } catch (error) {
+      if (error instanceof ContainerSandboxError && this.engine.isMissingVolume(error.message)) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  async createVolume(volume) {
+    const args = this.engine.volumeCreateArgs(volume);
+    try {
+      await spawn2(this.engine.cli, args);
+    } catch (error) {
+      const reason = this.engineErrorMessage(error);
+      if (this.isServiceDown(reason)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.volumeCreate(volume.name, reason);
+    }
   }
-  if (!existsSync2(realCwd)) {
-    realCwd = process.cwd();
+  async cleanupCreatedVolumes() {
+    const volumes = [...this.createdVolumes].reverse();
+    for (const volume of volumes) {
+      try {
+        await spawn2(this.engine.cli, ["volume", "rm", volume]);
+        this.createdVolumes.delete(volume);
+      } catch (error) {
+        const reason = this.engineErrorMessage(error);
+        if (this.isServiceDown(reason)) {
+          throw this.engine.errors.serviceNotAvailable();
+        }
+        throw this.engine.errors.volumeRemove(volume, reason);
+      }
+    }
   }
-  return realCwd;
-}
-
-// packages/context/src/lib/sandbox/daytona-sandbox.ts
-import "bash-tool";
-import { randomUUID } from "node:crypto";
-
-// packages/context/src/lib/sandbox/shell-quote.ts
-function shellQuote(s) {
-  return `'${s.replace(/'/g, `'\\''`)}'`;
-}
-
-// packages/context/src/lib/sandbox/daytona-sandbox.ts
-var DAYTONA_DEFAULT_DESTINATION = "/home/daytona";
-var DAYTONA_EXIT_POLL_INTERVAL_MS = 250;
-var DAYTONA_EXIT_POLL_TIMEOUT_MS = 3e4;
-var DaytonaSandboxError = class extends Error {
-  constructor(message2, cause) {
-    super(message2);
-    this.name = "DaytonaSandboxError";
-    this.cause = cause;
+  async cleanupCreatedVolumesAfterFailure(originalError) {
+    try {
+      await this.cleanupCreatedVolumes();
+    } catch (cleanupError) {
+      if (originalError instanceof Error) {
+        const original = originalError;
+        original.suppressed = [...original.suppressed ?? [], cleanupError];
+      }
+    }
   }
-};
-var DaytonaCreationError = class extends DaytonaSandboxError {
-  constructor(message2, cause) {
-    super(`Failed to create Daytona sandbox: ${message2}`, cause);
-    this.name = "DaytonaCreationError";
+  engineErrorMessage(error) {
+    return this.engine.errorMessage(error);
   }
-};
-var DaytonaCommandError = class extends DaytonaSandboxError {
-  constructor(message2, cause) {
-    super(message2, cause);
-    this.name = "DaytonaCommandError";
+  isServiceDown(message2) {
+    return this.engine.isServiceDown(message2);
   }
-};
-async function createDaytonaSandbox(client, options = {}) {
-  validateDaytonaOptions(options);
-  const sdk = await import("@daytona/sdk");
-  let sandbox;
-  try {
-    if (options.sandboxId !== void 0) {
-      sandbox = await client.get(options.sandboxId);
-      await startIfStopped(sandbox, options);
-    } else {
-      sandbox = await acquireReusedSandbox(client, options, sdk);
+  async startContainer(image, containerId) {
+    const args = this.buildRunArgs(image, containerId);
+    try {
+      await spawn2(this.engine.cli, args);
+    } catch (error) {
+      const message2 = this.engineErrorMessage(error);
+      if (this.isServiceDown(message2)) {
+        throw this.engine.errors.serviceNotAvailable();
+      }
+      throw this.engine.errors.creation(message2, image, error);
     }
-  } catch (error) {
-    throw normalizeDaytonaError(error, sdk);
   }
-  return createDaytonaSandboxMethods({
-    sandbox,
-    commandTimeout: options.commandTimeout
-  });
-}
-var UNRECOVERABLE_SANDBOX_STATES = /* @__PURE__ */ new Set([
-  "error",
-  "build_failed",
-  "destroyed"
-]);
-async function acquireReusedSandbox(client, options, sdk) {
-  let existing;
-  try {
-    existing = await client.get(options.name);
-  } catch (error) {
-    if (error instanceof sdk.DaytonaNotFoundError) {
-      return createSandbox(client, options);
+  async stopContainer(containerId) {
+    try {
+      await spawn2(this.engine.cli, ["stop", containerId]);
+    } catch {
     }
-    throw error;
-  }
-  if (existing.state && UNRECOVERABLE_SANDBOX_STATES.has(existing.state)) {
-    await deleteSandboxQuietly(existing, options);
-    return createSandbox(client, options);
   }
-  await startIfStopped(existing, options);
-  return existing;
-}
-async function deleteSandboxQuietly(sandbox, options) {
-  try {
-    await sandbox.delete(options.deleteTimeout);
-  } catch {
+  async exec(command, options) {
+    try {
+      const result = await spawn2(
+        this.engine.cli,
+        this.engine.execArgs(this.context.containerId, command),
+        { signal: options?.signal }
+      );
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: 0
+      };
+    } catch (error) {
+      const err = error;
+      return {
+        stdout: err.stdout || "",
+        stderr: err.stderr || err.message || "",
+        exitCode: err.exitCode ?? 1
+      };
+    }
   }
-}
-async function startIfStopped(sandbox, options) {
-  if (sandbox.state && sandbox.state !== "started") {
-    await sandbox.start(options.startTimeout ?? options.createTimeout);
+  spawnProcess(command, options) {
+    const child = childSpawn(
+      this.engine.cli,
+      this.engine.execArgs(this.context.containerId, command, options)
+    );
+    return toSandboxProcess(child, options?.signal);
   }
-}
-function normalizeDaytonaError(error, sdk) {
-  const err = toError(error);
-  if (err instanceof sdk.DaytonaError) {
-    return err;
+  createSandboxMethods() {
+    const { containerId } = this.context;
+    const sandbox = {
+      executeCommand: async (command, options) => this.exec(command, options),
+      spawn: (command, options) => this.spawnProcess(command, options),
+      readFile: async (path5) => {
+        const result = await sandbox.executeCommand(base64ReadCommand(path5));
+        if (result.exitCode !== 0) {
+          throw new Error(`Failed to read file "${path5}": ${result.stderr}`);
+        }
+        return Buffer.from(result.stdout, "base64").toString("utf-8");
+      },
+      writeFiles: async (files) => {
+        for (const file of files) {
+          const dir = file.path.substring(0, file.path.lastIndexOf("/"));
+          if (dir) {
+            await sandbox.executeCommand(`mkdir -p ${shellQuote(dir)}`);
+          }
+          for (const command of base64WriteCommands(file.path, file.content)) {
+            const result = await sandbox.executeCommand(command);
+            if (result.exitCode !== 0) {
+              throw new Error(
+                `Failed to write file "${file.path}": ${result.stderr}`
+              );
+            }
+          }
+        }
+      },
+      dispose: async () => {
+        await this.stopContainer(containerId);
+        await this.cleanupCreatedVolumes();
+      },
+      [Symbol.asyncDispose]() {
+        return this.dispose();
+      }
+    };
+    return sandbox;
   }
-  return new DaytonaCreationError(err.message, err);
-}
-function createSandbox(client, 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 !== void 0) {
-    const params2 = compactObject({
-      ...base,
-      image: options.image,
-      resources: options.resources
-    });
-    return client.create(params2, {
-      timeout: options.createTimeout,
-      onSnapshotCreateLogs: options.onSnapshotCreateLogs
-    });
+};
+var RuntimeStrategy = class extends ContainerSandboxStrategy {
+  image;
+  installers;
+  constructor(opts, engine, mode) {
+    super(opts, engine);
+    this.image = mode.image;
+    this.installers = mode.installers;
   }
-  const params = compactObject({
-    ...base,
-    snapshot: options.snapshot
-  });
-  return client.create(params, { timeout: options.createTimeout });
-}
-function validateDaytonaOptions(options) {
-  if (options.image && options.snapshot) {
-    throw new DaytonaSandboxError(
-      'Daytona sandbox options cannot include both "image" and "snapshot". Choose one environment source.'
-    );
+  async getImage() {
+    return this.image;
   }
-  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.'
+  async configure() {
+    const ctx = this.engine.createInstallerContext(
+      this.context.containerId,
+      this.image
     );
+    for (const installer of this.installers) {
+      await installer.install(ctx);
+    }
   }
-  if (options.sandboxId === void 0 && options.name === void 0) {
-    throw new DaytonaSandboxError(
-      'Daytona sandbox options require "name" (get-or-create) or "sandboxId" (attach). An unnamed sandbox cannot be reclaimed, since dispose() does not delete it.'
-    );
+};
+var ContainerfileStrategy = class extends ContainerSandboxStrategy {
+  dockerfile;
+  dockerContext;
+  showBuildLogs;
+  identity;
+  constructor(opts, engine, mode) {
+    super(opts, engine);
+    this.dockerfile = mode.dockerfile;
+    this.dockerContext = mode.context;
+    this.showBuildLogs = mode.showBuildLogs;
+    this.identity = mode.identity;
   }
-  if (!options.sandboxId) {
-    return;
+  async getImage() {
+    const content = this.dockerfile.includes("\n") ? this.dockerfile : readFileSync(this.dockerfile, "utf-8");
+    const tag = `sandbox-${createHash("sha256").update(content).update(this.identity ?? "").digest("hex").slice(0, 12)}`;
+    if (!await this.engine.imageExists(tag)) {
+      await this.engine.buildImage({
+        tag,
+        dockerfile: this.dockerfile,
+        context: this.dockerContext,
+        showBuildLogs: this.showBuildLogs,
+        identity: this.identity
+      });
+    }
+    return tag;
   }
-  const creationOnlyFields = [
-    "name",
-    "user",
-    "snapshot",
-    "image",
-    "language",
-    "envVars",
-    "labels",
-    "public",
-    "resources",
-    "volumes",
-    "networkAllowList",
-    "networkBlockAll",
-    "autoStopInterval",
-    "autoArchiveInterval",
-    "autoDeleteInterval",
-    "ephemeral",
-    "onSnapshotCreateLogs"
+  async configure() {
+  }
+};
+
+// packages/context/src/lib/sandbox/apple-container-sandbox.ts
+var CLI = "container";
+var WORKDIR = "/workspace";
+function isAppleContainerfileOptions(opts) {
+  return "dockerfile" in opts;
+}
+function buildMountArg(volume) {
+  const readOnly = volume.readOnly !== false;
+  if (volume.type === "volume") {
+    return `${volume.name}:${volume.containerPath}${readOnly ? ":ro" : ""}`;
+  }
+  const parts = [
+    "type=bind",
+    `source=${volume.hostPath}`,
+    `target=${volume.containerPath}`
   ];
-  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(", ")}`
-    );
+  if (readOnly) {
+    parts.push("readonly");
   }
+  return parts.join(",");
 }
-function createDaytonaSandboxMethods(args) {
-  const { sandbox, commandTimeout } = args;
-  const executeCommand = async (command, options) => {
-    if (options?.signal?.aborted) {
-      return abortedCommandResult();
+function getCliErrorMessage(error) {
+  const err = error;
+  return err.stderr?.trim() || err.stdout?.trim() || err.message || String(error);
+}
+function safeParseArray(stdout) {
+  try {
+    const parsed = JSON.parse(stdout || "[]");
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+function readContainerStatus(entry) {
+  const raw = entry?.status;
+  const status = String(
+    (typeof raw === "object" && raw !== null ? raw.state : raw) ?? ""
+  ).toLowerCase();
+  if (status === "running" || status === "booted") return "running";
+  if (status === "stopped") return "stopped";
+  throw new AppleContainerSandboxError(
+    `Container is in an unexpected state "${status}"`
+  );
+}
+var appleEngine = {
+  cli: CLI,
+  runArgs(image, containerId, opts) {
+    const { memory = "1024M", cpus = 2 } = opts.resources ?? {};
+    const args = [
+      "run",
+      "--detach",
+      "--rm",
+      "--name",
+      containerId,
+      "--memory",
+      memory,
+      "--cpus",
+      String(cpus)
+    ];
+    if (opts.arch) {
+      args.push("--arch", opts.arch);
     }
-    let aborted = false;
-    const abort = () => {
-      aborted = true;
-    };
-    options?.signal?.addEventListener("abort", abort, { once: true });
+    for (const [key, value] of Object.entries(opts.env ?? {})) {
+      args.push("--env", `${key}=${value}`);
+    }
+    for (const volume of opts.volumes ?? []) {
+      args.push(
+        volume.type === "volume" ? "--volume" : "--mount",
+        buildMountArg(volume)
+      );
+    }
+    args.push(image);
+    if (opts.command === void 0) {
+      args.push("tail", "-f", "/dev/null");
+    } else if (opts.command !== null) {
+      args.push(...opts.command);
+    }
+    return args;
+  },
+  execArgs(containerId, command, options) {
+    const flags = ["--cwd", options?.cwd || WORKDIR];
+    if (options?.env) {
+      for (const [key, value] of Object.entries(options.env)) {
+        if (key.length === 0 || key.includes("=")) {
+          throw new AppleContainerSandboxError(
+            `Invalid environment variable key: "${key}"`
+          );
+        }
+        flags.push("--env", `${key}=${value}`);
+      }
+    }
+    return ["exec", ...flags, containerId, "sh", "-c", command];
+  },
+  inspectArgs(containerId) {
+    return ["inspect", containerId];
+  },
+  mountArg: buildMountArg,
+  parseStatus(stdout) {
+    const entries = safeParseArray(stdout);
+    if (entries.length === 0) return "absent";
+    return readContainerStatus(entries[0]);
+  },
+  volumeCreateArgs(volume) {
+    return ["volume", "create", volume.name];
+  },
+  errorMessage: getCliErrorMessage,
+  isServiceDown(message2) {
+    return /apiserver|not running|connection refused|could not connect|xpc/i.test(
+      message2
+    );
+  },
+  isMissingContainer(message2) {
+    return /not found|no such/i.test(message2);
+  },
+  isMissingVolume(message2) {
+    return /not found|no such/i.test(message2);
+  },
+  isNameConflict(message2) {
+    return /already exists/i.test(message2);
+  },
+  async ensureWorkdir(containerId, workdir) {
+    await spawn3(CLI, ["exec", containerId, "sh", "-c", `mkdir -p ${workdir}`]);
+  },
+  defaultImage: "docker.io/library/alpine:latest",
+  createInstallerContext: createAppleInstallerContext,
+  async imageExists(tag) {
     try {
-      if (aborted || options?.signal?.aborted) {
-        return abortedCommandResult();
+      await spawn3(CLI, ["image", "inspect", tag]);
+      return true;
+    } catch {
+      return false;
+    }
+  },
+  async buildImage(spec) {
+    const archFlag = spec.identity ? ["--arch", spec.identity] : [];
+    if (spec.dockerfile.includes("\n")) {
+      const tempDir = await mkdtemp(join(tmpdir(), "sandbox-containerfile-"));
+      const dockerfilePath = join(tempDir, "Dockerfile");
+      await writeFile(dockerfilePath, spec.dockerfile);
+      try {
+        await runAppleBuild(
+          ["build", ...archFlag, "-t", spec.tag, "-f", dockerfilePath, tempDir],
+          spec.showBuildLogs
+        );
+      } finally {
+        await rm(tempDir, { recursive: true, force: true });
       }
-      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
-      };
+      return;
+    }
+    await runAppleBuild(
+      [
+        "build",
+        ...archFlag,
+        "-t",
+        spec.tag,
+        "-f",
+        spec.dockerfile,
+        spec.context
+      ],
+      spec.showBuildLogs
+    );
+  },
+  errors: {
+    serviceNotAvailable: () => new ContainerServiceNotRunningError(),
+    creation: (message2, image, cause) => new AppleContainerCreationError(message2, image, cause),
+    generic: (message2, containerId) => new AppleContainerSandboxError(message2, containerId),
+    volumePath: (source, containerPath, reason) => new AppleContainerVolumePathError(source, containerPath, reason),
+    volumeInspect: (name, reason) => new AppleContainerVolumeInspectError(name, reason),
+    volumeCreate: (name, reason) => new AppleContainerVolumeCreateError(name, reason),
+    volumeRemove: (name, reason) => new AppleContainerVolumeRemoveError(name, reason)
+  }
+};
+function createAppleInstallerContext(containerId, image) {
+  const packageManager = isDebianBased(image) ? "apt-get" : "apk";
+  let archPromise = null;
+  const ensuredTools = /* @__PURE__ */ new Set();
+  let aptUpdated = false;
+  const exec = async (command) => {
+    try {
+      const result = await spawn3(CLI, [
+        "exec",
+        containerId,
+        "sh",
+        "-c",
+        command
+      ]);
+      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
     } catch (error) {
-      if (aborted) return abortedCommandResult();
       const err = error;
       return {
         stdout: err.stdout ?? "",
-        stderr: err.stderr ?? err.message ?? String(error),
+        stderr: err.stderr ?? err.message ?? "",
         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 ${shellQuote(dir)}`);
-          if (result.exitCode !== 0) {
-            throw new DaytonaCommandError(
-              `Failed to create directory "${dir}": ${result.stderr}`
-            );
-          }
+  const arch = async () => {
+    if (!archPromise) {
+      const attempt = (async () => {
+        const result = await exec("uname -m");
+        if (result.exitCode !== 0) {
+          throw new AppleContainerSandboxError(
+            `Failed to detect container architecture: ${result.stderr}`,
+            containerId
+          );
         }
-        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() {
-    },
-    [Symbol.asyncDispose]() {
-      return this.dispose();
-    }
-  };
-}
-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(() => {
+        return result.stdout.trim();
+      })();
+      archPromise = attempt.catch((err) => {
+        archPromise = null;
+        throw err;
       });
     }
+    return archPromise;
   };
-  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."
+  const installPackages = async (packages) => {
+    if (packages.length === 0) return;
+    const quoted = packages.map(shellQuote).join(" ");
+    let cmd;
+    if (packageManager === "apt-get") {
+      cmd = aptUpdated ? `apt-get install -y ${quoted}` : `apt-get update && apt-get install -y ${quoted}`;
+    } else {
+      cmd = `apk add --no-cache ${quoted}`;
+    }
+    const result = await exec(cmd);
+    if (result.exitCode !== 0) {
+      throw new PackageInstallError(
+        packages,
+        image,
+        packageManager,
+        result.stderr,
+        containerId
       );
     }
-    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();
+    if (packageManager === "apt-get") aptUpdated = true;
+  };
+  const ensureTool = async (checkName, installName) => {
+    const cacheKey = installName ?? checkName;
+    if (ensuredTools.has(cacheKey)) return;
+    const check = await exec(`which ${shellQuote(checkName)}`);
+    if (check.exitCode === 0) {
+      ensuredTools.add(cacheKey);
+      return;
+    }
+    await installPackages([installName ?? checkName]);
+    ensuredTools.add(cacheKey);
+  };
+  return {
+    containerId,
+    image,
+    packageManager,
+    arch,
+    exec,
+    installPackages,
+    ensureTool
+  };
+}
+async function runAppleBuild(args, showBuildLogs) {
+  try {
+    if (showBuildLogs) {
+      await runStreamed(CLI, args);
+    } else {
+      await spawn3(CLI, args);
     }
-    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;
+    throw new AppleContainerImageBuildError(getCliErrorMessage(error));
+  }
+}
+function runStreamed(command, args) {
+  return new Promise((resolve4, reject) => {
+    const child = childSpawn2(command, args, { stdio: "inherit" });
+    child.once("error", reject);
+    child.once(
+      "exit",
+      (code) => code === 0 ? resolve4() : reject(
+        new Error(
+          `${command} build exited with code ${code} (see build output above)`
+        )
+      )
+    );
+  });
+}
+async function createAppleContainerSandbox(options = {}) {
+  if (isAppleContainerfileOptions(options)) {
+    return new ContainerfileStrategy(options, appleEngine, {
+      dockerfile: options.dockerfile,
+      context: options.context ?? ".",
+      showBuildLogs: options.showBuildLogs ?? false,
+      identity: options.arch
+    }).create();
+  }
+  return new RuntimeStrategy(options, appleEngine, {
+    image: options.image ?? appleEngine.defaultImage,
+    installers: options.installers ?? []
+  }).create();
+}
+async function useAppleContainerSandbox(options, fn) {
+  const sandbox = await createAppleContainerSandbox(options);
+  try {
+    return await fn(sandbox);
   } finally {
-    if (signal) {
-      signal.removeEventListener("abort", abort);
-    }
-    stdout.close();
-    stderr.close();
-    if (sessionCreated) {
-      await sandbox.process.deleteSession(sessionId).catch(() => {
-      });
-    }
+    await sandbox.dispose();
   }
 }
-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.`
-      );
+
+// packages/context/src/lib/sandbox/bash-exception.ts
+var BashException = class extends Error {
+};
+
+// packages/context/src/lib/sandbox/bash-meta.ts
+import { AsyncLocalStorage as AsyncLocalStorage2 } from "node:async_hooks";
+var store = new AsyncLocalStorage2();
+function runWithBashMeta(fn) {
+  return store.run({ hidden: {} }, fn);
+}
+function useBashMeta() {
+  const state = store.getStore();
+  if (!state) return null;
+  return {
+    setHidden(patch) {
+      state.hidden = { ...state.hidden, ...patch };
     }
-    await delay(DAYTONA_EXIT_POLL_INTERVAL_MS);
+  };
+}
+function readBashMeta() {
+  return store.getStore();
+}
+
+// packages/context/src/lib/sandbox/bash-tool.ts
+import { tool as tool2 } from "ai";
+import {
+  createBashTool as externalCreateBashTool
+} from "bash-tool";
+import z3 from "zod";
+
+// packages/context/src/lib/sandbox/upload-skills.ts
+import * as path3 from "node:path";
+
+// packages/context/src/lib/skills/loader.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import YAML from "yaml";
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\s*\n([\s\S]*?)\n---\s*\n?([\s\S]*)$/;
+  const match = content.match(frontmatterRegex);
+  if (!match) {
+    throw new Error("Invalid SKILL.md: missing or malformed frontmatter");
+  }
+  const [, yamlContent, body] = match;
+  const frontmatter = YAML.parse(yamlContent);
+  if (!frontmatter.name || typeof frontmatter.name !== "string") {
+    throw new Error('Invalid SKILL.md: frontmatter must have a "name" field');
+  }
+  if (!frontmatter.description || typeof frontmatter.description !== "string") {
+    throw new Error(
+      'Invalid SKILL.md: frontmatter must have a "description" field'
+    );
   }
+  return {
+    frontmatter,
+    body: body.trim()
+  };
 }
-function sessionExitPollTimeoutMs(commandTimeout) {
-  if (commandTimeout === void 0 || commandTimeout === 0) {
-    return DAYTONA_EXIT_POLL_TIMEOUT_MS;
+function loadSkillMetadata(skillMdPath) {
+  const content = fs.readFileSync(skillMdPath, "utf-8");
+  const parsed = parseFrontmatter(content);
+  const skillDir = path.dirname(skillMdPath);
+  return {
+    name: parsed.frontmatter.name,
+    description: parsed.frontmatter.description,
+    path: skillDir,
+    skillMdPath
+  };
+}
+function discoverSkillsInDirectory(directory) {
+  const skills2 = [];
+  const expandedDir = directory.startsWith("~") ? path.join(process.env.HOME || "", directory.slice(1)) : directory;
+  if (!fs.existsSync(expandedDir)) {
+    return skills2;
   }
-  return Math.max(commandTimeout * 1e3, DAYTONA_EXIT_POLL_TIMEOUT_MS);
+  const entries = fs.readdirSync(expandedDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    const skillMdPath = path.join(expandedDir, entry.name, "SKILL.md");
+    if (!fs.existsSync(skillMdPath)) continue;
+    try {
+      const metadata = loadSkillMetadata(skillMdPath);
+      skills2.push(metadata);
+    } catch (error) {
+      console.warn(`Warning: Failed to load skill at ${skillMdPath}:`, error);
+    }
+  }
+  return skills2;
 }
-function delay(ms) {
-  return new Promise((resolve4) => setTimeout(resolve4, ms));
+
+// packages/context/src/lib/sandbox/walk.ts
+import { readFile, readdir } from "node:fs/promises";
+import * as path2 from "node:path";
+function expandHome(input) {
+  if (!input.startsWith("~")) return input;
+  const home = process.env.HOME ?? "";
+  return path2.join(home, input.slice(1));
 }
-function createTextReadable() {
-  const encoder = new TextEncoder();
-  let controller;
-  let closed = false;
-  return {
-    stream: new ReadableStream({
-      start(streamController) {
-        controller = streamController;
+async function walkDirectory(root) {
+  const absoluteRoot = path2.resolve(expandHome(root));
+  const files = [];
+  async function walk(current) {
+    let entries;
+    try {
+      entries = await readdir(current, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".")) continue;
+      if (entry.isSymbolicLink()) continue;
+      const entryPath = path2.join(current, entry.name);
+      if (entry.isDirectory()) {
+        await walk(entryPath);
+      } else if (entry.isFile()) {
+        const content = await readFile(entryPath);
+        const relative3 = path2.relative(absoluteRoot, entryPath).split(path2.sep).join("/");
+        files.push({ path: entryPath, relativePath: relative3, content });
       }
-    }),
-    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 ${shellQuote(options.cwd)} && ` : "";
-  const env = options.env ?? {};
-  const entries = Object.entries(env);
-  if (entries.length === 0) {
-    return `sh -lc ${shellQuote(`${cwdPrefix}${command}`)}`;
   }
-  for (const [key] of entries) {
-    validateEnvKey(key);
+  await walk(absoluteRoot);
+  return files;
+}
+
+// packages/context/src/lib/sandbox/upload-skills.ts
+function expandHome2(input) {
+  if (!input.startsWith("~")) return input;
+  const home = process.env.HOME ?? "";
+  return path3.join(home, input.slice(1));
+}
+function joinSandbox(base, relative3) {
+  if (!relative3) return base;
+  const normalizedBase = base.endsWith("/") ? base.slice(0, -1) : base;
+  return `${normalizedBase}/${relative3}`;
+}
+function discoverSkillMappings(inputs) {
+  if (inputs.length === 0) return [];
+  const discoveredByName = /* @__PURE__ */ new Map();
+  for (const { host, sandbox: sandboxBase } of inputs) {
+    const absoluteHost = path3.resolve(expandHome2(host));
+    for (const skill of discoverSkillsInDirectory(host)) {
+      const absoluteSkillMd = path3.resolve(skill.skillMdPath);
+      const relative3 = path3.relative(absoluteHost, absoluteSkillMd).split(path3.sep).join("/");
+      discoveredByName.set(skill.name, {
+        name: skill.name,
+        description: skill.description,
+        host: skill.skillMdPath,
+        sandbox: joinSandbox(sandboxBase, relative3)
+      });
+    }
   }
-  const exports = entries.map(([key, value]) => `export ${key}=${shellQuote(value)}`).join("; ");
-  return `sh -lc ${shellQuote(`${exports}; ${cwdPrefix}${command}`)}`;
+  return Array.from(discoveredByName.values());
 }
-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.`
-    );
+async function uploadSkills(sandbox, inputs) {
+  if (inputs.length === 0) return [];
+  const skills2 = discoverSkillMappings(inputs);
+  const filesToUpload = [];
+  for (const { host, sandbox: sandboxBase } of inputs) {
+    const walked = await walkDirectory(host);
+    for (const file of walked) {
+      filesToUpload.push({
+        path: joinSandbox(sandboxBase, file.relativePath),
+        content: file.content
+      });
+    }
   }
+  if (filesToUpload.length > 0) {
+    await sandbox.writeFiles(filesToUpload);
+  }
+  return skills2;
 }
-function createSessionId(kind) {
-  return `deepagents-${kind}-${randomUUID()}`;
-}
-function abortedCommandResult() {
+
+// 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.';
+function withBashExceptionCatch(sandbox) {
   return {
-    stdout: "",
-    stderr: "Command aborted",
-    exitCode: 1
+    ...sandbox,
+    async executeCommand(command, options) {
+      try {
+        return await sandbox.executeCommand(command, options);
+      } catch (err) {
+        if (err instanceof BashException) return err.format();
+        throw err;
+      }
+    }
   };
 }
-function abortedExitInfo() {
+async function createBashTool(options) {
+  const {
+    skills: skillInputs = [],
+    extraInstructions,
+    sandbox: backend,
+    destination,
+    ...rest
+  } = options;
+  const sandbox = withAbortSignal(withBashExceptionCatch(backend));
+  const combinedInstructions = [extraInstructions, REASONING_INSTRUCTION].filter(Boolean).join("\n\n");
+  const toolkit = await externalCreateBashTool({
+    ...rest,
+    sandbox,
+    destination,
+    extraInstructions: combinedInstructions
+  });
+  const upstreamBash = toolkit.bash;
+  const originalExecute = upstreamBash.execute;
+  const toolBuilder = tool2;
+  const bash = toolBuilder({
+    ...upstreamBash,
+    description: upstreamBash.description ?? "",
+    inputSchema: z3.object({
+      command: z3.string().describe("The bash command to execute"),
+      reasoning: z3.string().trim().describe("Brief reason for executing this command")
+    }),
+    execute: async ({ command }, execOptions) => {
+      if (!originalExecute) {
+        throw new Error("bash tool execution is not available");
+      }
+      const { abortSignal } = execOptions;
+      return runWithAbortSignal(
+        abortSignal,
+        () => runWithBashMeta(async () => {
+          const result = await originalExecute({ command }, execOptions);
+          const state = readBashMeta();
+          if (!state) return result;
+          if (Object.keys(state.hidden).length === 0) return result;
+          return { ...result, meta: state.hidden };
+        })
+      );
+    },
+    toModelOutput: ({ output }) => {
+      if (typeof output !== "object" || output === null) {
+        return { type: "json", value: output };
+      }
+      const { meta: _meta, ...visible } = output;
+      return { type: "json", value: visible };
+    }
+  });
+  const upstreamWriteFile = toolkit.tools.writeFile;
+  const originalWriteExecute = upstreamWriteFile.execute;
+  const writeFileBuilder = tool2;
+  const writeFile2 = writeFileBuilder({
+    ...upstreamWriteFile,
+    execute: async (input, options2) => {
+      if (!originalWriteExecute) {
+        throw new Error("writeFile tool execution is not available");
+      }
+      try {
+        return await originalWriteExecute(input, options2);
+      } catch (err) {
+        if (err instanceof BashException) return err.format();
+        throw err;
+      }
+    }
+  });
+  const skills2 = await uploadSkills(backend, skillInputs);
   return {
-    code: null,
-    signal: "SIGKILL",
-    success: false
+    ...toolkit,
+    sandbox,
+    bash,
+    tools: { ...toolkit.tools, bash, writeFile: writeFile2 },
+    skills: skills2
   };
 }
-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));
+
+// packages/context/src/lib/sandbox/binary-bridges.ts
+import { existsSync as existsSync3 } from "fs";
+import { defineCommand } from "just-bash";
+import spawn4 from "nano-spawn";
+import * as path4 from "path";
+function createBinaryBridges(...binaries) {
+  return binaries.map((input) => {
+    const config = typeof input === "string" ? { name: input } : input;
+    const { name, binaryPath = name, allowedArgs } = config;
+    return defineCommand(name, async (args, ctx) => {
+      if (allowedArgs) {
+        const invalidArg = args.find((arg) => !allowedArgs.test(arg));
+        if (invalidArg) {
+          return {
+            stdout: "",
+            stderr: `${name}: argument '${invalidArg}' not allowed by security policy`,
+            exitCode: 1
+          };
+        }
+      }
+      try {
+        const realCwd = resolveRealCwd(ctx);
+        const resolvedArgs = args.map((arg) => {
+          if (arg.startsWith("-")) {
+            return arg;
+          }
+          const hasExtension = path4.extname(arg) !== "";
+          const hasPathSep = arg.includes(path4.sep) || arg.includes("/");
+          const isRelative = arg.startsWith(".");
+          if (hasExtension || hasPathSep || isRelative) {
+            return path4.resolve(realCwd, arg);
+          }
+          return arg;
+        });
+        const mergedEnv = {
+          ...process.env,
+          ...Object.fromEntries(ctx.env),
+          // ctx.env is a Map, convert to object
+          PATH: process.env.PATH
+          // Always use host PATH for binary bridges
+        };
+        const result = await spawn4(binaryPath, resolvedArgs, {
+          cwd: realCwd,
+          env: mergedEnv
+        });
+        return {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: 0
+        };
+      } catch (error) {
+        if (error && typeof error === "object") {
+          const err = error;
+          const cause = err.cause;
+          if (cause?.code === "ENOENT") {
+            return {
+              stdout: "",
+              stderr: `${name}: ${binaryPath} not found`,
+              exitCode: 127
+            };
+          }
+        }
+        if (error && typeof error === "object" && "exitCode" in error) {
+          const subprocessError = error;
+          return {
+            stdout: subprocessError.stdout ?? "",
+            stderr: subprocessError.stderr ?? "",
+            exitCode: subprocessError.exitCode ?? 1
+          };
+        }
+        return {
+          stdout: "",
+          stderr: `${name}: ${error instanceof Error ? error.message : String(error)}`,
+          exitCode: 127
+        };
+      }
+    });
+  });
+}
+function resolveRealCwd(ctx) {
+  const fs2 = ctx.fs;
+  let realCwd;
+  if (fs2.root) {
+    realCwd = path4.join(fs2.root, ctx.cwd);
+  } else if (typeof fs2.getMountPoint === "function" && typeof fs2.toRealPath === "function") {
+    const real = fs2.toRealPath(ctx.cwd);
+    realCwd = real ?? process.cwd();
+  } else {
+    realCwd = process.cwd();
+  }
+  if (!existsSync3(realCwd)) {
+    realCwd = process.cwd();
+  }
+  return realCwd;
+}
+
+// packages/context/src/lib/sandbox/daytona-sandbox.ts
+import "bash-tool";
+import { randomUUID } from "node:crypto";
+var DAYTONA_DEFAULT_DESTINATION = "/home/daytona";
+var DAYTONA_EXIT_POLL_INTERVAL_MS = 250;
+var DAYTONA_EXIT_POLL_TIMEOUT_MS = 3e4;
+var DaytonaSandboxError = class extends Error {
+  constructor(message2, cause) {
+    super(message2);
+    this.name = "DaytonaSandboxError";
+    this.cause = cause;
+  }
+};
+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(client, options = {}) {
+  validateDaytonaOptions(options);
+  const sdk = await import("@daytona/sdk");
+  let sandbox;
+  try {
+    if (options.sandboxId !== void 0) {
+      sandbox = await client.get(options.sandboxId);
+      await startIfStopped(sandbox, options);
+    } else {
+      sandbox = await acquireReusedSandbox(client, options, sdk);
+    }
+  } catch (error) {
+    throw normalizeDaytonaError(error, sdk);
+  }
+  const backend = createDaytonaSandboxMethods({
+    sandbox,
+    commandTimeout: options.commandTimeout
+  });
+  if (options.readiness) {
+    try {
+      await options.readiness(backend);
+    } catch (error) {
+      await backend.dispose().catch(() => {
+      });
+      throw error;
     }
   }
-  return [...dirs];
+  return backend;
 }
-function compactObject(input) {
-  const output = {};
-  for (const [key, value] of Object.entries(input)) {
-    if (value !== void 0) {
-      output[key] = value;
+var UNRECOVERABLE_SANDBOX_STATES = /* @__PURE__ */ new Set([
+  "error",
+  "build_failed",
+  "destroyed"
+]);
+async function acquireReusedSandbox(client, options, sdk) {
+  let existing;
+  try {
+    existing = await client.get(options.name);
+  } catch (error) {
+    if (error instanceof sdk.DaytonaNotFoundError) {
+      return createSandbox(client, options);
     }
+    throw error;
   }
-  return output;
+  if (existing.state && UNRECOVERABLE_SANDBOX_STATES.has(existing.state)) {
+    await deleteSandboxQuietly(existing, options);
+    return createSandbox(client, options);
+  }
+  await startIfStopped(existing, options);
+  return existing;
 }
-function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
+async function deleteSandboxQuietly(sandbox, options) {
+  try {
+    await sandbox.delete(options.deleteTimeout);
+  } catch {
+  }
 }
-
-// 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;
+async function startIfStopped(sandbox, options) {
+  if (sandbox.state && sandbox.state !== "started") {
+    await sandbox.start(options.startTimeout ?? options.createTimeout);
   }
-};
-var DockerNotAvailableError = class extends DockerSandboxError {
-  constructor() {
-    super("Docker is not available. Ensure Docker daemon is running.");
-    this.name = "DockerNotAvailableError";
+}
+function normalizeDaytonaError(error, sdk) {
+  const err = toError(error);
+  if (err instanceof sdk.DaytonaError) {
+    return err;
   }
-};
-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;
+  return new DaytonaCreationError(err.message, err);
+}
+function createSandbox(client, 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 !== void 0) {
+    const params2 = compactObject({
+      ...base,
+      image: options.image,
+      resources: options.resources
+    });
+    return client.create(params2, {
+      timeout: options.createTimeout,
+      onSnapshotCreateLogs: options.onSnapshotCreateLogs
+    });
   }
-};
-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
+  const params = compactObject({
+    ...base,
+    snapshot: options.snapshot
+  });
+  return client.create(params, { timeout: options.createTimeout });
+}
+function validateDaytonaOptions(options) {
+  if (options.image && options.snapshot) {
+    throw new DaytonaSandboxError(
+      'Daytona sandbox options cannot include both "image" and "snapshot". Choose one environment source.'
     );
-    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
+  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.'
     );
-    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}`
+  if (options.sandboxId === void 0 && options.name === void 0) {
+    throw new DaytonaSandboxError(
+      'Daytona sandbox options require "name" (get-or-create) or "sandboxId" (attach). An unnamed sandbox cannot be reclaimed, since dispose() does not delete it.'
     );
-    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;
+  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(", ")}`
+    );
   }
-};
-
-// packages/context/src/lib/sandbox/installers/installer.ts
-import "bash-tool";
-import spawn2 from "nano-spawn";
-var Installer = class {
-};
-function isDebianBased(image) {
-  const lower = image.toLowerCase();
-  if (lower.includes("alpine")) return false;
-  const debianPatterns = ["debian", "ubuntu", "node", "python"];
-  return debianPatterns.some((pattern) => lower.includes(pattern));
 }
-function createInstallerContext(containerId, image) {
-  const packageManager = isDebianBased(image) ? "apt-get" : "apk";
-  let archPromise = null;
-  const ensuredTools = /* @__PURE__ */ new Set();
-  let aptUpdated = false;
-  const exec = async (command) => {
+function createDaytonaSandboxMethods(args) {
+  const { sandbox, commandTimeout } = args;
+  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 {
-      const result = await spawn2("docker", [
-        "exec",
-        containerId,
-        "sh",
-        "-c",
-        command
-      ]);
-      return { stdout: result.stdout, stderr: result.stderr, exitCode: 0 };
+      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 ?? "",
+        stderr: err.stderr ?? err.message ?? String(error),
         exitCode: err.exitCode ?? 1
       };
+    } finally {
+      options?.signal?.removeEventListener("abort", abort);
     }
   };
-  const arch = async () => {
-    if (!archPromise) {
-      const attempt = (async () => {
-        const result = await exec("uname -m");
-        if (result.exitCode !== 0) {
-          throw new DockerSandboxError(
-            `Failed to detect container architecture: ${result.stderr}`,
-            containerId
-          );
-        }
-        return result.stdout.trim();
-      })();
-      archPromise = attempt.catch((err) => {
-        archPromise = null;
-        throw err;
+  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 ${shellQuote(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() {
+    },
+    [Symbol.asyncDispose]() {
+      return this.dispose();
     }
-    return archPromise;
-  };
-  const installPackages = async (packages) => {
-    if (packages.length === 0) return;
-    const quoted = packages.map(shellQuote).join(" ");
-    let cmd;
-    if (packageManager === "apt-get") {
-      cmd = aptUpdated ? `apt-get install -y ${quoted}` : `apt-get update && apt-get install -y ${quoted}`;
-    } else {
-      cmd = `apk add --no-cache ${quoted}`;
-    }
-    const result = await exec(cmd);
-    if (result.exitCode !== 0) {
-      throw new PackageInstallError(
-        packages,
-        image,
-        packageManager,
-        result.stderr,
-        containerId
-      );
-    }
-    if (packageManager === "apt-get") aptUpdated = true;
-  };
-  const ensureTool = async (checkName, installName) => {
-    const cacheKey = installName ?? checkName;
-    if (ensuredTools.has(cacheKey)) return;
-    const check = await exec(`which ${shellQuote(checkName)}`);
-    if (check.exitCode === 0) {
-      ensuredTools.add(cacheKey);
-      return;
-    }
-    await installPackages([installName ?? checkName]);
-    ensuredTools.add(cacheKey);
   };
+}
+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 {
-    containerId,
-    image,
-    packageManager,
-    arch,
-    exec,
-    installPackages,
-    ensureTool
+    stdout: stdout.stream,
+    stderr: stderr.stream,
+    exit
   };
 }
-
-// packages/context/src/lib/sandbox/docker-sandbox.ts
-function isDockerfileOptions(opts) {
-  return "dockerfile" in opts;
-}
-function isComposeOptions(opts) {
-  return "compose" in opts;
-}
-var CONTAINER_NAME_PATTERN = /^[A-Za-z0-9_.-]+$/;
-var DockerSandboxStrategy = class {
-  context;
-  volumes;
-  resources;
-  env;
-  name;
-  command;
-  securityOpt;
-  platform;
-  createdVolumes = /* @__PURE__ */ new Set();
-  constructor(args = {}) {
-    const {
-      volumes = [],
-      resources = {},
-      env = {},
-      name,
-      command,
-      securityOpt = [],
-      platform
-    } = args;
-    for (const key of Object.keys(env)) {
-      validateEnvKey2(key);
-    }
-    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;
-    this.command = command;
-    this.securityOpt = securityOpt;
-    this.platform = platform;
-  }
-  async create() {
-    const image = await this.getImage();
-    let acquired;
-    try {
-      acquired = await this.acquireContainer(image);
-      this.context = { containerId: acquired.containerId, image };
-      if (!acquired.attached) {
-        await this.configure();
-      }
-    } catch (error) {
-      if (acquired && !acquired.attached) {
-        await this.stopContainer(acquired.containerId);
-      }
-      await this.cleanupCreatedVolumesAfterFailure(error);
-      throw error;
+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(() => {
+      });
     }
-    return this.createSandboxMethods();
-  }
-  namedContainerId() {
-    return `sandbox-${this.name}`;
-  }
-  defaultContainerId() {
-    return `sandbox-${crypto.randomUUID().slice(0, 8)}`;
+  };
+  if (signal) {
+    if (signal.aborted) abort();
+    else signal.addEventListener("abort", abort, { once: true });
   }
-  async acquireContainer(image) {
-    if (!this.name) {
-      const containerId2 = this.defaultContainerId();
-      await this.prepareVolumes();
-      await this.startContainer(image, containerId2);
-      return { containerId: containerId2, attached: false };
+  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."
+      );
     }
-    const containerId = this.namedContainerId();
-    const probe = await this.inspectContainer(containerId);
-    if (probe === "running") {
-      return { containerId, attached: true };
+    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();
     }
-    if (probe === "stopped") {
-      await this.startStoppedContainer(containerId, image);
-      return { containerId, attached: true };
+    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);
     }
-    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;
+    stdout.close();
+    stderr.close();
+    if (sessionCreated) {
+      await sandbox.process.deleteSession(sessionId).catch(() => {
+      });
     }
   }
-  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 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);
   }
-  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";
+}
+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;
       }
-      throw new DockerSandboxError(
-        `Failed to inspect container "${containerId}": ${message2}`
-      );
+    }),
+    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 ${shellQuote(options.cwd)} && ` : "";
+  const env = options.env ?? {};
+  const entries = Object.entries(env);
+  if (entries.length === 0) {
+    return `sh -lc ${shellQuote(`${cwdPrefix}${command}`)}`;
   }
-  isMissingContainerError(message2) {
-    return message2.toLowerCase().includes("no such container");
+  for (const [key] of entries) {
+    validateEnvKey(key);
   }
-  isNameConflictError(message2) {
-    return message2.toLowerCase().includes("is already in use by container");
+  const exports = entries.map(([key, value]) => `export ${key}=${shellQuote(value)}`).join("; ");
+  return `sh -lc ${shellQuote(`${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.`
+    );
   }
-  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);
-      }
+}
+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 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));
     }
   }
-  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"'
-          );
-        }
-      }
+  return [...dirs];
+}
+function compactObject(input) {
+  const output = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (value !== void 0) {
+      output[key] = value;
     }
   }
-  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`
+  return output;
+}
+function toError(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+// packages/context/src/lib/sandbox/docker-sandbox.ts
+import "bash-tool";
+import spawn5 from "nano-spawn";
+import { spawn as childSpawn3 } from "node:child_process";
+import { createHash as createHash2 } from "node:crypto";
+import { readFileSync as readFileSync3 } from "node:fs";
+function isDockerfileOptions(opts) {
+  return "dockerfile" in opts;
+}
+function isComposeOptions(opts) {
+  return "compose" in opts;
+}
+function dockerMountArg(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(",");
+}
+function runDockerBuild(args, stdin, showBuildLogs) {
+  const stdio = [
+    stdin === void 0 ? "inherit" : "pipe",
+    showBuildLogs ? "inherit" : "ignore",
+    showBuildLogs ? "inherit" : "pipe"
+  ];
+  return new Promise((resolve4, reject) => {
+    const child = childSpawn3("docker", args, { stdio });
+    let stderr = "";
+    child.stderr?.on("data", (chunk) => {
+      stderr += chunk;
+    });
+    child.once(
+      "error",
+      (error) => reject(new DockerfileBuildError(error.message))
     );
-  }
-  buildDockerArgs(image, containerId) {
-    const { memory = "1g", cpus = 2 } = this.resources;
+    child.once("exit", (code) => {
+      if (code === 0) {
+        resolve4();
+        return;
+      }
+      reject(
+        new DockerfileBuildError(
+          showBuildLogs ? `docker build exited with code ${code} (see build output above)` : stderr || `docker build exited with code ${code}`
+        )
+      );
+    });
+    if (stdin !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(stdin);
+    }
+  });
+}
+var dockerEngine = {
+  cli: "docker",
+  runArgs(image, containerId, opts, workdir) {
+    const {
+      memory = "1g",
+      cpus = 2,
+      memorySwap,
+      shmSize,
+      pidsLimit,
+      ulimits = [],
+      cpusetCpus,
+      cpuShares
+    } = opts.resources ?? {};
+    const security = opts.security ?? {};
+    const network = opts.network ?? {};
     const args = [
       "run",
       "-d",
       "--rm",
       "--name",
       containerId,
-      `--memory=${memory}`,
-      `--cpus=${cpus}`,
+      "--memory",
+      memory,
+      "--cpus",
+      String(cpus),
       "-w",
-      "/workspace"
+      workdir
     ];
-    if (this.platform) {
-      args.push("--platform", this.platform);
+    if (memorySwap) {
+      args.push("--memory-swap", memorySwap);
     }
-    for (const opt of this.securityOpt) {
+    if (shmSize) {
+      args.push("--shm-size", shmSize);
+    }
+    if (pidsLimit !== void 0) {
+      args.push("--pids-limit", String(pidsLimit));
+    }
+    for (const ulimit of ulimits) {
+      args.push("--ulimit", ulimit);
+    }
+    if (cpusetCpus) {
+      args.push("--cpuset-cpus", cpusetCpus);
+    }
+    if (cpuShares !== void 0) {
+      args.push("--cpu-shares", String(cpuShares));
+    }
+    if (opts.platform) {
+      args.push("--platform", opts.platform);
+    }
+    if (opts.runtime) {
+      args.push("--runtime", opts.runtime);
+    }
+    for (const cap of security.capDrop ?? []) {
+      args.push("--cap-drop", cap);
+    }
+    for (const cap of security.capAdd ?? []) {
+      args.push("--cap-add", cap);
+    }
+    if (security.readOnly) {
+      args.push("--read-only");
+    }
+    if (security.user) {
+      args.push("--user", security.user);
+    }
+    for (const mount of security.tmpfs ?? []) {
+      args.push("--tmpfs", mount);
+    }
+    for (const opt of security.securityOpt ?? []) {
       args.push("--security-opt", opt);
     }
-    for (const [key, value] of Object.entries(this.env)) {
-      args.push("-e", `${key}=${value}`);
+    if (network.mode) {
+      args.push("--network", network.mode);
     }
-    for (const volume of this.volumes) {
-      args.push("--mount", this.buildVolumeMountArg(volume));
+    for (const port of network.publish ?? []) {
+      args.push("--publish", port);
     }
-    args.push(image);
-    if (this.command === void 0) {
-      args.push("tail", "-f", "/dev/null");
-    } else if (this.command !== null) {
-      args.push(...this.command);
+    for (const server of network.dns ?? []) {
+      args.push("--dns", server);
     }
-    return args;
-  }
-  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");
+    for (const host of network.addHost ?? []) {
+      args.push("--add-host", host);
     }
-    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);
+    if (network.hostname) {
+      args.push("--hostname", network.hostname);
     }
-  }
-  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;
+    if (opts.gpus) {
+      args.push("--gpus", opts.gpus);
     }
-  }
-  async createVolume(volume) {
-    const args = ["volume", "create"];
-    if (volume.driver) {
-      args.push("--driver", volume.driver);
+    for (const device of opts.devices ?? []) {
+      args.push("--device", device);
     }
-    for (const [key, value] of Object.entries(volume.driverOptions ?? {})) {
-      args.push("--opt", `${key}=${value}`);
+    if (opts.init) {
+      args.push("--init");
     }
-    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);
+    for (const [key, value] of Object.entries(opts.labels ?? {})) {
+      args.push("--label", `${key}=${value}`);
     }
-  }
-  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);
-      }
+    for (const [key, value] of Object.entries(opts.sysctls ?? {})) {
+      args.push("--sysctl", `${key}=${value}`);
     }
-  }
-  async cleanupCreatedVolumesAfterFailure(originalError) {
-    try {
-      await this.cleanupCreatedVolumes();
-    } catch (cleanupError) {
-      if (originalError instanceof Error) {
-        const original = originalError;
-        original.suppressed = [...original.suppressed ?? [], cleanupError];
-      }
+    if (opts.entrypoint) {
+      args.push("--entrypoint", opts.entrypoint);
     }
-  }
-  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);
-    } catch (error) {
-      const err = error;
-      if (err.message?.includes("Cannot connect") || err.message?.includes("docker daemon") || err.stderr?.includes("Cannot connect")) {
-        throw new DockerNotAvailableError();
-      }
-      throw new ContainerCreationError(
-        this.getDockerErrorMessage(err),
-        image,
-        err
-      );
+    for (const [key, value] of Object.entries(opts.env ?? {})) {
+      args.push("-e", `${key}=${value}`);
     }
-  }
-  async stopContainer(containerId) {
-    try {
-      await spawn3("docker", ["stop", containerId]);
-    } catch {
+    for (const volume of opts.volumes ?? []) {
+      args.push("--mount", dockerMountArg(volume));
     }
-  }
-  async exec(command, options) {
-    try {
-      const result = await spawn3(
-        "docker",
-        ["exec", this.context.containerId, "sh", "-c", command],
-        { signal: options?.signal }
-      );
-      return {
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: 0
-      };
-    } catch (error) {
-      const err = error;
-      return {
-        stdout: err.stdout || "",
-        stderr: err.stderr || err.message || "",
-        exitCode: err.exitCode ?? 1
-      };
+    args.push(image);
+    if (opts.command === void 0) {
+      args.push("tail", "-f", "/dev/null");
+    } else if (opts.command !== null) {
+      args.push(...opts.command);
     }
-  }
-  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, 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) {
-          throw new Error(`Failed to read file "${path5}": ${result.stderr}`);
-        }
-        return Buffer.from(result.stdout, "base64").toString("utf-8");
-      },
-      writeFiles: async (files) => {
-        for (const file of files) {
-          const dir = file.path.substring(0, file.path.lastIndexOf("/"));
-          if (dir) {
-            await sandbox.executeCommand(`mkdir -p "${dir}"`);
-          }
-          const base64Content = Buffer.from(file.content).toString("base64");
-          const result = await sandbox.executeCommand(
-            `echo "${base64Content}" | base64 -d > "${file.path}"`
+    return args;
+  },
+  execArgs(containerId, command, options) {
+    const flags = [];
+    if (options?.cwd) {
+      flags.push("-w", options.cwd);
+    }
+    if (options?.env) {
+      for (const [key, value] of Object.entries(options.env)) {
+        if (key.length === 0 || key.includes("=")) {
+          throw new DockerSandboxError(
+            `Invalid environment variable key: "${key}"`
           );
-          if (result.exitCode !== 0) {
-            throw new Error(
-              `Failed to write file "${file.path}": ${result.stderr}`
-            );
-          }
         }
-      },
-      dispose: async () => {
-        await this.stopContainer(containerId);
-        await this.cleanupCreatedVolumes();
-      },
-      [Symbol.asyncDispose]() {
-        return this.dispose();
+        flags.push("-e", `${key}=${value}`);
       }
-    };
-    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({
-      volumes: args.volumes,
-      resources: args.resources,
-      env: args.env,
-      name: args.name,
-      command: args.command,
-      securityOpt: args.securityOpt,
-      platform: args.platform
-    });
-    this.image = args.image ?? "alpine:latest";
-    this.installers = args.installers ?? [];
-  }
-  async getImage() {
-    return this.image;
-  }
-  async configure() {
-    const ctx = createInstallerContext(this.context.containerId, this.image);
-    for (const installer of this.installers) {
-      await installer.install(ctx);
     }
-  }
-};
-var DockerfileStrategy = class extends DockerSandboxStrategy {
-  imageTag;
-  dockerfile;
-  dockerContext;
-  showBuildLogs;
-  constructor(args) {
-    super({
-      volumes: args.volumes,
-      resources: args.resources,
-      env: args.env,
-      name: args.name,
-      command: args.command,
-      securityOpt: args.securityOpt,
-      platform: args.platform
-    });
-    this.dockerfile = args.dockerfile;
-    this.dockerContext = args.context ?? ".";
-    this.showBuildLogs = args.showBuildLogs ?? false;
-    this.imageTag = this.computeImageTag();
-  }
-  computeImageTag() {
-    const content = this.isInlineDockerfile() ? this.dockerfile : readFileSync2(this.dockerfile, "utf-8");
-    const hash = createHash("sha256").update(content).update(this.platform ?? "").digest("hex").slice(0, 12);
-    return `sandbox-${hash}`;
-  }
-  isInlineDockerfile() {
-    return this.dockerfile.includes("\n");
-  }
-  async getImage() {
-    const exists = await this.imageExists();
-    if (!exists) {
-      await this.buildImage();
+    return ["exec", ...flags, containerId, "sh", "-c", command];
+  },
+  inspectArgs(containerId) {
+    return [
+      "container",
+      "inspect",
+      "--format",
+      "{{.State.Status}}",
+      containerId
+    ];
+  },
+  mountArg: dockerMountArg,
+  parseStatus(status) {
+    return status === "running" ? "running" : "stopped";
+  },
+  volumeCreateArgs(volume) {
+    const args = ["volume", "create"];
+    if (volume.driver) {
+      args.push("--driver", volume.driver);
     }
-    return this.imageTag;
-  }
-  async configure() {
-  }
-  async imageExists() {
+    for (const [key, value] of Object.entries(volume.driverOptions ?? {})) {
+      args.push("--opt", `${key}=${value}`);
+    }
+    args.push(volume.name);
+    return args;
+  },
+  errorMessage(error) {
+    const err = error;
+    return err.stderr || err.stdout || err.message || String(error);
+  },
+  isServiceDown(message2) {
+    return message2.includes("Cannot connect") || message2.includes("docker daemon");
+  },
+  isMissingContainer(message2) {
+    return message2.toLowerCase().includes("no such container");
+  },
+  isMissingVolume(message2) {
+    return message2.toLowerCase().includes("no such volume");
+  },
+  isNameConflict(message2) {
+    return message2.toLowerCase().includes("is already in use by container");
+  },
+  async ensureWorkdir() {
+  },
+  defaultImage: "alpine:latest",
+  createInstallerContext,
+  async imageExists(tag) {
     try {
-      await spawn3("docker", ["image", "inspect", this.imageTag]);
+      await spawn5("docker", ["image", "inspect", tag]);
       return true;
     } catch {
       return false;
     }
+  },
+  async buildImage(spec) {
+    const inline = spec.dockerfile.includes("\n");
+    const args = [
+      "build",
+      ...spec.identity ? ["--platform", spec.identity] : [],
+      "-t",
+      spec.tag,
+      "-f",
+      inline ? "-" : spec.dockerfile,
+      spec.context
+    ];
+    await runDockerBuild(
+      args,
+      inline ? spec.dockerfile : void 0,
+      spec.showBuildLogs
+    );
+  },
+  errors: {
+    serviceNotAvailable: () => new DockerNotAvailableError(),
+    creation: (message2, image, cause) => new ContainerCreationError(message2, image, cause),
+    generic: (message2, containerId) => new DockerSandboxError(message2, containerId),
+    volumePath: (source, containerPath, reason) => new VolumePathError(source, containerPath, reason),
+    volumeInspect: (name, reason) => new VolumeInspectError(name, reason),
+    volumeCreate: (name, reason) => new VolumeCreateError(name, reason),
+    volumeRemove: (name, reason) => new VolumeRemoveError(name, reason)
   }
-  async buildImage() {
-    try {
-      const platformFlag = this.platform ? `--platform ${this.platform} ` : "";
-      if (this.isInlineDockerfile()) {
-        const buildCmd = `echo '${this.dockerfile.replace(/'/g, "'\\''")}' | docker build ${platformFlag}-t ${this.imageTag} -f - ${this.dockerContext}`;
-        if (this.showBuildLogs) {
-          await this.runStreamed("sh", ["-c", buildCmd]);
-        } else {
-          await spawn3("sh", ["-c", buildCmd]);
-        }
-      } else {
-        const args = [
-          "build",
-          ...this.platform ? ["--platform", this.platform] : [],
-          "-t",
-          this.imageTag,
-          "-f",
-          this.dockerfile,
-          this.dockerContext
-        ];
-        if (this.showBuildLogs) {
-          await this.runStreamed("docker", args);
-        } else {
-          await spawn3("docker", args);
-        }
-      }
-    } catch (error) {
-      const err = error;
-      throw new DockerfileBuildError(err.stderr || err.message);
-    }
+};
+function validateEnvKey2(key) {
+  if (key.length === 0 || key.includes("=")) {
+    throw new DockerSandboxError(`Invalid environment variable key: "${key}"`);
   }
-  /**
-   * Run a build command with stdio inherited so its output streams live to the
-   * parent terminal. On failure the build error is already on screen; the
-   * rejection just carries the exit code.
-   */
-  runStreamed(command, args) {
-    return new Promise((resolve4, reject) => {
-      const child = childSpawn(command, args, { stdio: "inherit" });
-      child.once("error", reject);
-      child.once(
-        "exit",
-        (code) => code === 0 ? resolve4() : reject(
-          new Error(
-            `docker build exited with code ${code} (see build output above)`
-          )
-        )
-      );
-    });
+}
+function buildDockerExecFlags(options) {
+  const flags = [];
+  if (options?.cwd) {
+    flags.push("-w", options.cwd);
   }
-};
-var ComposeStrategy = class extends DockerSandboxStrategy {
+  if (options?.env) {
+    for (const [key, value] of Object.entries(options.env)) {
+      validateEnvKey2(key);
+      flags.push("-e", `${key}=${value}`);
+    }
+  }
+  return flags;
+}
+var ComposeStrategy = class extends ContainerSandboxStrategy {
   projectName;
   composeFile;
   service;
   constructor(args) {
-    super({ resources: args.resources });
+    super({ resources: args.resources }, dockerEngine);
     this.composeFile = args.compose;
     this.service = args.service;
     this.projectName = this.computeProjectName();
   }
   computeProjectName() {
-    const content = readFileSync2(this.composeFile, "utf-8");
-    const hash = createHash("sha256").update(content).digest("hex").slice(0, 8);
+    const content = readFileSync3(this.composeFile, "utf-8");
+    const hash = createHash2("sha256").update(content).digest("hex").slice(0, 8);
     return `sandbox-${hash}`;
   }
   async getImage() {
@@ -7950,7 +8536,7 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   }
   async startContainer(_image, _containerId) {
     try {
-      await spawn3("docker", [
+      await spawn5("docker", [
         "compose",
         "-f",
         this.composeFile,
@@ -7962,7 +8548,7 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
     } catch (error) {
       const err = error;
       if (err.stderr?.includes("Cannot connect")) {
-        throw new DockerNotAvailableError();
+        throw this.engine.errors.serviceNotAvailable();
       }
       throw new ComposeStartError(this.composeFile, err.stderr || err.message);
     }
@@ -7974,7 +8560,7 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   }
   async exec(command, options) {
     try {
-      const result = await spawn3(
+      const result = await spawn5(
         "docker",
         [
           "compose",
@@ -8002,7 +8588,7 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
     }
   }
   spawnProcess(command, options) {
-    const child = childSpawn("docker", [
+    const child = childSpawn3("docker", [
       "compose",
       "-f",
       this.composeFile,
@@ -8020,7 +8606,7 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   }
   async stopContainer(_containerId) {
     try {
-      await spawn3("docker", [
+      await spawn5("docker", [
         "compose",
         "-f",
         this.composeFile,
@@ -8033,40 +8619,25 @@ var ComposeStrategy = class extends DockerSandboxStrategy {
   }
 };
 async function createDockerSandbox(options = {}) {
-  let strategy;
   if (isComposeOptions(options)) {
-    strategy = new ComposeStrategy({
+    return new ComposeStrategy({
       compose: options.compose,
       service: options.service,
       resources: options.resources
-    });
-  } else if (isDockerfileOptions(options)) {
-    strategy = new DockerfileStrategy({
+    }).create();
+  }
+  if (isDockerfileOptions(options)) {
+    return new ContainerfileStrategy(options, dockerEngine, {
       dockerfile: options.dockerfile,
-      context: options.context,
-      showBuildLogs: options.showBuildLogs,
-      volumes: options.volumes,
-      resources: options.resources,
-      env: options.env,
-      name: options.name,
-      command: options.command,
-      securityOpt: options.securityOpt,
-      platform: options.platform
-    });
-  } else {
-    strategy = new RuntimeStrategy({
-      image: options.image,
-      installers: options.installers,
-      volumes: options.volumes,
-      resources: options.resources,
-      env: options.env,
-      name: options.name,
-      command: options.command,
-      securityOpt: options.securityOpt,
-      platform: options.platform
-    });
+      context: options.context ?? ".",
+      showBuildLogs: options.showBuildLogs ?? false,
+      identity: options.platform
+    }).create();
   }
-  return strategy.create();
+  return new RuntimeStrategy(options, dockerEngine, {
+    image: options.image ?? dockerEngine.defaultImage,
+    installers: options.installers ?? []
+  }).create();
 }
 async function useSandbox(options, fn) {
   const sandbox = await createDockerSandbox(options);
@@ -8082,6 +8653,7 @@ import { randomUUID as randomUUID2 } from "node:crypto";
 import { posix as posix2 } from "node:path";
 
 // packages/context/src/lib/sandbox/strace/index.ts
+import spawn6 from "nano-spawn";
 import { posix } from "node:path";
 var STRACE_FLAGS = "-f -y -qq -e trace=%file,write,pwrite64,writev";
 function buildStraceCommand(command, traceFile, traceDir) {
@@ -8696,6 +9268,359 @@ function formatVersion(version) {
   return /^[<>=!~]/.test(version) ? version : `==${version}`;
 }
 
+// packages/context/src/lib/sandbox/microsandbox-sandbox.ts
+import "bash-tool";
+import { randomUUID as randomUUID3 } from "node:crypto";
+var MICROSANDBOX_DEFAULT_DESTINATION = "/workspace";
+var MICROSANDBOX_DEFAULT_IMAGE = "alpine";
+var MICROSANDBOX_MAX_NAME_BYTES = 128;
+var COMMAND_TIMEOUT_EXIT_CODE = 124;
+var MicrosandboxSandboxError = class extends Error {
+  constructor(message2, cause) {
+    super(message2);
+    this.name = "MicrosandboxSandboxError";
+    this.cause = cause;
+  }
+};
+var MicrosandboxNotAvailableError = class extends MicrosandboxSandboxError {
+  constructor(cause) {
+    super(
+      "microsandbox is not installed or its runtime is unavailable. Install it with: npm install microsandbox (requires Node >= 22 and hardware virtualization: Apple silicon, Linux with KVM, or Windows with WHP)",
+      cause
+    );
+    this.name = "MicrosandboxNotAvailableError";
+  }
+};
+var MicrosandboxCreationError = class extends MicrosandboxSandboxError {
+  constructor(message2, cause) {
+    super(`Failed to create microsandbox: ${message2}`, cause);
+    this.name = "MicrosandboxCreationError";
+  }
+};
+var MicrosandboxCommandError = class extends MicrosandboxSandboxError {
+  constructor(message2, cause) {
+    super(message2, cause);
+    this.name = "MicrosandboxCommandError";
+  }
+};
+async function createMicrosandboxSandbox(options = {}) {
+  validateMicrosandboxOptions(options);
+  const sdk = await importMicrosandbox();
+  const ephemeral = options.name === void 0;
+  const name = options.name ?? `deepagents-msb-${randomUUID3()}`;
+  const workdir = options.workdir ?? MICROSANDBOX_DEFAULT_DESTINATION;
+  let vm;
+  try {
+    vm = await acquireSandbox(sdk, { ...options, name, ephemeral, workdir });
+    await vm.fs().mkdir(workdir);
+  } catch (error) {
+    throw normalizeMicrosandboxError(error, sdk);
+  }
+  const backend = createMicrosandboxMethods({
+    sdk,
+    vm,
+    name,
+    ephemeral,
+    commandTimeout: options.commandTimeout
+  });
+  if (options.readiness) {
+    try {
+      await options.readiness(backend);
+    } catch (error) {
+      await backend.dispose().catch(() => {
+      });
+      throw error;
+    }
+  }
+  return backend;
+}
+async function importMicrosandbox() {
+  try {
+    return await import("microsandbox");
+  } catch (error) {
+    throw new MicrosandboxNotAvailableError(toError2(error));
+  }
+}
+async function acquireSandbox(sdk, options) {
+  if (options.ephemeral || options.replace) {
+    return buildSandbox(sdk, options);
+  }
+  let handle;
+  try {
+    handle = await sdk.Sandbox.get(options.name);
+  } catch (error) {
+    if (error instanceof sdk.SandboxNotFoundError) {
+      return createFreshSandbox(sdk, options);
+    }
+    throw error;
+  }
+  if (handle.status === "running") {
+    return handle.connect();
+  }
+  if (handle.status === "draining") {
+    await handle.waitUntilStopped();
+  }
+  try {
+    return await handle.start();
+  } catch {
+    await sdk.Sandbox.remove(options.name).catch(() => {
+    });
+    return buildSandbox(sdk, options);
+  }
+}
+async function createFreshSandbox(sdk, options) {
+  try {
+    return await buildSandbox(sdk, options);
+  } catch (error) {
+    if (error instanceof sdk.SandboxAlreadyExistsError) {
+      const handle = await sdk.Sandbox.get(options.name);
+      return handle.status === "running" ? handle.connect() : handle.start();
+    }
+    throw error;
+  }
+}
+function buildSandbox(sdk, options) {
+  let builder = sdk.Sandbox.builder(options.name).image(options.image ?? MICROSANDBOX_DEFAULT_IMAGE).patch((patch) => patch.mkdir(options.workdir)).workdir(options.workdir);
+  if (options.ephemeral) builder = builder.ephemeral(true);
+  if (options.replace) builder = builder.replace();
+  if (options.cpus !== void 0) builder = builder.cpus(options.cpus);
+  if (options.memory !== void 0) builder = builder.memory(options.memory);
+  if (options.env) builder = builder.envs(options.env);
+  if (options.configure) builder = options.configure(builder);
+  return builder.create();
+}
+function normalizeMicrosandboxError(error, sdk) {
+  const err = toError2(error);
+  if (err instanceof sdk.LibkrunfwNotFoundError) {
+    return new MicrosandboxNotAvailableError(err);
+  }
+  if (err instanceof sdk.MicrosandboxError) {
+    return err;
+  }
+  return new MicrosandboxCreationError(err.message, err);
+}
+function validateMicrosandboxOptions(options) {
+  if (options.name !== void 0 && Buffer.byteLength(options.name, "utf-8") > MICROSANDBOX_MAX_NAME_BYTES) {
+    throw new MicrosandboxSandboxError(
+      `Microsandbox names are limited to ${MICROSANDBOX_MAX_NAME_BYTES} UTF-8 bytes.`
+    );
+  }
+  if (options.replace && options.name === void 0) {
+    throw new MicrosandboxSandboxError(
+      'Microsandbox options can only include "replace" together with "name" \u2014 an unnamed sandbox is always created fresh.'
+    );
+  }
+}
+function createMicrosandboxMethods(args) {
+  const { sdk, vm, name, ephemeral, commandTimeout } = args;
+  const spawn7 = (command, options = {}) => {
+    return spawnMicrosandboxProcess(sdk, vm, command, {
+      ...options,
+      commandTimeout
+    });
+  };
+  return {
+    // `executeCommand` lowers onto the same streaming pump as `spawn` so a
+    // single code path supports real cancellation. Cooperative abort (abandon
+    // the promise, Daytona-style) is not an option here: the SDK is an
+    // in-process native binding, so an abandoned exec keeps the guest process
+    // and its libuv handle alive.
+    async executeCommand(command, options) {
+      const proc = spawn7(command, { signal: options?.signal });
+      const [stdout, stderr, info] = await Promise.all([
+        readAllText(proc.stdout),
+        readAllText(proc.stderr),
+        proc.exit
+      ]);
+      if (info.signal === "SIGKILL") {
+        return abortedCommandResult2();
+      }
+      return { stdout, stderr, exitCode: info.code ?? 1 };
+    },
+    spawn: spawn7,
+    async readFile(path5) {
+      try {
+        return await vm.fs().readToString(path5);
+      } catch (error) {
+        throw new MicrosandboxCommandError(
+          `Failed to read file "${path5}": ${toError2(error).message}`,
+          toError2(error)
+        );
+      }
+    },
+    async writeFiles(files) {
+      try {
+        const fs2 = vm.fs();
+        for (const dir of uniqueParentDirectories2(files.map((f) => f.path))) {
+          await fs2.mkdir(dir);
+        }
+        for (const file of files) {
+          await fs2.write(file.path, file.content);
+        }
+      } catch (error) {
+        const err = toError2(error);
+        throw new MicrosandboxCommandError(
+          `Failed to write files: ${err.message}`,
+          err
+        );
+      }
+    },
+    async dispose() {
+      try {
+        await vm.stop();
+      } catch {
+      }
+      if (ephemeral) {
+        await sdk.Sandbox.remove(name).catch(() => {
+        });
+      }
+    },
+    [Symbol.asyncDispose]() {
+      return this.dispose();
+    }
+  };
+}
+function spawnMicrosandboxProcess(sdk, vm, command, options) {
+  const stdout = createByteReadable();
+  const stderr = createByteReadable();
+  const exit = pumpExecStream({ sdk, vm, command, options, stdout, stderr });
+  return { stdout: stdout.stream, stderr: stderr.stream, exit };
+}
+async function pumpExecStream(args) {
+  const { sdk, vm, command, options, stdout, stderr } = args;
+  const { signal } = options;
+  let handle;
+  let aborted = signal?.aborted ?? false;
+  let timedOut = false;
+  let timeoutTimer;
+  const abort = () => {
+    aborted = true;
+    handle?.kill().catch(() => {
+    });
+  };
+  if (aborted) {
+    stdout.close();
+    stderr.close();
+    return abortedExitInfo2();
+  }
+  signal?.addEventListener("abort", abort, { once: true });
+  try {
+    handle = await vm.execStreamWith("sh", (builder) => {
+      builder.args(["-lc", command]).stdinNull();
+      if (options.cwd) builder.cwd(options.cwd);
+      if (options.env) builder.envs(options.env);
+      return builder;
+    });
+    if (aborted) {
+      return abortedExitInfo2();
+    }
+    if (options.commandTimeout) {
+      const startedHandle = handle;
+      timeoutTimer = setTimeout(() => {
+        timedOut = true;
+        startedHandle.kill().catch(() => {
+        });
+      }, options.commandTimeout);
+      timeoutTimer.unref();
+    }
+    let code = null;
+    for await (const event of handle) {
+      if (event.kind === "stdout") stdout.enqueue(event.data);
+      else if (event.kind === "stderr") stderr.enqueue(event.data);
+      else if (event.kind === "exited") code = event.code;
+    }
+    if (aborted) {
+      return abortedExitInfo2();
+    }
+    if (timedOut) {
+      stderr.enqueue(new TextEncoder().encode("Command timed out"));
+      return { code: COMMAND_TIMEOUT_EXIT_CODE, signal: null, success: false };
+    }
+    return { code, signal: null, success: code === 0 };
+  } catch (error) {
+    if (aborted) {
+      return abortedExitInfo2();
+    }
+    if (timedOut || error instanceof sdk.ExecTimeoutError) {
+      stderr.enqueue(new TextEncoder().encode("Command timed out"));
+      return { code: COMMAND_TIMEOUT_EXIT_CODE, signal: null, success: false };
+    }
+    const err = toError2(error);
+    stdout.error(err);
+    stderr.error(err);
+    throw err;
+  } finally {
+    clearTimeout(timeoutTimer);
+    signal?.removeEventListener("abort", abort);
+    stdout.close();
+    stderr.close();
+    await handle?.[Symbol.asyncDispose]();
+  }
+}
+function createByteReadable() {
+  let controller;
+  let closed = false;
+  return {
+    stream: new ReadableStream({
+      start(streamController) {
+        controller = streamController;
+      },
+      cancel() {
+        closed = true;
+      }
+    }),
+    enqueue(chunk) {
+      if (closed || chunk.length === 0) return;
+      controller?.enqueue(chunk);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      controller?.close();
+    },
+    error(error) {
+      if (closed) return;
+      closed = true;
+      controller?.error(error);
+    }
+  };
+}
+async function readAllText(stream) {
+  const decoder2 = new TextDecoder();
+  let text = "";
+  for await (const chunk of stream) {
+    text += decoder2.decode(chunk, { stream: true });
+  }
+  return text + decoder2.decode();
+}
+function abortedCommandResult2() {
+  return {
+    stdout: "",
+    stderr: "Command aborted",
+    exitCode: 1
+  };
+}
+function abortedExitInfo2() {
+  return {
+    code: null,
+    signal: "SIGKILL",
+    success: false
+  };
+}
+function uniqueParentDirectories2(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 toError2(error) {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
 // packages/context/src/lib/sandbox/subcommand.ts
 import {
   defineCommand as defineCommand2,
@@ -8777,7 +9702,7 @@ async function createVirtualSandbox(options) {
     env: options.env,
     customCommands: options.customCommands
   });
-  return {
+  const sandbox = {
     async executeCommand(command, options2) {
       const result = await bash.exec(
         command,
@@ -8806,6 +9731,16 @@ async function createVirtualSandbox(options) {
       return this.dispose();
     }
   };
+  if (options.readiness) {
+    try {
+      await options.readiness(sandbox);
+    } catch (error) {
+      await sandbox.dispose().catch(() => {
+      });
+      throw error;
+    }
+  }
+  return sandbox;
 }
 
 // packages/context/src/lib/skills/fragments.ts
@@ -12005,6 +12940,13 @@ export {
   AgentOsCreationError,
   AgentOsNotAvailableError,
   AgentOsSandboxError,
+  AppleContainerCreationError,
+  AppleContainerImageBuildError,
+  AppleContainerSandboxError,
+  AppleContainerVolumeCreateError,
+  AppleContainerVolumeInspectError,
+  AppleContainerVolumePathError,
+  AppleContainerVolumeRemoveError,
   AsyncResolver,
   BM25Classifier,
   BashException,
@@ -12012,6 +12954,10 @@ export {
   ComposeStartError,
   ComposeStrategy,
   ContainerCreationError,
+  ContainerSandboxError,
+  ContainerSandboxStrategy,
+  ContainerServiceNotRunningError,
+  ContainerfileStrategy,
   ContextEngine,
   ContextRenderer,
   ContextStore,
@@ -12023,9 +12969,7 @@ export {
   DaytonaSandboxError,
   DockerNotAvailableError,
   DockerSandboxError,
-  DockerSandboxStrategy,
   DockerfileBuildError,
-  DockerfileStrategy,
   FragmentLoaderResolver,
   FunctionResolver,
   GeneratorResolver,
@@ -12035,7 +12979,12 @@ export {
   Installer,
   IterableResolver,
   LOCALE_METADATA_KEY,
+  MICROSANDBOX_DEFAULT_DESTINATION,
   MarkdownRenderer,
+  MicrosandboxCommandError,
+  MicrosandboxCreationError,
+  MicrosandboxNotAvailableError,
+  MicrosandboxSandboxError,
   MissingRuntimeError,
   ModelsRegistry,
   NpmInstaller,
@@ -12072,6 +13021,7 @@ export {
   analogy,
   and,
   anyToolCalled,
+  appleEngine,
   applyInlineReminder,
   applyPartReminder,
   applyReminderToMessage,
@@ -12095,11 +13045,13 @@ export {
   correction,
   createAdaptivePollingState,
   createAgentOsSandbox,
+  createAppleContainerSandbox,
   createBashTool,
   createBinaryBridges,
   createDaytonaSandbox,
   createDockerSandbox,
   createInstallerContext,
+  createMicrosandboxSandbox,
   createRepairToolCall,
   createVirtualSandbox,
   dateReminder,
@@ -12110,6 +13062,7 @@ export {
   defineSubcommandGroup,
   discoverSkillMappings,
   discoverSkillsInDirectory,
+  dockerEngine,
   downloadAndInstall,
   elapsedExceeds,
   encodeSerializedValue,
@@ -12138,6 +13091,7 @@ export {
   hint,
   hourChanged,
   identity,
+  isAppleContainerfileOptions,
   isComposeOptions,
   isConditionalReminder,
   isDebianBased,
@@ -12182,7 +13136,6 @@ export {
   resetAdaptivePolling,
   resolveReminder,
   resolveReminderAsync,
-  resolveReminderText,
   resolveTz,
   role,
   runGuardrailChain,
@@ -12208,6 +13161,7 @@ export {
   timeReminder,
   toFragment,
   toMessageFragment,
+  toToolReminderModelOutput,
   toolCall,
   toolCallCount,
   toolCalled,
@@ -12216,6 +13170,7 @@ export {
   urlBinary,
   usageExceeds,
   useAgentOsSandbox,
+  useAppleContainerSandbox,
   useBashMeta,
   useSandbox,
   user,