@deepagents/context 0.30.0 → 0.32.0

package/dist/index.js

@@ -426,7 +426,7 @@ import {
 import { z } from "zod";
 
 // packages/context/src/lib/engine.ts
-import { isTextUIPart as isTextUIPart2, validateUIMessages } from "ai";
+import { validateUIMessages } from "ai";
 import { mergeWith } from "lodash-es";
 
 // packages/context/src/lib/estimate.ts
@@ -753,14 +753,45 @@ function applyPartReminder(message2, value) {
   };
 }
 function resolveReminderText(item, ctx) {
-  return typeof item.text === "function" ? item.text(ctx) : item.text;
+  return resolveReminder(item, ctx)?.text ?? "";
+}
+function normalizeReminderResolution(value) {
+  if (typeof value === "string") {
+    return value.trim().length === 0 ? null : { text: value };
+  }
+  if (value.text.trim().length === 0) {
+    return null;
+  }
+  return value;
+}
+function resolveReminder(item, ctx) {
+  const resolvedText = typeof item.text === "function" ? item.text(ctx) : item.text;
+  const resolved = normalizeReminderResolution(resolvedText);
+  if (!resolved) {
+    return null;
+  }
+  const metadata = item.metadata || resolved.metadata ? {
+    ...item.metadata ?? {},
+    ...resolved.metadata ?? {}
+  } : void 0;
+  return metadata ? { ...resolved, metadata } : resolved;
+}
+function mergeMessageMetadata(message2, addedMetadata) {
+  if (Object.keys(addedMetadata).length === 0) {
+    return;
+  }
+  const metadata = isRecord(message2.metadata) ? { ...message2.metadata } : {};
+  message2.metadata = { ...metadata, ...addedMetadata };
 }
 function applyReminderToMessage(message2, item, ctx) {
-  const resolvedText = resolveReminderText(item, ctx);
-  if (resolvedText.trim().length === 0) {
+  const resolved = resolveReminder(item, ctx);
+  if (!resolved) {
     return null;
   }
-  return item.asPart ? applyPartReminder(message2, resolvedText) : applyInlineReminder(message2, resolvedText);
+  if (resolved.metadata) {
+    mergeMessageMetadata(message2, resolved.metadata);
+  }
+  return item.asPart ? applyPartReminder(message2, resolved.text) : applyInlineReminder(message2, resolved.text);
 }
 function mergeReminderMetadata(message2, addedReminders) {
   if (addedReminders.length === 0) return;
@@ -798,14 +829,14 @@ function user(content, ...reminders) {
   } : { ...content, role: "user", parts: [...content.parts] };
   if (reminders.length > 0) {
     const plainText = extractPlainText(message2);
-    const addedReminders = [];
+    const added = [];
     for (const item of reminders) {
       const meta = applyReminderToMessage(message2, item, {
         content: plainText
       });
-      if (meta) addedReminders.push(meta);
+      if (meta) added.push(meta);
     }
-    mergeReminderMetadata(message2, addedReminders);
+    mergeReminderMetadata(message2, added);
   }
   return {
     id: message2.id,
@@ -1721,6 +1752,14 @@ var ContextEngine = class {
   #initialized = false;
   /** Initial metadata to merge on first initialization */
   #initialMetadata;
+  get #activeBranch() {
+    if (!this.#branch) {
+      throw new Error(
+        "Branch not initialized. Call #ensureInitialized() first."
+      );
+    }
+    return this.#branch;
+  }
   get #renderableFragments() {
     return this.#fragments.filter((f) => !isConditionalReminder(f));
   }
@@ -1757,7 +1796,13 @@ var ContextEngine = class {
       });
       this.#initialMetadata = void 0;
     }
