@tanstack/ai-sandbox 0.3.3 → 0.4.0

package/dist/esm/snapshot-operations.js

@@ -0,0 +1,317 @@
+import { SandboxSnapshotError, captureSandboxArtifacts, captureSandboxFiles, resolveSandboxSnapshotPolicy } from "./snapshots.js";
+import { resolveAllSecrets } from "./secrets.js";
+import { computeSandboxKey, computeWorkspaceHash } from "./key.js";
+import { stageEnsureExistingSandbox } from "./sandbox.js";
+//#region src/snapshot-operations.ts
+async function withWriterLease(acquire, renew, operation) {
+	const writer = await acquire();
+	const release = writer.release.bind(writer);
+	const renewWriter = renew ? writer.renew.bind(writer) : void 0;
+	const renewAfterMs = renew ? writer.renewAfterMs : void 0;
+	let renewalTimer;
+	let renewalTask;
+	let renewalFailure;
+	let stopped = false;
+	const scheduleRenewal = () => {
+		if (renewWriter === void 0 || renewAfterMs === void 0) return;
+		renewalTimer = setTimeout(() => {
+			renewalTimer = void 0;
+			renewalTask = (async () => {
+				try {
+					await renewWriter();
+				} catch (error) {
+					renewalFailure = { error };
+				} finally {
+					renewalTask = void 0;
+				}
+				if (!stopped && renewalFailure === void 0) scheduleRenewal();
+			})();
+		}, renewAfterMs);
+	};
+	if (renew) scheduleRenewal();
+	const throwIfLost = async () => {
+		await renewalTask;
+		if (renewalFailure !== void 0) throw renewalFailure.error;
+	};
+	let outcome;
+	let operationFailure;
+	try {
+		outcome = { value: await operation(writer, throwIfLost) };
+	} catch (error) {
+		operationFailure = { error };
+	}
+	stopped = true;
+	if (renewalTimer !== void 0) clearTimeout(renewalTimer);
+	await renewalTask;
+	let releaseFailure;
+	try {
+		await release();
+	} catch (error) {
+		releaseFailure = { error };
+	}
+	if (renewalFailure !== void 0) throw renewalFailure.error;
+	if (operationFailure !== void 0) throw operationFailure.error;
+	if (releaseFailure !== void 0) throw releaseFailure.error;
+	if (outcome === void 0) throw new Error("Writer operation had no outcome");
+	return outcome.value;
+}
+function stageWorkspace(workspace) {
+	if (workspace === void 0) return void 0;
+	const source = workspace.source;
+	const packageManager = workspace.packageManager;
+	const setup = workspace.setup;
+	const scripts = workspace.scripts;
+	const skills = workspace.skills;
+	const instructions = workspace.instructions;
+	const plugins = workspace.plugins;
+	const secrets = workspace.secrets;
+	const root = workspace.root;
+	return {
+		source,
+		...Object.hasOwn(workspace, "packageManager") ? { packageManager } : {},
+		...Object.hasOwn(workspace, "setup") ? { setup } : {},
+		...Object.hasOwn(workspace, "scripts") ? { scripts } : {},
+		...Object.hasOwn(workspace, "skills") ? { skills } : {},
+		...Object.hasOwn(workspace, "instructions") ? { instructions } : {},
+		...Object.hasOwn(workspace, "plugins") ? { plugins } : {},
+		...Object.hasOwn(workspace, "secrets") ? { secrets } : {},
+		...Object.hasOwn(workspace, "root") ? { root } : {}
+	};
+}
+function effectivePolicy(supplied, workspaceHash) {
+	return resolveSandboxSnapshotPolicy(supplied, workspaceHash);
+}
+function stageInstanceStore(store) {
+	return {
+		get: store.get.bind(store),
+		upsert: store.upsert.bind(store),
+		delete: store.delete.bind(store)
+	};
+}
+function stageLockStore(locks) {
+	if (locks === void 0) return void 0;
+	return { withLock: locks.withLock.bind(locks) };
+}
+function requireSnapshotPersistence(persistence) {
+	const stores = persistence.stores;
+	if (!stores?.messages || !stores.artifacts || !stores.blobs) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_MISSING_PERSISTENCE_STORES", "Sandbox snapshots require persistence stores.messages, stores.artifacts, and stores.blobs");
+	return persistence;
+}
+function createSandboxSnapshots(input) {
+	const persistence = requireSnapshotPersistence(input.persistence);
+	const checkpoints = input.checkpoints;
+	const policy = input.policy;
+	const boundSandbox = input.sandbox;
+	const boundInstances = input.instances;
+	const boundTenant = input.tenant;
+	const boundLocks = input.locks;
+	return {
+		persistence,
+		checkpoints,
+		...policy === void 0 ? {} : { policy },
+		async save(saveInput) {
+			const sandbox = saveInput.sandbox ?? boundSandbox;
+			const instances = saveInput.instances ?? boundInstances;
+			if (sandbox === void 0) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_MISSING_SANDBOX", "Named snapshots require a sandbox at create time or on save");
+			if (instances === void 0) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_MISSING_INSTANCES", "Named snapshots require instances at create time or on save");
+			return saveNamedSandboxSnapshot({
+				definition: sandbox,
+				threadId: saveInput.threadId,
+				runId: saveInput.runId,
+				instances,
+				persistence,
+				checkpoints,
+				policy,
+				label: saveInput.label,
+				tenant: saveInput.tenant ?? boundTenant,
+				locks: saveInput.locks ?? boundLocks,
+				signal: saveInput.signal,
+				adapterName: saveInput.adapterName
+			});
+		},
+		fork(forkInput) {
+			return forkFromSandboxSnapshot({
+				threadId: forkInput.threadId,
+				checkpointId: forkInput.checkpointId,
+				destinationThreadId: forkInput.destinationThreadId,
+				checkpoints,
+				destinationCheckpointId: forkInput.destinationCheckpointId,
+				createdAt: forkInput.createdAt
+			});
+		},
+		readArtifact(readInput) {
+			return resolveSnapshotArtifact({
+				threadId: readInput.threadId,
+				checkpointId: readInput.checkpointId,
+				artifactId: readInput.artifactId,
+				persistence,
+				checkpoints
+			});
+		}
+	};
+}
+async function saveNamedSandboxSnapshot(input) {
+	const definition = input.definition;
+	const threadId = input.threadId;
+	const runId = input.runId;
+	const instances = stageInstanceStore(input.instances);
+	const label = input.label;
+	const suppliedTenant = input.tenant;
+	const tenantUserId = suppliedTenant?.userId;
+	const tenantOrgId = suppliedTenant?.orgId;
+	const tenant = suppliedTenant ? {
+		...tenantUserId === void 0 ? {} : { userId: tenantUserId },
+		...tenantOrgId === void 0 ? {} : { orgId: tenantOrgId }
+	} : void 0;
+	const locks = stageLockStore(input.locks);
+	const signal = input.signal;
+	const adapterName = input.adapterName;
+	const lifecycle = definition.lifecycle;
+	const reuse = lifecycle?.reuse;
+	const snapshotMaxAge = lifecycle?.snapshotMaxAge;
+	const workspace = stageWorkspace(definition.workspace);
+	const sandboxId = definition.id;
+	const provider = definition.provider;
+	const providerName = provider.name;
+	const resume = provider.resume.bind(provider);
+	const ensureExisting = stageEnsureExistingSandbox(definition);
+	const stores = input.persistence.stores;
+	const messages = stores.messages;
+	const loadThread = messages.loadThread.bind(messages);
+	const artifactStore = stores.artifacts;
+	const listForThread = artifactStore.listForThread.bind(artifactStore);
+	const suppliedBlobs = stores.blobs;
+	const blobs = {
+		get: suppliedBlobs.get.bind(suppliedBlobs),
+		head: suppliedBlobs.head.bind(suppliedBlobs),
+		put: suppliedBlobs.put.bind(suppliedBlobs)
+	};
+	const checkpoints = input.checkpoints;
+	const acquireWriter = checkpoints.acquireWriter.bind(checkpoints);
+	const getHead = checkpoints.getHead.bind(checkpoints);
+	const append = checkpoints.append.bind(checkpoints);
+	const policy = effectivePolicy(input.policy, workspace === void 0 ? void 0 : computeWorkspaceHash(workspace));
+	const workspaceSecrets = workspace?.secrets;
+	const secrets = workspaceSecrets ? resolveAllSecrets(workspaceSecrets) : {};
+	const workspaceRoot = workspace?.root;
+	const key = computeSandboxKey({
+		threadId,
+		sandboxId,
+		providerName,
+		workspace,
+		tenant
+	});
+	return withWriterLease(() => acquireWriter(threadId), true, async (writer, throwIfLost) => {
+		if (reuse === "none") throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_REUSE_NONE", "Named snapshots require a reusable sandbox lifecycle");
+		const handle = await ensureExisting({
+			threadId,
+			runId,
+			store: instances,
+			locks,
+			tenant,
+			signal,
+			adapterName
+		}, {
+			key,
+			workspace,
+			resolvedSecrets: workspaceSecrets ? secrets : void 0,
+			snapshotMaxAge,
+			resume
+		});
+		if (!handle) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_MISSING_REUSABLE_SANDBOX", "Named snapshots require an existing resumable sandbox");
+		const conversation = await loadThread(threadId);
+		const files = await captureSandboxFiles(handle, {
+			blobs,
+			workspaceRoot
+		}, policy, secrets);
+		const artifacts = await captureSandboxArtifacts({
+			blobs,
+			artifacts: { listForThread }
+		}, threadId, secrets);
+		const parentCheckpointId = await getHead(threadId);
+		await throwIfLost();
+		const checkpoint = {
+			id: crypto.randomUUID(),
+			threadId,
+			parentCheckpointId,
+			createdAt: Date.now(),
+			reason: "named",
+			label,
+			sourceRunId: runId,
+			files: files.files,
+			conversation,
+			artifacts
+		};
+		await append({
+			checkpoint,
+			expectedHeadId: parentCheckpointId,
+			writer
+		});
+		await throwIfLost();
+		return checkpoint;
+	});
+}
+async function forkFromSandboxSnapshot(input) {
+	const sourceThreadId = input.threadId;
+	const sourceCheckpointId = input.checkpointId;
+	const destinationThreadId = input.destinationThreadId;
+	const suppliedDestinationCheckpointId = input.destinationCheckpointId;
+	const suppliedCreatedAt = input.createdAt;
+	const destinationCheckpointId = suppliedDestinationCheckpointId ?? crypto.randomUUID();
+	const createdAt = suppliedCreatedAt ?? Date.now();
+	const checkpoints = input.checkpoints;
+	const acquireWriter = checkpoints.acquireWriter.bind(checkpoints);
+	const forkFromCheckpoint = checkpoints.forkFromCheckpoint?.bind(checkpoints);
+	return withWriterLease(() => acquireWriter(destinationThreadId), false, async (writer) => {
+		if (forkFromCheckpoint === void 0) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_FORK_UNAVAILABLE", "The checkpoint store does not support atomic forks");
+		return (await forkFromCheckpoint({
+			sourceThreadId,
+			sourceCheckpointId,
+			destinationThreadId,
+			destinationCheckpointId,
+			createdAt,
+			writer
+		})).checkpoint;
+	});
+}
+async function sha256(bytes) {
+	const digest = await crypto.subtle.digest("SHA-256", new Uint8Array(bytes));
+	return Array.from(new Uint8Array(digest), (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+async function resolveSnapshotArtifact(input) {
+	const threadId = input.threadId;
+	const checkpointId = input.checkpointId;
+	const artifactId = input.artifactId;
+	const checkpoints = input.checkpoints;
+	const getCheckpoint = checkpoints.get.bind(checkpoints);
+	const blobs = input.persistence.stores.blobs;
+	const getBlob = blobs.get.bind(blobs);
+	const checkpoint = await getCheckpoint(checkpointId);
+	if (!checkpoint) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_MISSING_CHECKPOINT_ARTIFACT", "Snapshot checkpoint does not exist");
+	const checkpointThreadId = checkpoint.threadId;
+	const checkpointArtifacts = checkpoint.artifacts;
+	if (checkpointThreadId !== threadId) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_FOREIGN_CHECKPOINT_ARTIFACT", "Snapshot checkpoint belongs to another thread");
+	const foundArtifact = checkpointArtifacts.find((value) => value.artifactId === artifactId);
+	if (!foundArtifact) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_MISSING_CHECKPOINT_ARTIFACT", "Snapshot artifact does not exist");
+	const artifact = {
+		artifactId: foundArtifact.artifactId,
+		name: foundArtifact.name,
+		mimeType: foundArtifact.mimeType,
+		size: foundArtifact.size,
+		blobKey: foundArtifact.blobKey,
+		createdAt: foundArtifact.createdAt
+	};
+	const blob = await getBlob(artifact.blobKey);
+	if (!blob) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_INVALID_ARTIFACT_BYTES", "Snapshot artifact blob does not exist");
+	const arrayBuffer = blob.arrayBuffer.bind(blob);
+	const bytes = new Uint8Array(await arrayBuffer());
+	if (bytes.byteLength !== artifact.size || artifact.blobKey !== `sandbox-artifacts/sha256/${await sha256(bytes)}`) throw new SandboxSnapshotError("SANDBOX_SNAPSHOT_INVALID_ARTIFACT_BYTES", "Snapshot artifact bytes do not match metadata");
+	return {
+		artifact: { ...artifact },
+		bytes: bytes.slice()
+	};
+}
+//#endregion
+export { createSandboxSnapshots };
+
+//# sourceMappingURL=snapshot-operations.js.map

package/dist/esm/snapshot-operations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"snapshot-operations.js","names":[],"sources":["../../src/snapshot-operations.ts"],"sourcesContent":["import {\n  captureSandboxArtifacts,\n  captureSandboxFiles,\n  resolveSandboxSnapshotPolicy,\n  SandboxSnapshotError,\n} from './snapshots'\nimport { resolveAllSecrets } from './secrets'\nimport { computeSandboxKey, computeWorkspaceHash } from './key'\nimport { stageEnsureExistingSandbox } from './sandbox'\nimport type { ModelMessage } from '@tanstack/ai'\nimport type { LockStore } from '@tanstack/ai/locks'\nimport type {\n  SandboxCheckpoint,\n  SandboxCheckpointStore,\n  SandboxCheckpointWriterLease,\n} from './checkpoint-store'\nimport type { SandboxInstanceStore } from './instance-store'\nimport type { SandboxDefinition } from './sandbox'\nimport type { SandboxSnapshotBundle, SandboxSnapshotPolicy } from './snapshots'\nimport type { WorkspaceDefinition } from './workspace'\n\nexport interface SnapshotPersistence {\n  stores: {\n    messages: {\n      loadThread: (threadId: string) => Promise<ReadonlyArray<ModelMessage>>\n    }\n    artifacts: NonNullable<SandboxSnapshotBundle['artifacts']>\n    blobs: SandboxSnapshotBundle['blobs']\n  }\n}\n\nexport interface CreateSandboxSnapshotsInput<\n  TPersistence extends SnapshotPersistence = SnapshotPersistence,\n  TCheckpoints extends SandboxCheckpointStore = SandboxCheckpointStore,\n> {\n  persistence: TPersistence\n  checkpoints: TCheckpoints\n  policy?: SandboxSnapshotPolicy\n  sandbox?: SandboxDefinition\n  instances?: SandboxInstanceStore\n  tenant?: { userId?: string; orgId?: string }\n  locks?: LockStore\n}\n\nexport interface SaveSandboxSnapshotInput {\n  threadId: string\n  runId: string\n  label: string\n  sandbox?: SandboxDefinition\n  instances?: SandboxInstanceStore\n  tenant?: { userId?: string; orgId?: string }\n  locks?: LockStore\n  signal?: AbortSignal\n  adapterName?: string\n}\n\nexport interface ForkSandboxSnapshotInput {\n  threadId: string\n  checkpointId: string\n  destinationThreadId: string\n  destinationCheckpointId?: string\n  createdAt?: number\n}\n\nexport interface ReadSandboxSnapshotArtifactInput {\n  threadId: string\n  checkpointId: string\n  artifactId: string\n}\n\nexport interface SandboxSnapshots<\n  TPersistence extends SnapshotPersistence = SnapshotPersistence,\n  TCheckpoints extends SandboxCheckpointStore = SandboxCheckpointStore,\n> {\n  persistence: TPersistence\n  checkpoints: TCheckpoints\n  policy?: SandboxSnapshotPolicy\n  save: (input: SaveSandboxSnapshotInput) => Promise<SandboxCheckpoint>\n  fork: (input: ForkSandboxSnapshotInput) => Promise<SandboxCheckpoint>\n  readArtifact: (input: ReadSandboxSnapshotArtifactInput) => Promise<{\n    artifact: SandboxCheckpoint['artifacts'][number]\n    bytes: Uint8Array\n  }>\n}\n\ntype Failure = { error: unknown }\n\nasync function withWriterLease<T>(\n  acquire: () => Promise<SandboxCheckpointWriterLease>,\n  renew: boolean,\n  operation: (\n    writer: SandboxCheckpointWriterLease,\n    throwIfLost: () => Promise<void>,\n  ) => Promise<T>,\n): Promise<T> {\n  const writer = await acquire()\n  const release = writer.release.bind(writer)\n  const renewWriter = renew ? writer.renew.bind(writer) : undefined\n  const renewAfterMs = renew ? writer.renewAfterMs : undefined\n  let renewalTimer: ReturnType<typeof setTimeout> | undefined\n  let renewalTask: Promise<void> | undefined\n  let renewalFailure: Failure | undefined\n  let stopped = false\n\n  const scheduleRenewal = (): void => {\n    if (renewWriter === undefined || renewAfterMs === undefined) return\n    renewalTimer = setTimeout(() => {\n      renewalTimer = undefined\n      renewalTask = (async () => {\n        try {\n          await renewWriter()\n        } catch (error) {\n          renewalFailure = { error }\n        } finally {\n          renewalTask = undefined\n        }\n        if (!stopped && renewalFailure === undefined) scheduleRenewal()\n      })()\n    }, renewAfterMs)\n  }\n  if (renew) scheduleRenewal()\n\n  const throwIfLost = async (): Promise<void> => {\n    await renewalTask\n    if (renewalFailure !== undefined) throw renewalFailure.error\n  }\n\n  let outcome: { value: T } | undefined\n  let operationFailure: Failure | undefined\n  try {\n    outcome = { value: await operation(writer, throwIfLost) }\n  } catch (error) {\n    operationFailure = { error }\n  }\n\n  stopped = true\n  if (renewalTimer !== undefined) clearTimeout(renewalTimer)\n  await renewalTask\n  let releaseFailure: Failure | undefined\n  try {\n    await release()\n  } catch (error) {\n    releaseFailure = { error }\n  }\n\n  if (renewalFailure !== undefined) throw renewalFailure.error\n  if (operationFailure !== undefined) throw operationFailure.error\n  if (releaseFailure !== undefined) throw releaseFailure.error\n  if (outcome === undefined) throw new Error('Writer operation had no outcome')\n  return outcome.value\n}\n\nfunction stageWorkspace(\n  workspace: WorkspaceDefinition | undefined,\n): WorkspaceDefinition | undefined {\n  if (workspace === undefined) return undefined\n  const source = workspace.source\n  const packageManager = workspace.packageManager\n  const setup = workspace.setup\n  const scripts = workspace.scripts\n  const skills = workspace.skills\n  const instructions = workspace.instructions\n  const plugins = workspace.plugins\n  const secrets = workspace.secrets\n  const root = workspace.root\n  return {\n    source,\n    ...(Object.hasOwn(workspace, 'packageManager') ? { packageManager } : {}),\n    ...(Object.hasOwn(workspace, 'setup') ? { setup } : {}),\n    ...(Object.hasOwn(workspace, 'scripts') ? { scripts } : {}),\n    ...(Object.hasOwn(workspace, 'skills') ? { skills } : {}),\n    ...(Object.hasOwn(workspace, 'instructions') ? { instructions } : {}),\n    ...(Object.hasOwn(workspace, 'plugins') ? { plugins } : {}),\n    ...(Object.hasOwn(workspace, 'secrets') ? { secrets } : {}),\n    ...(Object.hasOwn(workspace, 'root') ? { root } : {}),\n  }\n}\n\nfunction effectivePolicy(\n  supplied: SandboxSnapshotPolicy | undefined,\n  workspaceHash: string | undefined,\n): SandboxSnapshotPolicy {\n  return resolveSandboxSnapshotPolicy(supplied, workspaceHash)\n}\n\nfunction stageInstanceStore(store: SandboxInstanceStore): SandboxInstanceStore {\n  const get = store.get.bind(store)\n  const upsert = store.upsert.bind(store)\n  const deleteRecord = store.delete.bind(store)\n  return { get, upsert, delete: deleteRecord }\n}\n\nfunction stageLockStore(locks: LockStore | undefined): LockStore | undefined {\n  if (locks === undefined) return undefined\n  const withLock = locks.withLock.bind(locks)\n  return { withLock }\n}\n\nfunction requireSnapshotPersistence<TPersistence extends SnapshotPersistence>(\n  persistence: TPersistence,\n): TPersistence {\n  const stores = persistence.stores\n  if (!stores?.messages || !stores.artifacts || !stores.blobs) {\n    throw new SandboxSnapshotError(\n      'SANDBOX_SNAPSHOT_MISSING_PERSISTENCE_STORES',\n      'Sandbox snapshots require persistence stores.messages, stores.artifacts, and stores.blobs',\n    )\n  }\n  return persistence\n}\n\nexport function createSandboxSnapshots<\n  TPersistence extends SnapshotPersistence,\n  TCheckpoints extends SandboxCheckpointStore,\n>(\n  input: CreateSandboxSnapshotsInput<TPersistence, TCheckpoints>,\n): SandboxSnapshots<TPersistence, TCheckpoints> {\n  const persistence = requireSnapshotPersistence(input.persistence)\n  const checkpoints = input.checkpoints\n  const policy = input.policy\n  const boundSandbox = input.sandbox\n  const boundInstances = input.instances\n  const boundTenant = input.tenant\n  const boundLocks = input.locks\n\n  return {\n    persistence,\n    checkpoints,\n    ...(policy === undefined ? {} : { policy }),\n    async save(saveInput) {\n      const sandbox = saveInput.sandbox ?? boundSandbox\n      const instances = saveInput.instances ?? boundInstances\n      if (sandbox === undefined)\n        throw new SandboxSnapshotError(\n          'SANDBOX_SNAPSHOT_MISSING_SANDBOX',\n          'Named snapshots require a sandbox at create time or on save',\n        )\n      if (instances === undefined)\n        throw new SandboxSnapshotError(\n          'SANDBOX_SNAPSHOT_MISSING_INSTANCES',\n          'Named snapshots require instances at create time or on save',\n        )\n      return saveNamedSandboxSnapshot({\n        definition: sandbox,\n        threadId: saveInput.threadId,\n        runId: saveInput.runId,\n        instances,\n        persistence,\n        checkpoints,\n        policy,\n        label: saveInput.label,\n        tenant: saveInput.tenant ?? boundTenant,\n        locks: saveInput.locks ?? boundLocks,\n        signal: saveInput.signal,\n        adapterName: saveInput.adapterName,\n      })\n    },\n    fork(forkInput) {\n      return forkFromSandboxSnapshot({\n        threadId: forkInput.threadId,\n        checkpointId: forkInput.checkpointId,\n        destinationThreadId: forkInput.destinationThreadId,\n        checkpoints,\n        destinationCheckpointId: forkInput.destinationCheckpointId,\n        createdAt: forkInput.createdAt,\n      })\n    },\n    readArtifact(readInput) {\n      return resolveSnapshotArtifact({\n        threadId: readInput.threadId,\n        checkpointId: readInput.checkpointId,\n        artifactId: readInput.artifactId,\n        persistence,\n        checkpoints,\n      })\n    },\n  }\n}\n\nasync function saveNamedSandboxSnapshot(input: {\n  definition: SandboxDefinition\n  threadId: string\n  runId: string\n  instances: SandboxInstanceStore\n  persistence: SnapshotPersistence\n  checkpoints: SandboxCheckpointStore\n  policy?: SandboxSnapshotPolicy\n  label: string\n  tenant?: { userId?: string; orgId?: string }\n  locks?: LockStore\n  signal?: AbortSignal\n  adapterName?: string\n}): Promise<SandboxCheckpoint> {\n  const definition = input.definition\n  const threadId = input.threadId\n  const runId = input.runId\n  const instances = stageInstanceStore(input.instances)\n  const label = input.label\n  const suppliedTenant = input.tenant\n  const tenantUserId = suppliedTenant?.userId\n  const tenantOrgId = suppliedTenant?.orgId\n  const tenant = suppliedTenant\n    ? {\n        ...(tenantUserId === undefined ? {} : { userId: tenantUserId }),\n        ...(tenantOrgId === undefined ? {} : { orgId: tenantOrgId }),\n      }\n    : undefined\n  const locks = stageLockStore(input.locks)\n  const signal = input.signal\n  const adapterName = input.adapterName\n  const lifecycle = definition.lifecycle\n  const reuse = lifecycle?.reuse\n  const snapshotMaxAge = lifecycle?.snapshotMaxAge\n  const workspace = stageWorkspace(definition.workspace)\n  const sandboxId = definition.id\n  const provider = definition.provider\n  const providerName = provider.name\n  const resume = provider.resume.bind(provider)\n  const ensureExisting = stageEnsureExistingSandbox(definition)\n  const persistence = input.persistence\n  const stores = persistence.stores\n  const messages = stores.messages\n  const loadThread = messages.loadThread.bind(messages)\n  const artifactStore = stores.artifacts\n  const listForThread = artifactStore.listForThread.bind(artifactStore)\n  const suppliedBlobs = stores.blobs\n  const getBlob = suppliedBlobs.get.bind(suppliedBlobs)\n  const headBlob = suppliedBlobs.head.bind(suppliedBlobs)\n  const putBlob = suppliedBlobs.put.bind(suppliedBlobs)\n  const blobs: SandboxSnapshotBundle['blobs'] = {\n    get: getBlob,\n    head: headBlob,\n    put: putBlob,\n  }\n  const checkpoints = input.checkpoints\n  const acquireWriter = checkpoints.acquireWriter.bind(checkpoints)\n  const getHead = checkpoints.getHead.bind(checkpoints)\n  const append = checkpoints.append.bind(checkpoints)\n  const policy = effectivePolicy(\n    input.policy,\n    workspace === undefined ? undefined : computeWorkspaceHash(workspace),\n  )\n  const workspaceSecrets = workspace?.secrets\n  const secrets = workspaceSecrets ? resolveAllSecrets(workspaceSecrets) : {}\n  const workspaceRoot = workspace?.root\n  const key = computeSandboxKey({\n    threadId,\n    sandboxId,\n    providerName,\n    workspace,\n    tenant,\n  })\n\n  return withWriterLease(\n    () => acquireWriter(threadId),\n    true,\n    async (writer, throwIfLost) => {\n      if (reuse === 'none')\n        throw new SandboxSnapshotError(\n          'SANDBOX_SNAPSHOT_REUSE_NONE',\n          'Named snapshots require a reusable sandbox lifecycle',\n        )\n      const handle = await ensureExisting(\n        {\n          threadId,\n          runId,\n          store: instances,\n          locks,\n          tenant,\n          signal,\n          adapterName,\n        },\n        {\n          key,\n          workspace,\n          resolvedSecrets: workspaceSecrets ? secrets : undefined,\n          snapshotMaxAge,\n          resume,\n        },\n      )\n      if (!handle)\n        throw new SandboxSnapshotError(\n          'SANDBOX_SNAPSHOT_MISSING_REUSABLE_SANDBOX',\n          'Named snapshots require an existing resumable sandbox',\n        )\n      const conversation = await loadThread(threadId)\n      const files = await captureSandboxFiles(\n        handle,\n        { blobs, workspaceRoot },\n        policy,\n        secrets,\n      )\n      const artifacts = await captureSandboxArtifacts(\n        {\n          blobs,\n          artifacts: { listForThread },\n        },\n        threadId,\n        secrets,\n      )\n      const parentCheckpointId = await getHead(threadId)\n      await throwIfLost()\n      const checkpoint: SandboxCheckpoint = {\n        id: crypto.randomUUID(),\n        threadId,\n        parentCheckpointId,\n        createdAt: Date.now(),\n        reason: 'named',\n        label,\n        sourceRunId: runId,\n        files: files.files,\n        conversation,\n        artifacts,\n      }\n      await append({\n        checkpoint,\n        expectedHeadId: parentCheckpointId,\n        writer,\n      })\n      await throwIfLost()\n      return checkpoint\n    },\n  )\n}\n\nasync function forkFromSandboxSnapshot(input: {\n  threadId: string\n  checkpointId: string\n  destinationThreadId: string\n  checkpoints: SandboxCheckpointStore\n  destinationCheckpointId?: string\n  createdAt?: number\n}): Promise<SandboxCheckpoint> {\n  const sourceThreadId = input.threadId\n  const sourceCheckpointId = input.checkpointId\n  const destinationThreadId = input.destinationThreadId\n  const suppliedDestinationCheckpointId = input.destinationCheckpointId\n  const suppliedCreatedAt = input.createdAt\n  const destinationCheckpointId =\n    suppliedDestinationCheckpointId ?? crypto.randomUUID()\n  const createdAt = suppliedCreatedAt ?? Date.now()\n  const checkpoints = input.checkpoints\n  const acquireWriter = checkpoints.acquireWriter.bind(checkpoints)\n  const forkFromCheckpoint = checkpoints.forkFromCheckpoint?.bind(checkpoints)\n\n  return withWriterLease(\n    () => acquireWriter(destinationThreadId),\n    false,\n    async (writer) => {\n      if (forkFromCheckpoint === undefined)\n        throw new SandboxSnapshotError(\n          'SANDBOX_SNAPSHOT_FORK_UNAVAILABLE',\n          'The checkpoint store does not support atomic forks',\n        )\n      const result = await forkFromCheckpoint({\n        sourceThreadId,\n        sourceCheckpointId,\n        destinationThreadId,\n        destinationCheckpointId,\n        createdAt,\n        writer,\n      })\n      return result.checkpoint\n    },\n  )\n}\n\nasync function sha256(bytes: Uint8Array): Promise<string> {\n  const digest = await crypto.subtle.digest('SHA-256', new Uint8Array(bytes))\n  return Array.from(new Uint8Array(digest), (byte) =>\n    byte.toString(16).padStart(2, '0'),\n  ).join('')\n}\n\nasync function resolveSnapshotArtifact(input: {\n  threadId: string\n  checkpointId: string\n  artifactId: string\n  persistence: SnapshotPersistence\n  checkpoints: SandboxCheckpointStore\n}): Promise<{\n  artifact: SandboxCheckpoint['artifacts'][number]\n  bytes: Uint8Array\n}> {\n  const threadId = input.threadId\n  const checkpointId = input.checkpointId\n  const artifactId = input.artifactId\n  const checkpoints = input.checkpoints\n  const getCheckpoint = checkpoints.get.bind(checkpoints)\n  const persistence = input.persistence\n  const stores = persistence.stores\n  const blobs = stores.blobs\n  const getBlob = blobs.get.bind(blobs)\n  const checkpoint = await getCheckpoint(checkpointId)\n  if (!checkpoint)\n    throw new SandboxSnapshotError(\n      'SANDBOX_SNAPSHOT_MISSING_CHECKPOINT_ARTIFACT',\n      'Snapshot checkpoint does not exist',\n    )\n  const checkpointThreadId = checkpoint.threadId\n  const checkpointArtifacts = checkpoint.artifacts\n  if (checkpointThreadId !== threadId)\n    throw new SandboxSnapshotError(\n      'SANDBOX_SNAPSHOT_FOREIGN_CHECKPOINT_ARTIFACT',\n      'Snapshot checkpoint belongs to another thread',\n    )\n  const foundArtifact = checkpointArtifacts.find(\n    (value) => value.artifactId === artifactId,\n  )\n  if (!foundArtifact)\n    throw new SandboxSnapshotError(\n      'SANDBOX_SNAPSHOT_MISSING_CHECKPOINT_ARTIFACT',\n      'Snapshot artifact does not exist',\n    )\n  const artifact = {\n    artifactId: foundArtifact.artifactId,\n    name: foundArtifact.name,\n    mimeType: foundArtifact.mimeType,\n    size: foundArtifact.size,\n    blobKey: foundArtifact.blobKey,\n    createdAt: foundArtifact.createdAt,\n  }\n  const blob = await getBlob(artifact.blobKey)\n  if (!blob)\n    throw new SandboxSnapshotError(\n      'SANDBOX_SNAPSHOT_INVALID_ARTIFACT_BYTES',\n      'Snapshot artifact blob does not exist',\n    )\n  const arrayBuffer = blob.arrayBuffer.bind(blob)\n  const bytes = new Uint8Array(await arrayBuffer())\n  if (\n    bytes.byteLength !== artifact.size ||\n    artifact.blobKey !== `sandbox-artifacts/sha256/${await sha256(bytes)}`\n  )\n    throw new SandboxSnapshotError(\n      'SANDBOX_SNAPSHOT_INVALID_ARTIFACT_BYTES',\n      'Snapshot artifact bytes do not match metadata',\n    )\n  return { artifact: { ...artifact }, bytes: bytes.slice() }\n}\n"],"mappings":"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"}

package/dist/esm/snapshot-tools.d.ts

@@ -0,0 +1,185 @@
+import { SandboxSnapshots } from './snapshot-operations.js';
+export interface CreateSnapshotToolsOptions {
+    threadId: string;
+    runId: string;
+    createThreadId: () => string;
+    tenant?: {
+        userId?: string;
+        orgId?: string;
+    };
+    onForked?: (input: {
+        destinationThreadId: string;
+        checkpointId: string;
+    }) => void | Promise<void>;
+}
+export declare function createSnapshotTools(snapshots: SandboxSnapshots, options: CreateSnapshotToolsOptions): readonly [import('@tanstack/ai').ServerTool<{
+    type: string;
+    properties: {
+        label: {
+            type: string;
+            description: string;
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+}, {
+    type: string;
+    properties: {
+        checkpointId: {
+            type: string;
+        };
+        label: {
+            type: string;
+        };
+        threadId: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+}, "save_sandbox_snapshot", unknown, false, undefined> & {
+    inputSchema: {
+        type: string;
+        properties: {
+            label: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchema: {
+        type: string;
+        properties: {
+            checkpointId: {
+                type: string;
+            };
+            label: {
+                type: string;
+            };
+            threadId: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: false;
+    };
+    approvalSchema: undefined;
+}, import('@tanstack/ai').ServerTool<{
+    type: string;
+    properties: {
+        checkpointId: {
+            type: string;
+            description: string;
+        };
+    };
+    additionalProperties: false;
+}, {
+    type: string;
+    properties: {
+        checkpointId: {
+            type: string;
+        };
+        destinationThreadId: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+}, "fork_sandbox_snapshot", unknown, false, undefined> & {
+    inputSchema: {
+        type: string;
+        properties: {
+            checkpointId: {
+                type: string;
+                description: string;
+            };
+        };
+        additionalProperties: false;
+    };
+    outputSchema: {
+        type: string;
+        properties: {
+            checkpointId: {
+                type: string;
+            };
+            destinationThreadId: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: false;
+    };
+    approvalSchema: undefined;
+}, import('@tanstack/ai').ServerTool<{
+    type: string;
+    properties: {
+        checkpointId: {
+            type: string;
+        };
+        artifactId: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+}, {
+    type: string;
+    properties: {
+        artifactId: {
+            type: string;
+        };
+        name: {
+            type: string;
+        };
+        mimeType: {
+            type: string;
+        };
+        size: {
+            type: string;
+        };
+        createdAt: {
+            type: string;
+        };
+    };
+    required: string[];
+    additionalProperties: false;
+}, "read_sandbox_snapshot_artifact", unknown, false, undefined> & {
+    inputSchema: {
+        type: string;
+        properties: {
+            checkpointId: {
+                type: string;
+            };
+            artifactId: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: false;
+    };
+    outputSchema: {
+        type: string;
+        properties: {
+            artifactId: {
+                type: string;
+            };
+            name: {
+                type: string;
+            };
+            mimeType: {
+                type: string;
+            };
+            size: {
+                type: string;
+            };
+            createdAt: {
+                type: string;
+            };
+        };
+        required: string[];
+        additionalProperties: false;
+    };
+    approvalSchema: undefined;
+}];