@deepagents/context 4.1.0 → 4.2.1

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({
@@ -2611,7 +2616,15 @@ async function evaluateFiredReminders(configs, whenCtx) {
 }
 
 // packages/context/src/lib/save/save-pipeline.ts
-var SavePipeline = class {
+var HeadConflictError = class extends Error {
+  constructor(chatId, headMessageId) {
+    super(
+      `Could not commit head "${headMessageId}" for chat "${chatId}": concurrent writers kept moving the branch head`
+    );
+    this.name = "HeadConflictError";
+  }
+};
+var SavePipeline = class _SavePipeline {
   #engine;
   #pending;
   #shouldBranch = true;
@@ -2667,9 +2680,49 @@ var SavePipeline = class {
       );
     }
     await this.#engine.store.addMessages(messages);
-    await this.#engine.commitHead(parentId);
+    await this.#commitHead(messages[0], parentId);
     return { headMessageId: parentId };
   }
+  static #maxCommitAttempts = 5;
+  /**
+   * Advance the branch head to `newHead` through the store's CAS. A stale
+   * cached head must never rewind the branch (that silently orphans turns
+   * committed in between), so a rejected CAS re-reads the store head and
+   * reconciles:
+   * - the store head already descends from `newHead` (an in-place assistant
+   *   fill whose turn was built past): content is on the chain, keep the
+   *   store head;
+   * - `newHead` descends from the store head: fast-forward, retry against it;
+   * - true fork (another turn won the same head): graft this turn onto the
+   *   winning head by re-parenting the first pending message, then retry.
+   *   Grafting applies only to messages chained off the stale head — an
+   *   in-place fill keeps its original parent and its content already landed.
+   */
+  async #commitHead(first2, newHead) {
+    let expected = this.#engine.getActiveBranch().headMessageId;
+    for (let i = 0; i < _SavePipeline.#maxCommitAttempts; i++) {
+      if (await this.#engine.commitHead(newHead, expected)) return;
+      const fresh = (await this.#engine.refreshBranch()).headMessageId;
+      if (fresh === null || fresh === expected) {
+        expected = fresh;
+        continue;
+      }
+      if (await this.#chainContains(fresh, newHead)) return;
+      if (await this.#chainContains(newHead, fresh)) {
+        expected = fresh;
+        continue;
+      }
+      if (first2.parentId !== expected) return;
+      await this.#engine.store.setMessageParent(first2.id, fresh);
+      first2.parentId = fresh;
+      expected = fresh;
+    }
+    throw new HeadConflictError(this.#engine.chatId, newHead);
+  }
+  async #chainContains(headId, messageId) {
+    const chain = await this.#engine.store.getMessageChain(headId);
+    return chain.some((message2) => message2.id === messageId);
+  }
 };
 
 // packages/context/src/lib/store/sqlite.store.ts
@@ -2937,6 +2990,17 @@ var SqliteContextStore = class extends ContextStore {
       }
     });
   }
+  async setMessageParent(messageId, parentId) {
+    if (parentId === messageId) {
+      throw new Error(`Message ${messageId} cannot be its own parent`);
+    }
+    const result = this.#stmt(
+      "UPDATE messages SET parentId = ? WHERE id = ?"
+    ).run(parentId, messageId);
+    if (result.changes === 0) {
+      throw new Error(`Message ${messageId} not found`);
+    }
+  }
   async getMessage(messageId) {
     const row = this.#stmt("SELECT * FROM messages WHERE id = ?").get(
       messageId
@@ -3043,11 +3107,11 @@ var SqliteContextStore = class extends ContextStore {
     this.#db.prepare("UPDATE branches SET isActive = 0 WHERE chatId = ?").run(chatId);
     this.#db.prepare("UPDATE branches SET isActive = 1 WHERE id = ?").run(branchId);
   }
-  async updateBranchHead(branchId, messageId) {
-    this.#stmt("UPDATE branches SET headMessageId = ? WHERE id = ?").run(
-      messageId,
-      branchId
-    );
+  async updateBranchHead(branchId, messageId, expectedHeadMessageId) {
+    const result = this.#stmt(
+      "UPDATE branches SET headMessageId = ? WHERE id = ? AND headMessageId IS ?"
+    ).run(messageId, branchId, expectedHeadMessageId);
+    return result.changes > 0;
   }
   async listBranches(chatId) {
     const rows = this.#db.prepare(
@@ -3916,6 +3980,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 +3992,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,
@@ -3949,12 +4022,29 @@ var ContextEngine = class _ContextEngine {
         id: this.#activeBranch.id,
         headMessageId: this.#activeBranch.headMessageId
       }),