-    this.#branch = await this.#store.getActiveBranch(this.#chatId);
+    const branch = await this.#store.getActiveBranch(this.#chatId);
+    if (!branch) {
+      throw new Error(
+        `Active branch not found for chat "${this.#chatId}" after upsertChat`
+      );
+    }
+    this.#branch = branch;
     this.#initialized = true;
   }
   /**
@@ -1841,30 +1886,35 @@ var ContextEngine = class {
     };
   }
   /**
-   * Count user+assistant message pairs (turns) in the conversation.
-   * Includes persisted messages and pending messages.
-   * A turn is one user message paired with one assistant message.
-   * An unpaired trailing user message counts as the next turn.
+   * Count user turns in the conversation and return the previous saved user message context.
+   * Includes persisted messages and pending messages in the turn count.
    */
-  async getTurnCount() {
+  async #getChainContext() {
     await this.#ensureInitialized();
-    let userCount = 0;
+    let turn = 0;
+    let lastMessageAt;
+    let lastMessage;
     if (this.#branch?.headMessageId) {
       const chain = await this.#store.getMessageChain(
         this.#branch.headMessageId
       );
       for (const msg of chain) {
-        if (msg.name === "user") {
-          userCount++;
+        if (msg.name !== "user") {
+          continue;
         }
+        turn++;
+        lastMessageAt = msg.createdAt;
+        lastMessage = msg.data;
       }
     }
     for (const fragment2 of this.#pendingMessages) {
-      if (fragment2.name === "user") {
-        userCount++;
-      }
+      if (fragment2.name === "user") turn++;
     }
-    return userCount;
+    return { turn, lastMessageAt, lastMessage };
+  }
+  async getTurnCount() {
+    const { turn } = await this.#getChainContext();
+    return turn;
   }
   /**
    * Add fragments to the context.
@@ -1935,37 +1985,6 @@ var ContextEngine = class {
       }
       messages.push(fragment2.codec.encode());
     }
-    const conditionalReminders = this.#fragments.filter(isConditionalReminder);
-    if (conditionalReminders.length > 0) {
-      const turn = await this.getTurnCount();
-      let lastUserIndex = -1;
-      for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].role === "user") {
-          lastUserIndex = i;
-          break;
-        }
-      }
-      if (lastUserIndex >= 0) {
-        const original = messages[lastUserIndex];
-        const message2 = {
-          ...original,
-          parts: [...original.parts]
-        };
-        const plainText = message2.parts.filter(isTextUIPart2).map((p) => p.text).join(" ");
-        const addedReminders = [];
-        for (const fragment2 of conditionalReminders) {
-          const config = getConditionalReminder(fragment2);
-          if (!config.when(turn)) continue;
-          const meta = applyReminderToMessage(message2, config, {
-            content: plainText,
-            turn
-          });
-          if (meta) addedReminders.push(meta);
-        }
-        mergeReminderMetadata(message2, addedReminders);
-        messages[lastUserIndex] = message2;
-      }
-    }
     return {
       systemPrompt,
       messages: messages.length === 0 ? [] : await validateUIMessages({ messages })
@@ -2009,7 +2028,49 @@ var ContextEngine = class {
         }
       }
     }
-    let parentId = this.#branch.headMessageId;
+    const conditionalReminders = this.#fragments.filter(isConditionalReminder);
+    if (conditionalReminders.length > 0) {
+      let lastUserIndex = -1;
+      for (let i = this.#pendingMessages.length - 1; i >= 0; i--) {
+        if (this.#pendingMessages[i].name === "user") {
+          lastUserIndex = i;
+          break;
+        }
+      }
+      if (lastUserIndex >= 0) {
+        const lastUserFragment = this.#pendingMessages[lastUserIndex];
+        if (lastUserFragment.codec) {
+          const { turn, lastMessageAt, lastMessage } = await this.#getChainContext();
+          const firedReminders = conditionalReminders.map(getConditionalReminder).filter((config) => config.when(turn));
+          if (firedReminders.length > 0) {
+            const original = lastUserFragment.codec.encode();
+            const plainText = extractPlainText(original);
+            const reminders = firedReminders.flatMap((rem) => {
+              const resolved = resolveReminder(rem, {
+                content: plainText,
+                turn,
+                lastMessageAt,
+                lastMessage
+              });
+              if (!resolved) {
+                return [];
+              }
+              return [
+                {
+                  text: resolved.text,
+                  asPart: rem.asPart,
+                  metadata: resolved.metadata
+                }
+              ];
+            });
+            const recreated = user(original, ...reminders);
+            recreated.id = lastUserFragment.id;
+            this.#pendingMessages[lastUserIndex] = recreated;
+          }
+        }
+      }
+    }
+    let parentId = this.#activeBranch.headMessageId;
     const now = Date.now();
     for (const fragment2 of this.#pendingMessages) {
       if (!fragment2.codec) {
@@ -2037,10 +2098,10 @@ var ContextEngine = class {
       await this.#store.addMessage(messageData);
       parentId = messageData.id;
     }
-    await this.#store.updateBranchHead(this.#branch.id, parentId);
-    this.#branch.headMessageId = parentId;
+    await this.#store.updateBranchHead(this.#activeBranch.id, parentId);
+    this.#activeBranch.headMessageId = parentId;
     this.#pendingMessages = [];
-    return { headMessageId: this.#branch.headMessageId ?? void 0 };
+    return { headMessageId: this.#activeBranch.headMessageId ?? void 0 };
   }
   /**
    * Resolve a lazy fragment by finding the appropriate ID.
@@ -3814,6 +3875,159 @@ function fromFragment(fragment2, options) {
   throw new Error(`Fragment "${fragment2.name}" is missing codec`);
 }
 
+// packages/context/src/lib/fragments/message/environment-reminder.ts
+var ENVIRONMENT_REMINDER_METADATA_KEY = "environment";
+function getSeason(month) {
+  if (month >= 2 && month <= 4) return "Spring";
+  if (month >= 5 && month <= 7) return "Summer";
+  if (month >= 8 && month <= 10) return "Fall";
+  return "Winter";
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function buildEnvironmentSnapshot(now, options) {
+  const { language, timeZone } = options;
+  const currentDateTime = now.toLocaleString("en-CA", {
+    timeZone,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+    hour12: false
+  });
+  const dayOfWeek = now.toLocaleString("default", {
+    weekday: "long",
+    timeZone
+  });
+  const month = now.toLocaleString("default", {
+    month: "long",
+    timeZone
+  });
+  const year = parseInt(
+    now.toLocaleString("en-CA", { year: "numeric", timeZone }),
+    10
+  );
+  const monthIndex = parseInt(now.toLocaleString("en-CA", { month: "numeric", timeZone }), 10) - 1;
+  return {
+    timeZone,
+    language,
+    currentDateTime,
+    dateKey: now.toLocaleDateString("en-CA", { timeZone }),
+    dayOfWeek,
+    month,
+    year,
+    season: getSeason(monthIndex),
+    timestamp: now.getTime()
+  };
+}
+function buildEnvironmentBlock(snapshot) {
+  return `TimeZone is always in ${snapshot.timeZone}.
+
+Current Date & Time: "${snapshot.currentDateTime}"
+Day of Week: ${snapshot.dayOfWeek}
+Month: ${snapshot.month}
+Year: ${snapshot.year}
+Timestamp: ${snapshot.timestamp}
+Language: ${snapshot.language}
+Season: ${snapshot.season}`;
+}
+function formatChange(previous, current) {
+  const changes = [];
+  if (previous.timeZone !== current.timeZone) {
+    changes.push(`time zone: ${previous.timeZone} -> ${current.timeZone}`);
+  }
+  if (previous.language !== current.language) {
+    changes.push(`language: ${previous.language} -> ${current.language}`);
+  }
+  if (previous.dateKey !== current.dateKey) {
+    changes.push(`date: ${previous.dateKey} -> ${current.dateKey}`);
+  }
+  if (previous.dayOfWeek !== current.dayOfWeek) {
+    changes.push(`day of week: ${previous.dayOfWeek} -> ${current.dayOfWeek}`);
+  }
+  if (previous.month !== current.month) {
+    changes.push(`month: ${previous.month} -> ${current.month}`);
+  }
+  if (previous.year !== current.year) {
+    changes.push(`year: ${previous.year} -> ${current.year}`);
+  }
+  if (previous.season !== current.season) {
+    changes.push(`season: ${previous.season} -> ${current.season}`);
+  }
+  return changes;
+}
+function buildChangeSummary(previous, current) {
+  if (!previous) {
+    return "";
+  }
+  const changes = formatChange(previous, current);
+  if (changes.length === 0) {
+    return "";
+  }
+  return `Changes since last environment snapshot:
+- ${changes.join("\n- ")}
+
+`;
+}
+function parseEnvironmentSnapshot(value) {
+  if (!isRecord2(value)) {
+    return null;
+  }
+  if (typeof value.timeZone !== "string" || typeof value.language !== "string" || typeof value.currentDateTime !== "string" || typeof value.dateKey !== "string" || typeof value.dayOfWeek !== "string" || typeof value.month !== "string" || typeof value.year !== "number" || typeof value.season !== "string" || typeof value.timestamp !== "number") {
+    return null;
+  }
+  return {
+    timeZone: value.timeZone,
+    language: value.language,
+    currentDateTime: value.currentDateTime,
+    dateKey: value.dateKey,
+    dayOfWeek: value.dayOfWeek,
+    month: value.month,
+    year: value.year,
+    season: value.season,
+    timestamp: value.timestamp
+  };
+}
+function getEnvironmentSnapshot(message2) {
+  const metadata = isRecord2(message2?.metadata) ? message2.metadata : null;
+  if (!metadata) {
+    return null;
+  }
+  const stored = metadata[ENVIRONMENT_REMINDER_METADATA_KEY];
+  if (!isRecord2(stored) || stored.version !== 1) {
+    return null;
+  }
+  return parseEnvironmentSnapshot(stored.snapshot);
+}
+function environmentReminder(options) {
+  const getNow = options?.getNow ?? (() => /* @__PURE__ */ new Date());
+  const language = options?.language ?? "English (US)";
+  const timeZone = options?.timeZone ?? "UTC";
+  return reminder(
+    (ctx) => {
+      const snapshot = buildEnvironmentSnapshot(getNow(), {
+        language,
+        timeZone
+      });
+      const previousSnapshot = getEnvironmentSnapshot(ctx.lastMessage);
+      const summary = buildChangeSummary(previousSnapshot, snapshot);
+      return {
+        text: `${summary}${buildEnvironmentBlock(snapshot)}`,
+        metadata: {
+          [ENVIRONMENT_REMINDER_METADATA_KEY]: {
+            version: 1,
+            snapshot
+          }
+        }
+      };
+    },
+    { when: everyNTurns(1) }
+  );
+}
+
 // packages/context/src/lib/fragments/reasoning.ts
 function reasoningFramework() {
   return [
@@ -3938,6 +4152,68 @@ function selfCritique(checks = DEFAULT_SELF_CRITIQUE_CHECKS) {
   });
 }
 
