zeitlich 0.2.36 → 0.2.37

package/src/adapters/thread/langchain/hooks.test.ts

@@ -3,11 +3,14 @@ import { HumanMessage, AIMessage } from "@langchain/core/messages";
 import type { BaseMessage } from "@langchain/core/messages";
 import { appendCachePoint } from "./hooks";
 
-const cacheBlock = { type: "cache_control" as const, cache_control: { type: "ephemeral" as const } };
+const cacheBlock = {
+  type: "cache_control" as const,
+  cache_control: { type: "ephemeral" as const },
+};
 
 function applyHook(
   messages: BaseMessage[],
-  hook: ReturnType<typeof appendCachePoint>,
+  hook: ReturnType<typeof appendCachePoint>
 ): BaseMessage[] {
   return messages.map((m, i, arr) => hook(m, i, arr));
 }
@@ -47,29 +50,25 @@ describe("appendCachePoint", () => {
   it("deduplicates within the last message", () => {
     const messages: BaseMessage[] = [
       new HumanMessage({
-        content: [
-          { type: "text", text: "hello" },
-          cacheBlock,
-        ],
+        content: [{ type: "text", text: "hello" }, cacheBlock],
       }),
     ];
     const hook = appendCachePoint(cacheBlock);
     const result = applyHook(messages, hook);
 
-    const blocks = (messageAt(result, 0).content as Array<{ type: string }>).filter(
-      (b) => b.type === cacheBlock.type,
-    );
+    const blocks = (
+      messageAt(result, 0).content as Array<{ type: string }>
+    ).filter((b) => b.type === cacheBlock.type);
     expect(blocks).toHaveLength(1);
   });
 
   it("strips old cache blocks when total would exceed maxBlocks", () => {
-    const messages: BaseMessage[] = Array.from({ length: 6 }, (_, i) =>
-      new HumanMessage({
-        content: [
-          { type: "text", text: `msg ${i}` },
-          cacheBlock,
-        ],
-      }),
+    const messages: BaseMessage[] = Array.from(
+      { length: 6 },
+      (_, i) =>
+        new HumanMessage({
+          content: [{ type: "text", text: `msg ${i}` }, cacheBlock],
+        })
     );
     const hook = appendCachePoint(cacheBlock, { maxBlocks: 4 });
     const result = applyHook(messages, hook);
@@ -78,13 +77,12 @@ describe("appendCachePoint", () => {
   });
 
   it("keeps the most recent cache blocks", () => {
-    const messages: BaseMessage[] = Array.from({ length: 6 }, (_, i) =>
-      new HumanMessage({
-        content: [
-          { type: "text", text: `msg ${i}` },
-          cacheBlock,
-        ],
-      }),
+    const messages: BaseMessage[] = Array.from(
+      { length: 6 },
+      (_, i) =>
+        new HumanMessage({
+          content: [{ type: "text", text: `msg ${i}` }, cacheBlock],
+        })
     );
     const hook = appendCachePoint(cacheBlock, { maxBlocks: 4 });
     const result = applyHook(messages, hook);
@@ -101,13 +99,12 @@ describe("appendCachePoint", () => {
   });
 
   it("respects a custom maxBlocks value", () => {
-    const messages: BaseMessage[] = Array.from({ length: 5 }, (_, i) =>
-      new HumanMessage({
-        content: [
-          { type: "text", text: `msg ${i}` },
-          cacheBlock,
-        ],
-      }),
+    const messages: BaseMessage[] = Array.from(
+      { length: 5 },
+      (_, i) =>
+        new HumanMessage({
+          content: [{ type: "text", text: `msg ${i}` }, cacheBlock],
+        })
     );
     const hook = appendCachePoint(cacheBlock, { maxBlocks: 2 });
     const result = applyHook(messages, hook);
@@ -141,13 +138,12 @@ describe("appendCachePoint", () => {
   });
 
   it("defaults maxBlocks to 4", () => {
-    const messages: BaseMessage[] = Array.from({ length: 8 }, (_, i) =>
-      new HumanMessage({
-        content: [
-          { type: "text", text: `msg ${i}` },
-          cacheBlock,
-        ],
-      }),
+    const messages: BaseMessage[] = Array.from(
+      { length: 8 },
+      (_, i) =>
+        new HumanMessage({
+          content: [{ type: "text", text: `msg ${i}` }, cacheBlock],
+        })
     );
     const hook = appendCachePoint(cacheBlock);
     const result = applyHook(messages, hook);
@@ -165,22 +161,13 @@ describe("appendCachePoint", () => {
         ],
       }),
       new HumanMessage({
-        content: [
-          { type: "text", text: "msg 1" },
-          cacheBlock,
-        ],
+        content: [{ type: "text", text: "msg 1" }, cacheBlock],
       }),
       new HumanMessage({
-        content: [
-          { type: "text", text: "msg 2" },
-          cacheBlock,
-        ],
+        content: [{ type: "text", text: "msg 2" }, cacheBlock],
       }),
       new HumanMessage({
-        content: [
-          { type: "text", text: "msg 3" },
-          cacheBlock,
-        ],
+        content: [{ type: "text", text: "msg 3" }, cacheBlock],
       }),
       new HumanMessage("last"),
     ];

package/src/adapters/thread/langchain/hooks.ts

@@ -12,8 +12,12 @@ type ContentBlock = MessageContent extends (infer U)[] | string ? U : never;
  */
 export function appendCachePoint(
   block: ContentBlock,
-  { maxBlocks = 4 }: { maxBlocks?: number } = {},
-): (message: BaseMessage, index: number, messages: readonly BaseMessage[]) => BaseMessage {
+  { maxBlocks = 4 }: { maxBlocks?: number } = {}
+): (
+  message: BaseMessage,
+  index: number,
+  messages: readonly BaseMessage[]
+) => BaseMessage {
   return (message, index, messages) => {
     const isLast = index === messages.length - 1;
 
@@ -23,13 +27,19 @@ export function appendCachePoint(
         if (content.some((b) => b.type === block.type)) return message;
         message.content = [...content, block];
       } else if (typeof content === "string") {
-        message.content = [{ type: "text", text: content }, block] satisfies MessageContent;
+        message.content = [
+          { type: "text", text: content },
+          block,
+        ] satisfies MessageContent;
       }
       return message;
     }
 
     const { content } = message;
-    if (!Array.isArray(content) || !content.some((b) => b.type === block.type)) {
+    if (
+      !Array.isArray(content) ||
+      !content.some((b) => b.type === block.type)
+    ) {
       return message;
     }
 
@@ -40,7 +50,10 @@ export function appendCachePoint(
       const msg = messages[i];
       if (!msg) continue;
       const c = msg.content;
-      if (Array.isArray(c) && c.some((b: ContentBlock) => b.type === block.type)) {
+      if (
+        Array.isArray(c) &&
+        c.some((b: ContentBlock) => b.type === block.type)
+      ) {
         cacheBlocksAfter++;
       }
     }

package/src/adapters/thread/langchain/model-invoker.ts

@@ -9,7 +9,7 @@ import {
 } from "./thread-manager";
 import { getActivityContext } from "../../../lib/activity";
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ 
 export interface LangChainModelInvokerConfig<
   TModel extends BaseChatModel<any> = BaseChatModel<any>,
 > {
@@ -40,7 +40,7 @@ export interface LangChainModelInvokerConfig<
  * return { ...createRunAgentActivity(client, invoker, "myAgent") };
  * ```
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ 
 export function createLangChainModelInvoker<
   TModel extends BaseChatModel<any> = BaseChatModel<any>,
 >({ redis, model, hooks }: LangChainModelInvokerConfig<TModel>) {
@@ -109,7 +109,7 @@ export function createLangChainModelInvoker<
  * Convenience wrapper around createLangChainModelInvoker for cases where
  * you don't need to reuse the invoker.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
+ 
 export async function invokeLangChainModel<
   TModel extends BaseChatModel<any> = BaseChatModel<any>,
 >({

package/src/adapters/thread/langchain/proxy.ts

@@ -27,7 +27,11 @@ const ADAPTER_PREFIX = "langChain";
 
 export function proxyLangChainThreadOps(
   scope?: string,
-  options?: Parameters<typeof createThreadOpsProxy>[2],
+  options?: Parameters<typeof createThreadOpsProxy>[2]
 ): ActivityInterfaceFor<ThreadOps<LangChainContent>> {
-  return createThreadOpsProxy(ADAPTER_PREFIX, scope, options) as ActivityInterfaceFor<ThreadOps<LangChainContent>>;
+  return createThreadOpsProxy(
+    ADAPTER_PREFIX,
+    scope,
+    options
+  ) as ActivityInterfaceFor<ThreadOps<LangChainContent>>;
 }

package/src/adapters/thread/langchain/thread-manager.test.ts

@@ -91,7 +91,11 @@ describe("LangChain thread manager hooks", () => {
 
       await tm.prepareForInvocation();
 
-      const args = hook.mock.calls[0] as unknown as [unknown, number, unknown[]];
+      const args = hook.mock.calls[0] as unknown as [
+        unknown,
+        number,
+        unknown[],
+      ];
       expect(args[2]).toHaveLength(2);
     });
   });

package/src/adapters/thread/langchain/thread-manager.ts

@@ -23,7 +23,10 @@ export type LangChainContent = string | MessageContent;
 /** SDK-native content type for LangChain system messages */
 export type LangChainSystemContent = string | MessageContent;
 
-export type LangChainThreadManagerHooks = ThreadManagerHooks<StoredMessage, BaseMessage>;
+export type LangChainThreadManagerHooks = ThreadManagerHooks<
+  StoredMessage,
+  BaseMessage
+>;
 
 export interface LangChainThreadManagerConfig {
   redis: Redis;
@@ -39,8 +42,12 @@ export interface LangChainInvocationPayload {
 }
 
 /** Thread manager with LangChain StoredMessage convenience helpers */
-export interface LangChainThreadManager
-  extends ProviderThreadManager<StoredMessage, LangChainContent, JsonValue, LangChainSystemContent> {
+export interface LangChainThreadManager extends ProviderThreadManager<
+  StoredMessage,
+  LangChainContent,
+  JsonValue,
+  LangChainSystemContent
+> {
   appendAIMessage(id: string, content: string | MessageContent): Promise<void>;
   prepareForInvocation(): Promise<LangChainInvocationPayload>;
 }
@@ -63,7 +70,7 @@ function storedMessageId(msg: StoredMessage): string {
  * appending typed LangChain messages.
  */
 export function createLangChainThreadManager(
-  config: LangChainThreadManagerConfig,
+  config: LangChainThreadManagerConfig
 ): LangChainThreadManager {
   const baseConfig: ThreadManagerConfig<StoredMessage> = {
     redis: config.redis,
@@ -77,7 +84,7 @@ export function createLangChainThreadManager(
   const helpers: Omit<LangChainThreadManager, keyof typeof base> = {
     async appendUserMessage(
       id: string,
-      content: LangChainContent,
+      content: LangChainContent
     ): Promise<void> {
       await base.append([
         new HumanMessage({ id, content: content as MessageContent }).toDict(),
@@ -86,7 +93,7 @@ export function createLangChainThreadManager(
 
     async appendSystemMessage(
       id: string,
-      content: LangChainSystemContent,
+      content: LangChainSystemContent
     ): Promise<void> {
       await base.initialize();
       await base.append([
@@ -99,7 +106,7 @@ export function createLangChainThreadManager(
 
     async appendAIMessage(
       id: string,
-      content: string | MessageContent,
+      content: string | MessageContent
     ): Promise<void> {
       await base.append([
         new AIMessage({ id, content: content as MessageContent }).toDict(),
@@ -110,10 +117,14 @@ export function createLangChainThreadManager(
       id: string,
       _toolCallId: string,
       _toolName: string,
-      content: JsonValue,
+      content: JsonValue
     ): Promise<void> {
       await base.append([
-        new ToolMessage({ id, content: content as MessageContent, tool_call_id: _toolCallId }).toDict(),
+        new ToolMessage({
+          id,
+          content: content as MessageContent,
+          tool_call_id: _toolCallId,
+        }).toDict(),
       ]);
     },
 

package/src/index.ts

@@ -58,7 +58,10 @@ export type { AgentStateContext } from "./lib/activity";
 
 // Sandbox (activity-side: manager + Node.js filesystem adapter)
 export { SandboxManager } from "./lib/sandbox/manager";
-export type { SandboxManagerHooks, PreCreateHookResult } from "./lib/sandbox/manager";
+export type {
+  SandboxManagerHooks,
+  PreCreateHookResult,
+} from "./lib/sandbox/manager";
 export { NodeFsSandboxFileSystem } from "./lib/sandbox/node-fs";
 
 // Virtual filesystem (activity-side)

package/src/lib/activity.ts

@@ -59,10 +59,13 @@ export async function queryParentWorkflowState<T>(
  * };
  * ```
  */
-export function createRunAgentActivity<R, S extends BaseAgentState = BaseAgentState>(
+export function createRunAgentActivity<
+  R,
+  S extends BaseAgentState = BaseAgentState,
+>(
   client: WorkflowClient,
   handler: (config: RunAgentConfig & { state: S }) => Promise<R>,
-  scope: string,
+  scope: string
 ): Record<string, (config: RunAgentConfig) => Promise<R>> {
   const name = `run${scope.charAt(0).toUpperCase()}${scope.slice(1)}`;
   return {
@@ -76,7 +79,9 @@ export function createRunAgentActivity<R, S extends BaseAgentState = BaseAgentSt
 /**
  * Context injected into tool handlers created via {@link withParentWorkflowState}.
  */
-export interface AgentStateContext<S extends BaseAgentState = BaseAgentState> extends RouterContext {
+export interface AgentStateContext<
+  S extends BaseAgentState = BaseAgentState,
+> extends RouterContext {
   state: S;
 }
 
@@ -101,12 +106,17 @@ export interface AgentStateContext<S extends BaseAgentState = BaseAgentState> ex
  * );
  * ```
  */
-export function withParentWorkflowState<TArgs, TResult, S extends BaseAgentState = BaseAgentState, TToolResponse = JsonValue>(
+export function withParentWorkflowState<
+  TArgs,
+  TResult,
+  S extends BaseAgentState = BaseAgentState,
+  TToolResponse = JsonValue,
+>(
   client: WorkflowClient,
   handler: (
     args: TArgs,
-    context: AgentStateContext<S>,
-  ) => Promise<ToolHandlerResponse<TResult, TToolResponse>>,
+    context: AgentStateContext<S>
+  ) => Promise<ToolHandlerResponse<TResult, TToolResponse>>
 ): ActivityToolHandler<TArgs, TResult, RouterContext, TToolResponse> {
   return async (args, context) => {
     const state = await queryParentWorkflowState<S>(client);

package/src/lib/hooks/types.ts

@@ -1,8 +1,5 @@
 import type { SessionExitReason } from "../types";
-import type {
-  ToolMap,
-  ToolRouterHooks,
-} from "../tool-router/types";
+import type { ToolMap, ToolRouterHooks } from "../tool-router/types";
 
 // ============================================================================
 // Session Lifecycle Hooks
@@ -85,8 +82,11 @@ export type PostHumanMessageAppendHook<TContent = unknown> = (
  * (consumed by the router) with session/message lifecycle hooks
  * (consumed directly by the session).
  */
-export interface Hooks<T extends ToolMap, TResult = unknown, TContent = unknown>
-  extends ToolRouterHooks<T, TResult> {
+export interface Hooks<
+  T extends ToolMap,
+  TResult = unknown,
+  TContent = unknown,
+> extends ToolRouterHooks<T, TResult> {
   /** Called before each human message is appended to the thread */
   onPreHumanMessageAppend?: PreHumanMessageAppendHook<TContent>;
   /** Called after each human message is appended to the thread */

package/src/lib/lifecycle.ts

@@ -19,6 +19,8 @@ export type ThreadInit =
 // Sandbox lifecycle
 // ============================================================================
 
+import type { SandboxSnapshot } from "./sandbox/types";
+
 /**
  * Sandbox initialization strategy.
  *
@@ -30,6 +32,8 @@ export type ThreadInit =
  *   on exit.
  * - `"fork"` — fork from an existing (or paused) sandbox; a new sandbox is
  *   created and owned by this session.
+ * - `"from-snapshot"` — restore a fresh sandbox from a previously captured
+ *   {@link SandboxSnapshot}. The new sandbox is owned by this session.
  * - `"inherit"` — use a sandbox owned by someone else (e.g. a parent agent).
  *   The session will **not** manage its lifecycle on exit.
  */
@@ -37,6 +41,7 @@ export type SandboxInit =
   | { mode: "new"; ctx?: unknown }
   | { mode: "continue"; sandboxId: string }
   | { mode: "fork"; sandboxId: string }
+  | { mode: "from-snapshot"; snapshot: SandboxSnapshot }
   | {
       mode: "inherit";
       sandboxId: string;
@@ -48,8 +53,11 @@ export type SandboxInit =
  * - `"destroy"` — tear down the sandbox entirely.
  * - `"pause"` — pause the sandbox so it can be resumed later.
  * - `"keep"` — leave the sandbox running (no-op on exit).
+ * - `"snapshot"` — capture a snapshot then destroy the sandbox. The snapshot
+ *   is surfaced on the session result so the caller can reuse it to spawn
+ *   future sandboxes.
  */
-export type SandboxShutdown = "destroy" | "pause" | "keep";
+export type SandboxShutdown = "destroy" | "pause" | "keep" | "snapshot";
 
 /**
  * Extended shutdown options available to subagent workflows.

package/src/lib/model/proxy.ts

@@ -29,7 +29,7 @@ import type { RunAgentConfig } from "../types";
 
 export function proxyRunAgent<M = unknown>(
   scope?: string,
-  options?: Parameters<typeof proxyActivities>[0],
+  options?: Parameters<typeof proxyActivities>[0]
 ): (config: RunAgentConfig) => Promise<AgentResponse<M>> {
   const resolvedScope = scope ?? workflowInfo().workflowType;
   const name = `run${resolvedScope.charAt(0).toUpperCase()}${resolvedScope.slice(1)}`;
@@ -44,7 +44,7 @@ export function proxyRunAgent<M = unknown>(
         maximumInterval: "2m",
         backoffCoefficient: 3,
       },
-    },
+    }
   );
   return acts[name] as (config: RunAgentConfig) => Promise<AgentResponse<M>>;
 }

package/src/lib/observability/hooks.ts

@@ -1,9 +1,6 @@
 import { proxySinks } from "@temporalio/workflow";
 import type { ZeitlichObservabilitySinks } from "./sinks";
-import type {
-  SessionStartHook,
-  SessionEndHook,
-} from "../hooks/types";
+import type { SessionStartHook, SessionEndHook } from "../hooks/types";
 import type {
   PostToolUseHook,
   PostToolUseFailureHook,
@@ -39,7 +36,9 @@ export interface ObservabilityHooks {
  *
  * @param agentName - Agent name attached to every emitted event
  */
-export function createObservabilityHooks(agentName: string): ObservabilityHooks {
+export function createObservabilityHooks(
+  agentName: string
+): ObservabilityHooks {
   const { zeitlichMetrics } = proxySinks<ZeitlichObservabilitySinks>();
   let sessionStartMs = Date.now();
 

package/src/lib/observability/index.ts

@@ -1,7 +1,4 @@
-export {
-  createObservabilityHooks,
-  composeHooks,
-} from "./hooks";
+export { createObservabilityHooks, composeHooks } from "./hooks";
 export type { ObservabilityHooks } from "./hooks";
 
 export type {

package/src/lib/sandbox/manager.ts

@@ -50,8 +50,12 @@ export interface SandboxManagerHooks<
 
   /**
    * Called after a sandbox has been successfully created.
+   *
+   * Receives the live {@link Sandbox} instance so the hook can run setup
+   * commands, seed files, or capture identifiers without an extra
+   * `provider.get()` round-trip.
    */
-  onPostCreate?: (sandboxId: string) => Promise<void>;
+  onPostCreate?: (sandbox: Sandbox, ctx: TCtx) => Promise<void>;
 }
 
 /**
@@ -87,8 +91,9 @@ export interface SandboxManagerHooks<
  *         for (const p of filePaths) files[p] = await db.readFile(projectId, p);
  *         return { modifiedOptions: { initialFiles: files } };
  *       },
- *       onPostCreate: async (sandboxId) => {
- *         console.log("Sandbox created:", sandboxId);
+ *       onPostCreate: async (sandbox) => {
+ *         console.log("Sandbox created:", sandbox.id);
+ *         await sandbox.exec("git init");
  *       },
  *     },
  *   },
@@ -148,7 +153,7 @@ export class SandboxManager<
     const { sandbox } = await this.provider.create(providerOptions);
 
     if (this.hooks.onPostCreate) {
-      await this.hooks.onPostCreate(sandbox.id);
+      await this.hooks.onPostCreate(sandbox, ctx ?? ({} as TCtx));
     }
 
     return { sandboxId: sandbox.id };
@@ -179,6 +184,10 @@ export class SandboxManager<
     return sandbox.id;
   }
 
+  async deleteSnapshot(snapshot: SandboxSnapshot): Promise<void> {
+    await this.provider.deleteSnapshot(snapshot);
+  }
+
   async fork(sandboxId: string): Promise<string> {
     const sandbox = await this.provider.fork(sandboxId);
     return sandbox.id;
@@ -232,6 +241,14 @@ export class SandboxManager<
       snapshotSandbox: async (sandboxId: string): Promise<SandboxSnapshot> => {
         return this.snapshot(sandboxId);
       },
+      restoreSandbox: async (snapshot: SandboxSnapshot): Promise<string> => {
+        return this.restore(snapshot);
+      },
+      deleteSandboxSnapshot: async (
+        snapshot: SandboxSnapshot
+      ): Promise<void> => {
+        await this.deleteSnapshot(snapshot);
+      },
       forkSandbox: async (sandboxId: string): Promise<string> => {
         return this.fork(sandboxId);
       },

package/src/lib/sandbox/node-fs.ts

@@ -65,10 +65,7 @@ export class NodeFsSandboxFileSystem implements SandboxFileSystem {
     };
   }
 
-  async mkdir(
-    path: string,
-    options?: { recursive?: boolean },
-  ): Promise<void> {
+  async mkdir(path: string, options?: { recursive?: boolean }): Promise<void> {
     await fsp.mkdir(this.abs(path), options);
   }
 
@@ -88,7 +85,7 @@ export class NodeFsSandboxFileSystem implements SandboxFileSystem {
 
   async rm(
     path: string,
-    options?: { recursive?: boolean; force?: boolean },
+    options?: { recursive?: boolean; force?: boolean }
   ): Promise<void> {
     await fsp.rm(this.abs(path), options);
   }
@@ -96,7 +93,7 @@ export class NodeFsSandboxFileSystem implements SandboxFileSystem {
   async cp(
     src: string,
     dest: string,
-    options?: { recursive?: boolean },
+    options?: { recursive?: boolean }
   ): Promise<void> {
     await fsp.cp(this.abs(src), this.abs(dest), options);
   }

package/src/lib/sandbox/sandbox.test.ts

@@ -157,18 +157,21 @@ describe("SandboxManager", () => {
     expect(await sandbox.fs.readFile("/file.txt")).toBe("explicit");
   });
 
-  it("onPostCreate hook receives sandboxId", async () => {
+  it("onPostCreate hook receives the live sandbox", async () => {
     let capturedId: string | undefined;
     const mgr = new SandboxManager(new InMemorySandboxProvider(), {
       hooks: {
-        onPostCreate: async (sandboxId) => {
-          capturedId = sandboxId;
+        onPostCreate: async (sandbox) => {
+          capturedId = sandbox.id;
+          await sandbox.fs.writeFile("/hook.txt", "written-by-hook");
         },
       },
     });
 
     const { sandboxId } = await mustCreate(mgr);
     expect(capturedId).toBe(sandboxId);
+    const sandbox = await mgr.getSandbox(sandboxId);
+    expect(await sandbox.fs.readFile("/hook.txt")).toBe("written-by-hook");
   });
 
   it("onPostCreate hook does not run when creation is skipped", async () => {
@@ -192,6 +195,8 @@ describe("SandboxManager", () => {
     expect(activities.inMemoryTestCreateSandbox).toBeTypeOf("function");
     expect(activities.inMemoryTestDestroySandbox).toBeTypeOf("function");
     expect(activities.inMemoryTestSnapshotSandbox).toBeTypeOf("function");
+    expect(activities.inMemoryTestRestoreSandbox).toBeTypeOf("function");
+    expect(activities.inMemoryTestDeleteSandboxSnapshot).toBeTypeOf("function");
 
     const result = await activities.inMemoryTestCreateSandbox();
     expect(result).not.toBeNull();
@@ -203,6 +208,34 @@ describe("SandboxManager", () => {
       SandboxNotFoundError
     );
   });
+
+  it("restoreSandbox activity creates a new sandbox from a snapshot", async () => {
+    const activities = manager.createActivities("Test");
+
+    const created = await activities.inMemoryTestCreateSandbox({
+      initialFiles: { "/greeting.txt": "hello" },
+    });
+    const { sandboxId } = created as { sandboxId: string };
+
+    const snapshot = await activities.inMemoryTestSnapshotSandbox(sandboxId);
+    await activities.inMemoryTestDestroySandbox(sandboxId);
+
+    const restoredId = await activities.inMemoryTestRestoreSandbox(snapshot);
+    const restored = await manager.getSandbox(restoredId);
+    expect(await restored.fs.readFile("/greeting.txt")).toBe("hello");
+  });
+
+  it("deleteSandboxSnapshot activity is a no-op for in-memory snapshots", async () => {
+    const activities = manager.createActivities("Test");
+
+    const created = await activities.inMemoryTestCreateSandbox();
+    const { sandboxId } = created as { sandboxId: string };
+
+    const snapshot = await activities.inMemoryTestSnapshotSandbox(sandboxId);
+    await expect(
+      activities.inMemoryTestDeleteSandboxSnapshot(snapshot)
+    ).resolves.toBeUndefined();
+  });
 });
 
 describe("InMemorySandboxProvider", () => {