-      commitHead: async (headMessageId) => {
-        await this.#store.updateBranchHead(
+      commitHead: async (headMessageId, expectedHeadMessageId) => {
+        const committed = await this.#store.updateBranchHead(
           this.#activeBranch.id,
-          headMessageId
+          headMessageId,
+          expectedHeadMessageId
+        );
+        if (committed) {
+          this.#activeBranch.headMessageId = headMessageId;
+        }
+        return committed;
+      },
+      refreshBranch: async () => {
+        const fresh = await this.#store.getBranch(
+          this.#chatId,
+          this.#activeBranch.name
         );
-        this.#activeBranch.headMessageId = headMessageId;
+        if (!fresh) {
+          throw new Error(
+            `Branch "${this.#activeBranch.name}" not found for chat "${this.#chatId}"`
+          );
+        }
+        this.#branch = fresh;
+        return { id: fresh.id, headMessageId: fresh.headMessageId };
       },
       rewindForUpdate: (parentId) => this.#rewindForUpdate(parentId)
     };
@@ -4055,8 +4145,14 @@ var ContextEngine = class _ContextEngine {
    *
    * @example
    * ```ts
-   * context.set(user('What is 2 + 2?', { id: 'q1' }));
-   * context.set(assistant('The answer is 5.', { id: 'wrong' })); // Oops!
+   * context.set(
+   *   user({
+   *     id: 'q1',
+   *     role: 'user',
+   *     parts: [{ type: 'text', text: 'What is 2 + 2?' }],
+   *   }),
+   * );
+   * context.set(assistantText('The answer is 5.', { id: 'wrong' })); // Oops!
    * await context.save();
    *
    * // Rewind to the question, creates new branch
@@ -4894,7 +4990,7 @@ async function chat(agent2, options = {}) {
     execute: async ({ writer }) => {
       writer.merge(uiStream);
       if (title) {
-        writer.write({ type: "data-chat-title", data: title });
+        writer.write({ type: "data-chat-title", data: title, transient: true });
       }
     }
   });
@@ -6132,14 +6228,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 +6316,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 +6779,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 +7162,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 +7188,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 +7220,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) {
@@ -7131,7 +7250,6 @@ var appleEngine = {
   inspectArgs(containerId) {
     return ["inspect", containerId];
   },
-  mountArg: buildMountArg,
   parseStatus(stdout) {
     const entries = safeParseArray(stdout);
     if (entries.length === 0) return "absent";
@@ -7356,12 +7474,6 @@ function useBashMeta() {
   return {
     setHidden(patch) {
       state.hidden = { ...state.hidden, ...patch };
-    },
-    setReminder(text) {
-      state.reminder = text;
-    },
-    clearReminder() {
-      state.reminder = void 0;
     }
   };
 }
@@ -7571,14 +7683,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 +7858,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",
@@ -8393,7 +8509,6 @@ var dockerEngine = {
       containerId
     ];
   },
-  mountArg: dockerMountArg,
   parseStatus(status) {
     return status === "running" ? "running" : "stopped";
   },
@@ -9233,6 +9348,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 +9782,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 +9811,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
@@ -9806,6 +10284,18 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
       );
     });
   }
+  async setMessageParent(messageId, parentId) {
+    if (parentId === messageId) {
+      throw new Error(`Message ${messageId} cannot be its own parent`);
+    }
+    const rows = await this.#query(
+      `UPDATE ${this.#t("messages")} SET parentId = $1 WHERE id = $2 RETURNING id`,
+      [parentId, messageId]
+    );
+    if (rows.length === 0) {
+      throw new Error(`Message ${messageId} not found`);
+    }
+  }
   async getMessage(messageId) {
     const rows = await this.#query(`SELECT * FROM ${this.#t("messages")} WHERE id = $1`, [messageId]);
     if (rows.length === 0) {
@@ -9928,11 +10418,14 @@ var PostgresContextStore = class _PostgresContextStore extends ContextStore {
       );
     });
   }