+// packages/context/src/lib/fragments/socratic.ts
+function socraticPrompting() {
+  return [
+    role(
+      "You are a deep, methodical thinker. Before producing any output, you reason through the problem by asking and answering foundational questions. You never treat a request as a simple task to complete \u2014 you first build understanding through inquiry, then apply that understanding to produce high-quality output."
+    ),
+    fragment(
+      "socratic_prompting",
+      hint(
+        "When given a task, do not jump straight to producing output. Instead, decompose the task into foundational questions that, once answered, will make the output significantly better. Answer those questions first, then synthesize your answers into the final output."
+      ),
+      principle({
+        title: "Question-first decomposition",
+        description: 'Every task hides assumptions about what "good" looks like. Surface those assumptions by asking what makes the output effective before attempting to produce it.',
+        policies: [
+          'Ask "What makes X effective/compelling/useful?" before producing X.',
+          "Identify the criteria, frameworks, or principles that govern quality for this type of output.",
+          "Do not skip this step even when the task seems straightforward \u2014 obvious tasks often have non-obvious quality dimensions."
+        ]
+      }),
+      principle({
+        title: "Multi-dimensional inquiry",
+        description: "Explore the problem from multiple angles \u2014 emotional, logical, practical, audience-specific \u2014 through targeted questions.",
+        policies: [
+          "Ask about the audience: Who is this for? What do they care about?",
+          "Ask about constraints: What must this include or avoid?",
+          "Ask about effectiveness: What separates great output from mediocre output in this domain?",
+          "Ask about structure: How should this be organized for maximum impact?"
+        ]
+      }),
+      principle({
+        title: "Framework discovery before application",
+        description: "Build or recall a relevant framework by reasoning through questions, then explicitly apply that framework to the specific task.",
+        policies: [
+          "First derive the framework: What principles govern this type of work?",
+          'Then apply it: "Now, using these principles, produce the specific output."',
+          "The framework should emerge from your reasoning, not from a template."
+        ]
+      }),
+      workflow({
+        task: "Socratic reasoning process",
+        steps: [
+          "Identify the core task and desired output type.",
+          "Formulate 2-5 foundational questions about what makes this output effective.",
+          "Answer each question, drawing on relevant knowledge and frameworks.",
+          "Synthesize answers into a coherent set of principles or criteria.",
+          "Apply the discovered framework to produce the specific output.",
+          "Verify the output satisfies the criteria you identified."
+        ]
+      }),
+      example({
+        question: "How should I prompt for a value proposition for my AI analytics tool?",
+        answer: "What makes a value proposition compelling to B2B buyers? What emotional and logical triggers should it hit? Now apply that framework to an AI analytics tool that helps teams make faster data-driven decisions."
+      }),
+      example({
+        question: "How should I prompt for a 30-day LinkedIn content calendar for B2B SaaS?",
+        answer: "What types of LinkedIn content generate the most engagement in B2B SaaS? What posting frequency avoids audience fatigue? How should topics build on each other? Now design a 30-day calendar using these principles."
+      })
+    )
+  ];
+}
+
 // packages/context/src/lib/guardrails/error-recovery.guardrail.ts
 import chalk2 from "chalk";
 var errorRecoveryGuardrail = {
@@ -4046,6 +4322,107 @@ function render(tag, ...fragments) {
   return renderer.render([wrapped]);
 }
 
+// packages/context/src/lib/sandbox/agent-os-sandbox.ts
+import "bash-tool";
+var textDecoder = new TextDecoder();
+var AgentOsSandboxError = class extends Error {
+  constructor(message2) {
+    super(message2);
+    this.name = "AgentOsSandboxError";
+  }
+};
+var AgentOsNotAvailableError = class extends AgentOsSandboxError {
+  constructor(cause) {
+    super(
+      "@rivet-dev/agent-os-core is not installed. Install it with: npm install @rivet-dev/agent-os-core @rivet-dev/agent-os-common"
+    );
+    this.name = "AgentOsNotAvailableError";
+    this.cause = cause;
+  }
+};
+var AgentOsCreationError = class extends AgentOsSandboxError {
+  constructor(message2, cause) {
+    super(`Failed to create Agent OS instance: ${message2}`);
+    this.name = "AgentOsCreationError";
+    this.cause = cause;
+  }
+};
+async function importAgentOs() {
+  try {
+    return await import("@rivet-dev/agent-os-core");
+  } catch (error) {
+    throw new AgentOsNotAvailableError(
+      error instanceof Error ? error : void 0
+    );
+  }
+}
+async function createAgentOsSandbox(options = {}) {
+  const { AgentOs } = await importAgentOs();
+  let os;
+  try {
+    os = await AgentOs.create(options);
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new AgentOsCreationError(err.message, err);
+  }
+  return {
+    async executeCommand(command) {
+      try {
+        const result = await os.exec(command);
+        return {
+          stdout: result.stdout,
+          stderr: result.stderr,
+          exitCode: result.exitCode
+        };
+      } catch (error) {
+        const err = error;
+        return {
+          stdout: err.stdout || "",
+          stderr: err.stderr || err.message || "",
+          exitCode: err.exitCode ?? 1
+        };
+      }
+    },
+    async readFile(path3) {
+      try {
+        const bytes = await os.readFile(path3);
+        return textDecoder.decode(bytes);
+      } catch (error) {
+        throw new Error(
+          `Failed to read file "${path3}": ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    },
+    async writeFiles(files) {
+      const results = await os.writeFiles(
+        files.map((f) => ({
+          path: f.path,
+          content: typeof f.content === "string" ? f.content : new Uint8Array(f.content)
+        }))
+      );
+      const failures = results.filter((r) => !r.success);
+      if (failures.length > 0) {
+        const details = failures.map((f) => `${f.path}: ${f.error}`).join(", ");
+        throw new Error(`Failed to write files: ${details}`);
+      }
+    },
+    async dispose() {
+      try {
+        await os.dispose();
+      } catch {
+      }
+    }
+  };
+}
+async function useAgentOsSandbox(options, fn) {
+  const sandbox = await createAgentOsSandbox(options);
+  try {
+    return await fn(sandbox);
+  } finally {
+    await sandbox.dispose();
+  }
+}
+
 // packages/context/src/lib/sandbox/binary-bridges.ts
 import { existsSync } from "fs";
 import { defineCommand } from "just-bash";
@@ -4142,6 +4519,11 @@ function resolveRealCwd(ctx) {
   return realCwd;
 }
 
+// packages/context/src/lib/sandbox/container-tool.ts
+import {
+  createBashTool
+} from "bash-tool";
+
 // packages/context/src/lib/sandbox/docker-sandbox.ts
 import "bash-tool";
 import spawn2 from "nano-spawn";
@@ -4234,10 +4616,10 @@ var ComposeStartError = class extends DockerSandboxError {
   }
 };
 function isDebianBased(image) {
+  const lower = image.toLowerCase();
+  if (lower.includes("alpine")) return false;
   const debianPatterns = ["debian", "ubuntu", "node", "python"];
-  return debianPatterns.some(
-    (pattern) => image.toLowerCase().includes(pattern)
-  );
+  return debianPatterns.some((pattern) => lower.includes(pattern));
 }
 function isDockerfileOptions(opts) {
   return "dockerfile" in opts;
@@ -4249,9 +4631,18 @@ var DockerSandboxStrategy = class {
   context;
   mounts;
   resources;
-  constructor(mounts = [], resources = {}) {
+  env;
+  constructor(mounts = [], resources = {}, env = {}) {
+    for (const key of Object.keys(env)) {
+      if (key.length === 0 || key.includes("=")) {
+        throw new DockerSandboxError(
+          `Invalid environment variable key: "${key}"`
+        );
+      }
+    }
     this.mounts = mounts;
     this.resources = resources;
+    this.env = env;
   }
   /**
    * Template method - defines the algorithm skeleton for creating a sandbox.
@@ -4308,6 +4699,9 @@ var DockerSandboxStrategy = class {
       "/workspace"
       // Set working directory
     ];
+    for (const [key, value] of Object.entries(this.env)) {
+      args.push("-e", `${key}=${value}`);
+    }
     for (const mount of this.mounts) {
       const mode = mount.readOnly !== false ? "ro" : "rw";
       args.push("-v", `${mount.hostPath}:${mount.containerPath}:${mode}`);
@@ -4411,8 +4805,8 @@ var RuntimeStrategy = class extends DockerSandboxStrategy {
   image;
   packages;
   binaries;
-  constructor(image = "alpine:latest", packages = [], binaries = [], mounts, resources) {
-    super(mounts, resources);
+  constructor(image = "alpine:latest", packages = [], binaries = [], mounts, resources, env) {
+    super(mounts, resources, env);
     this.image = image;
     this.packages = packages;
     this.binaries = binaries;
@@ -4581,8 +4975,8 @@ var DockerfileStrategy = class extends DockerSandboxStrategy {
   imageTag;
   dockerfile;
   dockerContext;
-  constructor(dockerfile, dockerContext = ".", mounts, resources) {
-    super(mounts, resources);
+  constructor(dockerfile, dockerContext = ".", mounts, resources, env) {
+    super(mounts, resources, env);
     this.dockerfile = dockerfile;
     this.dockerContext = dockerContext;
     this.imageTag = this.computeImageTag();
@@ -4755,7 +5149,8 @@ async function createDockerSandbox(options = {}) {
       options.dockerfile,
       options.context,
       options.mounts,
-      options.resources
+      options.resources,
+      options.env
     );
   } else {
     strategy = new RuntimeStrategy(
@@ -4763,7 +5158,8 @@ async function createDockerSandbox(options = {}) {
       options.packages,
       options.binaries,
       options.mounts,
-      options.resources
+      options.resources,
+      options.env
     );
   }
   return strategy.create();
@@ -4778,9 +5174,6 @@ async function useSandbox(options, fn) {
 }
 
 // packages/context/src/lib/sandbox/container-tool.ts
-import {
-  createBashTool
-} from "bash-tool";
 async function createContainerTool(options = {}) {
   let sandboxOptions;
   let bashOptions;
@@ -4789,12 +5182,12 @@ async function createContainerTool(options = {}) {
     sandboxOptions = { compose, service, resources };
     bashOptions = rest;
   } else if (isDockerfileOptions(options)) {
-    const { dockerfile, context, mounts, resources, ...rest } = options;
-    sandboxOptions = { dockerfile, context, mounts, resources };
+    const { dockerfile, context, mounts, resources, env, ...rest } = options;
+    sandboxOptions = { dockerfile, context, mounts, resources, env };
     bashOptions = rest;
   } else {
-    const { image, packages, binaries, mounts, resources, ...rest } = options;
-    sandboxOptions = { image, packages, binaries, mounts, resources };
+    const { image, packages, binaries, mounts, resources, env, ...rest } = options;
+    sandboxOptions = { image, packages, binaries, mounts, resources, env };
     bashOptions = rest;
   }
   const sandbox = await createDockerSandbox(sandboxOptions);
@@ -7335,6 +7728,9 @@ function visualizeGraph(data) {
   return lines.join("\n");
 }
 export {
+  AgentOsCreationError,
+  AgentOsNotAvailableError,
+  AgentOsSandboxError,
   BM25SkillClassifier,
   BinaryInstallError,
   ComposeStartError,
@@ -7350,6 +7746,7 @@ export {
   DockerSandboxStrategy,
   DockerfileBuildError,
   DockerfileStrategy,
+  ENVIRONMENT_REMINDER_METADATA_KEY,
   InMemoryContextStore,
   LAZY_ID,
   MarkdownRenderer,
@@ -7381,23 +7778,27 @@ export {
   clarification,
   correction,
   createAdaptivePollingState,
+  createAgentOsSandbox,
   createBinaryBridges,
   createContainerTool,
   createDockerSandbox,
   defaultTokenizer,
   discoverSkillsInDirectory,
   encodeSerializedValue,
+  environmentReminder,
   errorRecoveryGuardrail,
   estimate,
   everyNTurns,
   example,
   explain,
+  extractPlainText,
   fail,
   firstN,
   fragment,
   fromFragment,
   generateChatTitle,
   getConditionalReminder,
+  getEnvironmentSnapshot,
   getFragmentData,
   getModelsRegistry,
   getReminderRanges,
@@ -7414,6 +7815,7 @@ export {
   isMessageFragment,
   lastAssistantMessage,
   loadSkillMetadata,
+  mergeMessageMetadata,
   mergeReminderMetadata,
   message,
   nextAdaptivePollingDelay,
@@ -7434,12 +7836,14 @@ export {
   reminder,
   render,
   resetAdaptivePolling,
+  resolveReminder,
   resolveReminderText,
   role,
   runGuardrailChain,
   selfCritique,
   skills,
   skillsReminder,
+  socraticPrompting,
   soul,
   staticChatTitle,
   stop,
@@ -7450,6 +7854,7 @@ export {
   term,
   toFragment,
   toMessageFragment,
+  useAgentOsSandbox,
   useSandbox,
   user,
   visualizeGraph,