@deepagents/context 6.0.0 → 6.1.2

package/README.md

@@ -32,6 +32,8 @@ with `createVirtualSandbox()`, `createDockerSandbox()`,
 `createDaytonaSandbox(client, options)`, or `createAgentOsSandbox()` depending
 on whether commands should run in memory, Docker, Apple Container lightweight
 VMs, Microsandbox microVMs, managed Daytona sandboxes, or Agent OS.
+Virtual sandboxes can opt into in-process JavaScript execution with
+`createVirtualSandbox({ javascript: true, ... })`.
 
 See the docs for the full API surface:
 
@@ -315,8 +317,9 @@ points.
 For `target: 'tool-output'`, use `toolOutput(...)` or inspect
 `ctx.toolOutcome`. The outcome is available after a tool reaches
 `output-available`, `output-error`, or `output-denied`, but before the next model
-generation. Assistant-history predicates such as `toolCalled(...)` only
-describe already persisted calls.
+generation. Assistant-history predicates such as `toolCalled(...)` describe
+tool parts visible in the current assistant segment; use `toolOutput(...)` when
+you need the raw outcome currently being evaluated.
 
 ```ts
 import {

package/dist/index.js

@@ -840,6 +840,7 @@ import { getErrorMessage } from "@ai-sdk/provider";
 import {
   convertToModelMessages as convertToModelMessages2,
   generateId as generateId5,
+  isStaticToolUIPart as isStaticToolUIPart2,
   validateUIMessages
 } from "ai";
 
@@ -3959,6 +3960,58 @@ function toolOutcomesFromStep(content) {
   }
   return outcomes;
 }
+function terminalToolPartsFromStep(content) {
+  return content.flatMap((part) => {
+    if (part.type === "tool-result" && part.dynamic !== true) {
+      return [
+        {
+          type: `tool-${part.toolName}`,
+          toolCallId: part.toolCallId,
+          state: "output-available",
+          input: part.input,
+          output: part.output === void 0 ? null : part.output
+        }
+      ];
+    }
+    if (part.type === "tool-error" && part.dynamic !== true) {
+      return [
+        {
+          type: `tool-${part.toolName}`,
+          toolCallId: part.toolCallId,
+          state: "output-error",
+          input: part.input,
+          errorText: getErrorMessage(part.error)
+        }
+      ];
+    }
+    if (part.type === "tool-approval-response" && part.approved === false && part.toolCall.dynamic !== true) {
+      return [
+        {
+          type: `tool-${part.toolCall.toolName}`,
+          toolCallId: part.toolCall.toolCallId,
+          state: "output-denied",
+          input: part.toolCall.input,
+          approval: {
+            id: part.approvalId,
+            approved: false,
+            ...part.reason === void 0 ? {} : { reason: part.reason }
+          }
+        }
+      ];
+    }
+    return [];
+  });
+}
+function mergeTerminalToolParts(message2, liveParts) {
+  const remaining = new Map(liveParts);
+  const parts = message2.parts.map((part) => {
+    if (!isStaticToolUIPart2(part)) return part;
+    remaining.delete(part.toolCallId);
+    return part;
+  });
+  parts.push(...remaining.values());
+  return { ...message2, parts };
+}
 var ContextEngine = class _ContextEngine {
   /** Non-message fragments (role, hints, etc.) - not persisted in graph */
   #fragments = [];
@@ -4371,12 +4424,24 @@ var ContextEngine = class _ContextEngine {
     const enableSteer = options.steer ?? true;
     const session = {
       firedOnceIds: /* @__PURE__ */ new Set(),
-      currentSegStart: 0
+      terminalToolParts: /* @__PURE__ */ new Map(),
+      segments: [],
+      initialStepStarts: null,
+      stepOffset: 0,
+      lastStepNumber: null
     };
     this.#currentReminderSession = session;
     return async ({ steps, stepNumber, messages }) => {
+      if (stepNumber === 0 && session.lastStepNumber !== null) {
+        session.stepOffset += session.lastStepNumber + 1;
+      }
+      session.lastStepNumber = stepNumber;
+      const completedSteps = session.stepOffset + stepNumber;
       const priorStep = stepNumber >= 1 ? steps[stepNumber - 1] : void 0;
       const hasSafeBoundary = (priorStep?.content?.length ?? 0) > 0;
+      for (const part of terminalToolPartsFromStep(priorStep?.content ?? [])) {
+        session.terminalToolParts.set(part.toolCallId, part);
+      }
       const canFire = enableSteer && hasSafeBoundary;
       const steerConfigs = canFire ? this.#remindersFor("steer") : [];
       const outcomes = toolOutcomesFromStep(steps.at(-1)?.content ?? []);
@@ -4435,18 +4500,24 @@ var ContextEngine = class _ContextEngine {
             "createPrepareStep: expected an assistant message at chain head."
           );
         }
-        const currentSegmentId = session.currentSegId ?? head.id;
+        const currentSegmentId = head.id;
         const currentSegment = await this.#store.getMessage(currentSegmentId);
         if (!currentSegment || currentSegment.name !== "assistant") {
           throw new Error(
             "createPrepareStep: expected the open assistant segment to be persisted."
           );
         }
-        const currentMessage = requireUIMessage(
+        requireUIMessage(
           currentSegment.data,
           `Stored assistant message "${currentSegment.id}"`
         );
         const nextSegmentId = generateId5();
+        if (session.segments.length === 0) {
+          session.segments.push({
+            id: currentSegmentId,
+            startStep: 0
+          });
+        }
         for (const input of inputs) this.set(user(input));
         this.set(
           assistant({
@@ -4456,8 +4527,11 @@ var ContextEngine = class _ContextEngine {
           })
         );
         await this.save({ branch: false });
-        session.currentSegId = nextSegmentId;
-        session.currentSegStart += currentMessage.parts.length;
+        session.segments.push({
+          id: nextSegmentId,
+          startStep: completedSteps
+        });
+        session.terminalToolParts.clear();
         return {
           messages: [...messages, ...inputModel]
         };
@@ -4482,14 +4556,81 @@ var ContextEngine = class _ContextEngine {
       );
     }
     const session = this.#currentReminderSession;
-    this.set(
-      assistant({
-        ...message2,
-        id: session?.currentSegId ?? head.id,
-        parts: message2.parts.slice(session?.currentSegStart ?? 0)
-      })
-    );
-    await this.save({ branch: false });
+    let id = head.id;
+    let parts = message2.parts;
+    if (session) {
+      if (session.initialStepStarts === null) {
+        const initialId = session.segments[0]?.id ?? head.id;
+        const initial = await this.#store.getMessage(initialId);
+        if (!initial || initial.name !== "assistant") {
+          throw new Error(
+            `writeAssistantSegment: initial segment "${initialId}" was not found`
+          );
+        }
+        session.initialStepStarts = requireUIMessage(
+          initial.data,
+          `Stored assistant message "${initial.id}"`
+        ).parts.filter((part) => part.type === "step-start").length;
+      }
+      const streamStepStarts = message2.parts.flatMap(
+        (part, index) => part.type === "step-start" ? [index] : []
+      );
+      const completedSteps = streamStepStarts.length - session.initialStepStarts;
+      if (completedSteps < 0) {
+        throw new Error(
+          "writeAssistantSegment: response lost an existing step boundary"
+        );
+      }
+      const segmentIndex = session.segments.findLastIndex(
+        (candidate) => candidate.startStep < completedSteps
+      );
+      if (segmentIndex >= 0) {
+        const segment = session.segments[segmentIndex];
+        id = segment.id;
+        if (segmentIndex > 0) {
+          const start = streamStepStarts[session.initialStepStarts + segment.startStep];
+          if (start === void 0) {
+            throw new Error(
+              `writeAssistantSegment: response is missing step ${segment.startStep + 1}`
+            );
+          }
+          parts = message2.parts.slice(start);
+        }
+      } else {
+        const lastSegment = session.segments.at(-1);
+        if (lastSegment) {
+          id = lastSegment.id;
+          parts = [];
+        }
+      }
+    }
+    const fragment2 = assistant({
+      ...message2,
+      id,
+      parts
+    });
+    if (!session) {
+      this.set(fragment2);
+      await this.save({ branch: false });
+      return;
+    }
+    const stored = await this.#store.getMessage(id);
+    if (!stored) {
+      throw new Error(
+        `writeAssistantSegment: reserved segment "${id}" was not found`
+      );
+    }
+    if (!fragment2.codec) {
+      throw new Error("writeAssistantSegment: assistant codec is missing");
+    }
+    await this.#store.addMessages([
+      {
+        ...stored,
+        name: fragment2.name,
+        type: fragment2.type,
+        data: fragment2.codec.encode()
+      }
+    ]);
   }
   #remindersFor(target) {
     return this.#fragments.filter(isConditionalReminder).map((fragment2) => fragment2.metadata.reminder).filter((config) => config.target === target);
@@ -4590,8 +4731,16 @@ var ContextEngine = class _ContextEngine {
         "steer reminders require a user message earlier in the turn"
       );
     }
+    const lastAssistantMessage = chain.lastAssistantMessage;
+    if (!lastAssistantMessage) {
+      throw new Error("steer reminders require a completed assistant step");
+    }
     return {
       ...this.#buildWhenCtx(chain, currentMessage),
+      lastAssistantMessage: mergeTerminalToolParts(
+        lastAssistantMessage,
+        session.terminalToolParts
+      ),
       sandbox,
       firedOnceIds: /* @__PURE__ */ new Set([...chain.firedOnceIds, ...session.firedOnceIds])
     };
@@ -6557,7 +6706,7 @@ function startKernelProcess(os, command, options) {
   const stderr = new PassThrough();
   const onStdout = (chunk) => stdout.write(chunk);
   const onStderr = (chunk) => stderr.write(chunk);
-  const { pid } = os.spawn("sh", ["-c", command], {
+  const { pid } = os.spawn("bash", ["-lc", command], {
     ...options,
     onStdout,
     onStderr
@@ -6610,6 +6759,25 @@ async function createAgentOsSandbox(options = {}) {
     const err = error instanceof Error ? error : new Error(String(error));
     throw new AgentOsCreationError(err.message, err);
   }
+  try {
+    const probe = startKernelProcess(os, ":", {});
+    const [, stderr, exitCode] = await Promise.all([
+      readAll(probe.stdout),
+      readAll(probe.stderr),
+      probe.exit
+    ]);
+    if (exitCode !== 0) {
+      throw new Error(stderr.trim() || `exit code ${exitCode}`);
+    }
+  } catch (error) {
+    await os.dispose().catch(() => {
+    });
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new AgentOsCreationError(
+      `Bash is required to execute sandbox commands but could not be started: ${err.message}`,
+      err
+    );
+  }
   const sandbox = {
     async executeCommand(command, { signal } = {}) {
       if (signal?.aborted) {
@@ -7143,6 +7311,7 @@ var ContainerSandboxStrategy = class {
         await this.engine.ensureWorkdir(this.context.containerId, this.workdir);
         await this.configure();
       }
+      await this.assertBashAvailable();
     } catch (error) {
       if (acquired && !acquired.attached) {
         await this.stopContainer(acquired.containerId);
@@ -7441,6 +7610,15 @@ var ContainerSandboxStrategy = class {
       };
     }
   }
+  async assertBashAvailable() {
+    const result = await this.exec(":");
+    if (result.exitCode === 0) return;
+    const detail = result.stderr.trim() || result.stdout.trim();
+    throw this.engine.errors.generic(
+      `Bash is required to execute sandbox commands but could not be started${detail ? `: ${detail}` : "."}`,
+      this.context.containerId
+    );
+  }
   spawnProcess(command, options) {
     const child = childSpawn(
       this.engine.cli,
@@ -7632,7 +7810,7 @@ var appleEngine = {
         flags.push("--env", `${key}=${value}`);
       }
     }
-    return ["exec", ...flags, containerId, "sh", "-c", command];
+    return ["exec", ...flags, containerId, "bash", "-lc", command];
   },
   inspectArgs(containerId) {
     return ["inspect", containerId];
@@ -7661,9 +7839,15 @@ var appleEngine = {
     return /already exists/i.test(message2);
   },
   async ensureWorkdir(containerId, workdir) {
-    await spawn3(CLI, ["exec", containerId, "sh", "-c", `mkdir -p ${workdir}`]);
+    await spawn3(CLI, [
+      "exec",
+      containerId,
+      "bash",
+      "-lc",
+      `mkdir -p ${shellQuote(workdir)}`
+    ]);
   },
-  defaultImage: "docker.io/library/alpine:latest",
+  defaultImage: "docker.io/library/bash:5.3-alpine3.24",
   createInstallerContext: createAppleInstallerContext,
   async imageExists(tag) {
     try {
@@ -7878,6 +8062,7 @@ var KNOWN_TOOLS = /* @__PURE__ */ new Set([
   "head",
   "html-to-markdown",
   "iconv",
+  "js-exec",
   "join",
   "jq",
   "node",
@@ -8022,6 +8207,7 @@ async function createToolPrompt(sandbox, filenames, customPrompt) {
   const available = new Set(
     result.stdout.split("\n").filter((entry) => KNOWN_TOOLS.has(entry))
   );
+  if (available.has("js-exec")) available.delete("node");
   if (available.size === 0) return "";
   const lines = [
     `Available tools: ${[...available].sort().join(", ")}, and more`
@@ -8311,6 +8497,7 @@ async function createDaytonaSandbox(client, options = {}) {
   } catch (error) {
     throw normalizeDaytonaError(error, sdk);
   }
+  await assertDaytonaBash(sandbox, options.commandTimeout);
   const backend = createDaytonaSandboxMethods({
     sandbox,
     commandTimeout: options.commandTimeout
@@ -8326,6 +8513,24 @@ async function createDaytonaSandbox(client, options = {}) {
   }
   return backend;
 }
+async function assertDaytonaBash(sandbox, commandTimeout) {
+  try {
+    const result = await sandbox.process.executeCommand(
+      "bash -lc ':'",
+      void 0,
+      void 0,
+      commandTimeout
+    );
+    if (result.exitCode === void 0 || result.exitCode === 0) return;
+    throw new Error(result.result || `exit code ${result.exitCode}`);
+  } catch (error) {
+    const err = toError(error);
+    throw new DaytonaCreationError(
+      `Bash is required to execute sandbox commands but could not be started: ${err.message}`,
+      err
+    );
+  }
+}
 var UNRECOVERABLE_SANDBOX_STATES = /* @__PURE__ */ new Set([
   "error",
   "build_failed",
@@ -8462,7 +8667,7 @@ function createDaytonaSandboxMethods(args) {
         return abortedCommandResult();
       }
       const response = await sandbox.process.executeCommand(
-        command,
+        `bash -lc ${shellQuote(command)}`,
         void 0,
         void 0,
         commandTimeout
@@ -8704,13 +8909,13 @@ function buildSessionCommand(command, options) {
   const env = options.env ?? {};
   const entries = Object.entries(env);
   if (entries.length === 0) {
-    return `sh -lc ${shellQuote(`${cwdPrefix}${command}`)}`;
+    return `bash -lc ${shellQuote(`${cwdPrefix}${command}`)}`;
   }
   for (const [key] of entries) {
     validateEnvKey(key);
   }
   const exports = entries.map(([key, value]) => `export ${key}=${shellQuote(value)}`).join("; ");
-  return `sh -lc ${shellQuote(`${exports}; ${cwdPrefix}${command}`)}`;
+  return `bash -lc ${shellQuote(`${exports}; ${cwdPrefix}${command}`)}`;
 }
 function validateEnvKey(key) {
   if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)) {
@@ -8950,7 +9155,7 @@ var dockerEngine = {
         flags.push("-e", `${key}=${value}`);
       }
     }
-    return ["exec", ...flags, containerId, "sh", "-c", command];
+    return ["exec", ...flags, containerId, "bash", "-lc", command];
   },
   inspectArgs(containerId) {
     return [
@@ -8993,7 +9198,7 @@ var dockerEngine = {
   },
   async ensureWorkdir() {
   },
-  defaultImage: "alpine:latest",
+  defaultImage: "bash:5.3-alpine3.24",
   createInstallerContext,
   async imageExists(tag) {
     try {
@@ -9103,8 +9308,8 @@ var ComposeStrategy = class extends ContainerSandboxStrategy {
           "exec",
           "-T",
           this.service,
-          "sh",
-          "-c",
+          "bash",
+          "-lc",
           command
         ],
         { signal: options?.signal }
@@ -9130,8 +9335,8 @@ var ComposeStrategy = class extends ContainerSandboxStrategy {
       "-T",
       ...buildDockerExecFlags(options),
       this.service,
-      "sh",
-      "-c",
+      "bash",
+      "-lc",
       command
     ]);
     return toSandboxProcess(child, options?.signal);
@@ -9189,10 +9394,10 @@ import spawn6 from "nano-spawn";
 import { posix as posix2 } from "node:path";
 var STRACE_FLAGS = "-f -y -qq -e trace=%file,write,pwrite64,writev";
 function buildStraceCommand(command, traceFile, traceDir) {
-  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- sh -c ${shellQuote(command)}`;
+  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- bash -lc ${shellQuote(command)}`;
 }
 function buildTracedCommand(command, traceFile, traceDir, sentinel) {
-  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- sh -c ${shellQuote(command)}; __dat_rc=$?; printf '\\n%s\\n' ${shellQuote(sentinel)}; base64 ${shellQuote(traceFile)} 2>/dev/null; rm -f ${shellQuote(traceFile)} 2>/dev/null; exit $__dat_rc`;
+  return `mkdir -p ${shellQuote(traceDir)} 2>/dev/null; strace ${STRACE_FLAGS} -o ${shellQuote(traceFile)} -- bash -lc ${shellQuote(command)}; __dat_rc=$?; printf '\\n%s\\n' ${shellQuote(sentinel)}; base64 ${shellQuote(traceFile)} 2>/dev/null; rm -f ${shellQuote(traceFile)} 2>/dev/null; exit $__dat_rc`;
 }
 function splitTracedOutput(stdout, sentinel) {
   const marker = `
@@ -9815,7 +10020,7 @@ function formatVersion(version) {
 // packages/context/src/lib/sandbox/microsandbox-sandbox.ts
 import { randomUUID as randomUUID3 } from "node:crypto";
 var MICROSANDBOX_DEFAULT_DESTINATION = "/workspace";
-var MICROSANDBOX_DEFAULT_IMAGE = "alpine";
+var MICROSANDBOX_DEFAULT_IMAGE = "bash:5.3-alpine3.24";
 var MICROSANDBOX_MAX_NAME_BYTES = 128;
 var COMMAND_TIMEOUT_EXIT_CODE = 124;
 var MicrosandboxSandboxError = class extends Error {
@@ -9855,8 +10060,17 @@ async function createMicrosandboxSandbox(options = {}) {
   let vm;
   try {
     vm = await acquireSandbox(sdk, { ...options, name, ephemeral, workdir });
+  } catch (error) {
+    throw normalizeMicrosandboxError(error, sdk);
+  }
+  try {
     await vm.fs().mkdir(workdir);
+    await assertMicrosandboxBash(vm);
   } catch (error) {
+    await vm.stop().catch(() => {
+    });
+    if (ephemeral) await sdk.Sandbox.remove(name).catch(() => {
+    });
     throw normalizeMicrosandboxError(error, sdk);
   }
   const backend = createMicrosandboxMethods({
@@ -9930,10 +10144,24 @@ function buildSandbox(sdk, options) {
   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();
+  return builder.shell("bash").create();
+}
+async function assertMicrosandboxBash(vm) {
+  try {
+    const result = await vm.exec("bash", ["-lc", ":"]);
+    if (result.code === 0) return;
+    throw new Error(result.stderr() || `exit code ${result.code}`);
+  } catch (error) {
+    const err = toError2(error);
+    throw new MicrosandboxCreationError(
+      `Bash is required to execute sandbox commands but could not be started: ${err.message}`,
+      err
+    );
+  }
 }
 function normalizeMicrosandboxError(error, sdk) {
   const err = toError2(error);
+  if (err instanceof MicrosandboxSandboxError) return err;
   if (err instanceof sdk.LibkrunfwNotFoundError) {
     return new MicrosandboxNotAvailableError(err);
   }
@@ -10048,7 +10276,7 @@ async function pumpExecStream(args) {
   }
   signal?.addEventListener("abort", abort, { once: true });
   try {
-    handle = await vm.execStreamWith("sh", (builder) => {
+    handle = await vm.execStreamWith("bash", (builder) => {
       builder.args(["-lc", command]).stdinNull();
       if (options.cwd) builder.cwd(options.cwd);
       if (options.env) builder.envs(options.env);
@@ -10237,12 +10465,15 @@ function buildSubcommandRepair(name, subcommands) {
 }
 
 // packages/context/src/lib/sandbox/virtual-sandbox.ts
-import { Bash } from "just-bash";
+import {
+  Bash
+} from "just-bash";
 async function createVirtualSandbox(options) {
   const bash = new Bash({
     fs: options.fs,
     cwd: options.cwd,
     env: options.env,
+    javascript: options.javascript,
     customCommands: options.customCommands
   });
   const sandbox = {