-  async updateBranchHead(branchId, messageId) {
-    await this.#query(
-      `UPDATE ${this.#t("branches")} SET headMessageId = $1 WHERE id = $2`,
-      [messageId, branchId]
+  async updateBranchHead(branchId, messageId, expectedHeadMessageId) {
+    const rows = await this.#query(
+      `UPDATE ${this.#t("branches")} SET headMessageId = $1
+       WHERE id = $2 AND headMessageId IS NOT DISTINCT FROM $3
+       RETURNING id`,
+      [messageId, branchId, expectedHeadMessageId]
     );
+    return rows.length > 0;
   }
   async listBranches(chatId) {
     const branches = await this.#query(
@@ -10595,6 +11088,20 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
       `);
     });
   }
+  async setMessageParent(messageId, parentId) {
+    if (parentId === messageId) {
+      throw new Error(`Message ${messageId} cannot be its own parent`);
+    }
+    const rows = await this.#query(
+      `UPDATE ${this.#t("messages")} SET parentId = @p0
+       OUTPUT INSERTED.id
+       WHERE id = @p1`,
+      [parentId, messageId]
+    );
+    if (rows.length === 0) {
+      throw new Error(`Message ${messageId} not found`);
+    }
+  }
   async getMessage(messageId) {
     const rows = await this.#query(`SELECT * FROM ${this.#t("messages")} WHERE id = @p0`, [messageId]);
     if (rows.length === 0) {
@@ -10720,11 +11227,15 @@ var SqlServerContextStore = class _SqlServerContextStore extends ContextStore {
       );
     });
   }
-  async updateBranchHead(branchId, messageId) {
-    await this.#query(
-      `UPDATE ${this.#t("branches")} SET headMessageId = @p0 WHERE id = @p1`,
-      [messageId, branchId]
+  async updateBranchHead(branchId, messageId, expectedHeadMessageId) {
+    const rows = await this.#query(
+      `UPDATE ${this.#t("branches")} SET headMessageId = @p0
+       OUTPUT INSERTED.id
+       WHERE id = @p1
+         AND (headMessageId = @p2 OR (headMessageId IS NULL AND @p2 IS NULL))`,
+      [messageId, branchId, expectedHeadMessageId]
     );
+    return rows.length > 0;
   }
   async listBranches(chatId) {
     const branches = await this.#query(
@@ -12576,12 +13087,18 @@ export {
   FunctionResolver,
   GeneratorResolver,
   GithubReleaseInstaller,
+  HeadConflictError,
   InMemoryContextStore,
   InstallError,
   Installer,
   IterableResolver,
   LOCALE_METADATA_KEY,
+  MICROSANDBOX_DEFAULT_DESTINATION,
   MarkdownRenderer,
+  MicrosandboxCommandError,
+  MicrosandboxCreationError,
+  MicrosandboxNotAvailableError,
+  MicrosandboxSandboxError,
   MissingRuntimeError,
   ModelsRegistry,
   NpmInstaller,
@@ -12618,6 +13135,7 @@ export {
   analogy,
   and,
   anyToolCalled,
+  appleEngine,
   applyInlineReminder,
   applyPartReminder,
   applyReminderToMessage,
@@ -12647,6 +13165,7 @@ export {
   createDaytonaSandbox,
   createDockerSandbox,
   createInstallerContext,
+  createMicrosandboxSandbox,
   createRepairToolCall,
   createVirtualSandbox,
   dateReminder,