@deepagents/context 4.1.0 → 4.2.0

package/dist/index.js

@@ -1595,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(
@@ -1672,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(
@@ -1932,7 +1934,10 @@ function wrapToolsWithOutputReminders(tools, context) {
       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({
@@ -3916,6 +3921,10 @@ var ContextEngine = class _ContextEngine {
    * return the (possibly wrapped) output.
    *
    * 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`.
    *
@@ -3924,17 +3933,22 @@ var ContextEngine = class _ContextEngine {
    * (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,
@@ -6132,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 };
@@ -6219,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);
@@ -6672,7 +6697,17 @@ var ContainerSandboxStrategy = class {
       await this.cleanupCreatedVolumesAfterFailure(error);
       throw error;
     }
-    return this.createSandboxMethods();
+    const sandbox = this.createSandboxMethods();
+    if (this.opts.readiness) {
+      try {
+        await this.opts.readiness(sandbox);
+      } catch (error) {
+        await sandbox.dispose().catch(() => {
+        });
+        throw error;
+      }
+    }
+    return sandbox;
   }
   namedContainerId() {
     return `sandbox-${this.name}`;
@@ -7045,15 +7080,13 @@ function isAppleContainerfileOptions(opts) {
 }
 function buildMountArg(volume) {
   const readOnly = volume.readOnly !== false;
-  const parts = volume.type === "bind" ? [
+  if (volume.type === "volume") {
+    return `${volume.name}:${volume.containerPath}${readOnly ? ":ro" : ""}`;
+  }
+  const parts = [
     "type=bind",
     `source=${volume.hostPath}`,
     `target=${volume.containerPath}`
-  ] : [
-    // Named volumes mount as virtiofs; `container` has no `type=volume`.
-    "type=virtiofs",
-    `source=${volume.name}`,
-    `target=${volume.containerPath}`
   ];
   if (readOnly) {
     parts.push("readonly");
@@ -7073,8 +7106,9 @@ function safeParseArray(stdout) {
   }
 }
 function readContainerStatus(entry) {
+  const raw = entry?.status;
   const status = String(
-    entry?.status ?? ""
+    (typeof raw === "object" && raw !== null ? raw.state : raw) ?? ""
   ).toLowerCase();
   if (status === "running" || status === "booted") return "running";
   if (status === "stopped") return "stopped";
@@ -7104,7 +7138,10 @@ var appleEngine = {
       args.push("--env", `${key}=${value}`);
     }
     for (const volume of opts.volumes ?? []) {
-      args.push("--mount", buildMountArg(volume));
+      args.push(
+        volume.type === "volume" ? "--volume" : "--mount",
+        buildMountArg(volume)
+      );
     }
     args.push(image);
     if (opts.command === void 0) {
@@ -7356,12 +7393,6 @@ function useBashMeta() {
   return {
     setHidden(patch) {
       state.hidden = { ...state.hidden, ...patch };
-    },
-    setReminder(text) {
-      state.reminder = text;
-    },
-    clearReminder() {
-      state.reminder = void 0;
     }
   };
 }
@@ -7571,14 +7602,8 @@ async function createBashTool(options) {
           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 } : {}
-          };
+          if (Object.keys(state.hidden).length === 0) return result;
+          return { ...result, meta: state.hidden };
         })
       );
     },
@@ -7752,10 +7777,20 @@ async function createDaytonaSandbox(client, options = {}) {
   } catch (error) {
     throw normalizeDaytonaError(error, sdk);
   }
-  return createDaytonaSandboxMethods({
+  const backend = createDaytonaSandboxMethods({
     sandbox,
     commandTimeout: options.commandTimeout
   });
+  if (options.readiness) {
+    try {
+      await options.readiness(backend);
+    } catch (error) {
+      await backend.dispose().catch(() => {
+      });
+      throw error;
+    }
+  }
+  return backend;
 }
 var UNRECOVERABLE_SANDBOX_STATES = /* @__PURE__ */ new Set([
   "error",
@@ -9233,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,
@@ -9314,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,
@@ -9343,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
@@ -12581,7 +12979,12 @@ export {
   Installer,
   IterableResolver,
   LOCALE_METADATA_KEY,
+  MICROSANDBOX_DEFAULT_DESTINATION,
   MarkdownRenderer,
+  MicrosandboxCommandError,
+  MicrosandboxCreationError,
+  MicrosandboxNotAvailableError,
+  MicrosandboxSandboxError,
   MissingRuntimeError,
   ModelsRegistry,
   NpmInstaller,
@@ -12618,6 +13021,7 @@ export {
   analogy,
   and,
   anyToolCalled,
+  appleEngine,
   applyInlineReminder,
   applyPartReminder,
   applyReminderToMessage,
@@ -12647,6 +13051,7 @@ export {
   createDaytonaSandbox,
   createDockerSandbox,
   createInstallerContext,
+  createMicrosandboxSandbox,
   createRepairToolCall,
   createVirtualSandbox,
   dateReminder,