@agentuity/server 0.0.110 → 0.0.112

package/dist/schema.js

@@ -12,7 +12,9 @@ export const toJSONSchema = (schema) => {
         return agentuityToJSONSchema(schema);
     }
     // Check if it's a Zod schema
-    if (schema?._def?.typeName) {
+    // Zod 3 uses _def.typeName (e.g., "ZodObject")
+    // Zod 4 uses _def.type (e.g., "object")
+    if (schema?._def?.typeName || schema?._def?.type) {
         try {
             return z.toJSONSchema(schema);
         }

package/dist/schema.js.map

@@ -1 +1 @@
-{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,IAAI,qBAAqB,EAAmB,MAAM,mBAAmB,CAAC;AAE3F;;;;GAIG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAW,EAAc,EAAE;IACvD,gEAAgE;IAChE,IAAI,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;QACnD,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,6BAA6B;IAC7B,IAAI,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC;QAC5B,IAAI,CAAC;YACJ,OAAO,CAAC,CAAC,YAAY,CAAC,MAAM,CAAe,CAAC;QAC7C,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,EAAE,CAAC;QACX,CAAC;IACF,CAAC;IACD,sBAAsB;IACtB,OAAO,EAAE,CAAC;AACX,CAAC,CAAC"}
+{"version":3,"file":"schema.js","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAAE,YAAY,IAAI,qBAAqB,EAAmB,MAAM,mBAAmB,CAAC;AAE3F;;;;GAIG;AACH,8DAA8D;AAC9D,MAAM,CAAC,MAAM,YAAY,GAAG,CAAC,MAAW,EAAc,EAAE;IACvD,gEAAgE;IAChE,IAAI,MAAM,EAAE,CAAC,WAAW,CAAC,EAAE,MAAM,KAAK,WAAW,EAAE,CAAC;QACnD,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;IACD,6BAA6B;IAC7B,+CAA+C;IAC/C,wCAAwC;IACxC,IAAI,MAAM,EAAE,IAAI,EAAE,QAAQ,IAAI,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;QAClD,IAAI,CAAC;YACJ,OAAO,CAAC,CAAC,YAAY,CAAC,MAAM,CAAe,CAAC;QAC7C,CAAC;QAAC,MAAM,CAAC;YACR,OAAO,EAAE,CAAC;QACX,CAAC;IACF,CAAC;IACD,sBAAsB;IACtB,OAAO,EAAE,CAAC;AACX,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@agentuity/server",
-	"version": "0.0.110",
+	"version": "0.0.112",
 	"license": "Apache-2.0",
 	"author": "Agentuity employees and contributors",
 	"type": "module",
@@ -25,12 +25,12 @@
 		"prepublishOnly": "bun run clean && bun run build"
 	},
 	"dependencies": {
-		"@agentuity/core": "0.0.110",
-		"@agentuity/schema": "0.0.110",
-		"zod": "^4.1.12"
+		"@agentuity/core": "0.0.112",
+		"@agentuity/schema": "0.0.112",
+		"zod": "^4.3.5"
 	},
 	"devDependencies": {
-		"@agentuity/test-utils": "0.0.110",
+		"@agentuity/test-utils": "0.0.112",
 		"@types/bun": "latest",
 		"@types/node": "^22.0.0",
 		"bun-types": "latest",

package/src/api/api.ts

@@ -186,6 +186,19 @@ export class APIClient {
 		return this.#makeRequest('GET', endpoint, undefined, signal);
 	}
 
+	/**
+	 * Raw POST request that returns the Response object directly.
+	 * Useful for binary uploads where you need to pass raw body data.
+	 */
+	async rawPost(
+		endpoint: string,
+		body: Uint8Array | ArrayBuffer | ReadableStream<Uint8Array> | string,
+		contentType: string,
+		signal?: AbortSignal
+	): Promise<Response> {
+		return this.#makeRequest('POST', endpoint, body, signal, contentType);
+	}
+
 	/**
 	 * Generic request method (prefer HTTP verb methods: get, post, put, delete, patch)
 	 */
@@ -249,7 +262,8 @@ export class APIClient {
 		method: string,
 		endpoint: string,
 		body?: unknown,
-		signal?: AbortSignal
+		signal?: AbortSignal,
+		contentType?: string
 	): Promise<Response> {
 		this.#logger.trace('sending %s to %s%s', method, this.#baseUrl, endpoint);
 
@@ -260,10 +274,14 @@ export class APIClient {
 			try {
 				const url = `${this.#baseUrl}${endpoint}`;
 				const headers: Record<string, string> = {
-					'Content-Type': 'application/json',
-					Accept: 'application/json',
+					'Content-Type': contentType ?? 'application/json',
 				};
 
+				// Only set Accept header for JSON requests (not binary uploads)
+				if (!contentType || contentType === 'application/json') {
+					headers['Accept'] = 'application/json';
+				}
+
 				if (this.#config?.userAgent) {
 					headers['User-Agent'] = this.#config.userAgent;
 				}
@@ -281,10 +299,28 @@ export class APIClient {
 				let response: Response;
 
 				try {
+					let requestBody:
+						| Uint8Array
+						| ArrayBuffer
+						| ReadableStream<Uint8Array>
+						| string
+						| undefined;
+					if (body !== undefined) {
+						if (contentType && contentType !== 'application/json') {
+							requestBody = body as
+								| Uint8Array
+								| ArrayBuffer
+								| ReadableStream<Uint8Array>
+								| string;
+						} else {
+							requestBody = JSON.stringify(body);
+						}
+					}
+
 					response = await fetch(url, {
 						method,
 						headers,
-						body: body !== undefined ? JSON.stringify(body) : undefined,
+						body: requestBody,
 						signal,
 					});
 				} catch (ex) {

package/src/api/project/deploy.ts

@@ -33,7 +33,7 @@ const BaseFileFields = {
 const EvalSchema = z.object({
 	...BaseFileFields,
 	id: z.string().describe('the unique calculated id for the eval'),
-	evalId: z.string().describe('the unique id for eval for the project across deployments'),
+	identifier: z.string().describe('the unique id for eval for the project across deployments'),
 	name: z.string().describe('the name of the eval'),
 	description: z.string().optional().describe('the eval description'),
 	agentIdentifier: z.string().describe('the identifier of the agent'),
@@ -164,6 +164,10 @@ const CreateProjectDeployment = z.object({
 	id: z.string().describe('the unique id for the deployment'),
 	orgId: z.string().describe('the organization id'),
 	publicKey: z.string().describe('the public key to use for encrypting the deployment'),
+	buildLogsStreamURL: z
+		.string()
+		.optional()
+		.describe('the URL for streaming build logs (PUT to write, GET to read)'),
 });
 
 const CreateProjectDeploymentSchema = APIResponseSchema(CreateProjectDeployment);
@@ -314,3 +318,95 @@ export async function projectDeploymentStatus(
 	}
 	throw new ProjectResponseError({ message: resp.message });
 }
+
+export interface ClientDiagnosticsError {
+	type: 'file' | 'general';
+	scope: 'typescript' | 'ast' | 'build' | 'bundler' | 'validation' | 'deploy';
+	path?: string;
+	line?: number;
+	column?: number;
+	message: string;
+	code?: string;
+}
+
+export interface ClientDiagnosticsTiming {
+	name: string;
+	startedAt: string;
+	completedAt: string;
+	durationMs: number;
+}
+
+export interface ClientDiagnostics {
+	success: boolean;
+	errors: ClientDiagnosticsError[];
+	warnings: ClientDiagnosticsError[];
+	diagnostics: ClientDiagnosticsTiming[];
+	error?: string;
+}
+
+export interface DeploymentFailPayload {
+	error?: string;
+	diagnostics?: ClientDiagnostics;
+}
+
+const ClientDiagnosticsErrorSchema = z.object({
+	type: z.enum(['file', 'general']),
+	scope: z.enum(['typescript', 'ast', 'build', 'bundler', 'validation', 'deploy']),
+	path: z.string().optional(),
+	line: z.number().optional(),
+	column: z.number().optional(),
+	message: z.string(),
+	code: z.string().optional(),
+});
+
+const ClientDiagnosticsTimingSchema = z.object({
+	name: z.string(),
+	startedAt: z.string(),
+	completedAt: z.string(),
+	durationMs: z.number(),
+});
+
+const ClientDiagnosticsSchema = z.object({
+	success: z.boolean(),
+	errors: z.array(ClientDiagnosticsErrorSchema),
+	warnings: z.array(ClientDiagnosticsErrorSchema),
+	diagnostics: z.array(ClientDiagnosticsTimingSchema),
+	error: z.string().optional(),
+});
+
+const DeploymentFailPayloadSchema = z.object({
+	error: z.string().optional(),
+	diagnostics: ClientDiagnosticsSchema.optional(),
+});
+
+const DeploymentFailResponseObject = z.object({
+	state: z.literal('failed'),
+});
+
+const DeploymentFailResponseSchema = APIResponseSchema(DeploymentFailResponseObject);
+type DeploymentFailResponse = z.infer<typeof DeploymentFailResponseSchema>;
+
+/**
+ * Report a deployment failure from the client
+ *
+ * @param client
+ * @param deploymentId
+ * @param payload - Error message and/or structured diagnostics
+ * @returns
+ */
+export async function projectDeploymentFail(
+	client: APIClient,
+	deploymentId: string,
+	payload: DeploymentFailPayload
+): Promise<void> {
+	const resp = await client.request<DeploymentFailResponse, DeploymentFailPayload>(
+		'POST',
+		`/cli/deploy/1/fail/${deploymentId}`,
+		DeploymentFailResponseSchema,
+		payload,
+		DeploymentFailPayloadSchema
+	);
+	if (!resp.success) {
+		throw new ProjectResponseError({ message: resp.message });
+	}
+}

package/src/api/sandbox/create.ts

@@ -65,6 +65,10 @@ const SandboxCreateRequestSchema = z
 			.array(z.string())
 			.optional()
 			.describe('Apt packages to install when creating the sandbox'),
+		metadata: z
+			.record(z.string(), z.unknown())
+			.optional()
+			.describe('Optional user-defined metadata to associate with the sandbox'),
 	})
 	.describe('Request body for creating a new sandbox');
 
@@ -143,6 +147,9 @@ export async function sandboxCreate(
 	if (options.dependencies && options.dependencies.length > 0) {
 		body.dependencies = options.dependencies;
 	}
+	if (options.metadata) {
+		body.metadata = options.metadata;
+	}
 
 	const queryParams = new URLSearchParams();
 	if (orgId) {

package/src/api/sandbox/files.ts

@@ -136,3 +136,453 @@ export async function sandboxReadFile(
 
 	return response.body;
 }
+
+const MkDirRequestSchema = z
+	.object({
+		path: z.string().describe('Path to the directory to create'),
+		recursive: z.boolean().optional().describe('Create parent directories if needed'),
+	})
+	.describe('Request body for creating a directory');
+
+const MkDirResponseSchema = z.discriminatedUnion('success', [
+	z.object({
+		success: z.literal<false>(false),
+		message: z.string().describe('the error message'),
+	}),
+	z.object({
+		success: z.literal<true>(true),
+	}),
+]);
+
+export interface MkDirParams {
+	sandboxId: string;
+	path: string;
+	recursive?: boolean;
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+/**
+ * Creates a directory in a sandbox workspace.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID, path, and recursive flag
+ * @throws {SandboxResponseError} If the mkdir request fails
+ */
+export async function sandboxMkDir(client: APIClient, params: MkDirParams): Promise<void> {
+	const { sandboxId, path, recursive, orgId, signal } = params;
+
+	const body: z.infer<typeof MkDirRequestSchema> = {
+		path,
+		recursive: recursive ?? false,
+	};
+
+	const queryParams = new URLSearchParams();
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/fs/${API_VERSION}/mkdir/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.post<z.infer<typeof MkDirResponseSchema>>(
+		url,
+		body,
+		MkDirResponseSchema,
+		MkDirRequestSchema,
+		signal
+	);
+
+	if (!resp.success) {
+		throw new SandboxResponseError({ message: resp.message, sandboxId });
+	}
+}
+
+const RmDirRequestSchema = z
+	.object({
+		path: z.string().describe('Path to the directory to remove'),
+		recursive: z.boolean().optional().describe('Remove directory and all contents'),
+	})
+	.describe('Request body for removing a directory');
+
+const RmDirResponseSchema = z.discriminatedUnion('success', [
+	z.object({
+		success: z.literal<false>(false),
+		message: z.string().describe('the error message'),
+	}),
+	z.object({
+		success: z.literal<true>(true),
+	}),
+]);
+
+export interface RmDirParams {
+	sandboxId: string;
+	path: string;
+	recursive?: boolean;
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+/**
+ * Removes a directory from a sandbox workspace.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID, path, and recursive flag
+ * @throws {SandboxResponseError} If the rmdir request fails
+ */
+export async function sandboxRmDir(client: APIClient, params: RmDirParams): Promise<void> {
+	const { sandboxId, path, recursive, orgId, signal } = params;
+
+	const body: z.infer<typeof RmDirRequestSchema> = {
+		path,
+		recursive: recursive ?? false,
+	};
+
+	const queryParams = new URLSearchParams();
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/fs/${API_VERSION}/rmdir/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.post<z.infer<typeof RmDirResponseSchema>>(
+		url,
+		body,
+		RmDirResponseSchema,
+		RmDirRequestSchema,
+		signal
+	);
+
+	if (!resp.success) {
+		throw new SandboxResponseError({ message: resp.message, sandboxId });
+	}
+}
+
+const RmFileRequestSchema = z
+	.object({
+		path: z.string().describe('Path to the file to remove'),
+	})
+	.describe('Request body for removing a file');
+
+const RmFileResponseSchema = z.discriminatedUnion('success', [
+	z.object({
+		success: z.literal<false>(false),
+		message: z.string().describe('the error message'),
+	}),
+	z.object({
+		success: z.literal<true>(true),
+	}),
+]);
+
+export interface RmFileParams {
+	sandboxId: string;
+	path: string;
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+/**
+ * Removes a file from a sandbox workspace.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID and path
+ * @throws {SandboxResponseError} If the rm request fails
+ */
+export async function sandboxRmFile(client: APIClient, params: RmFileParams): Promise<void> {
+	const { sandboxId, path, orgId, signal } = params;
+
+	const body: z.infer<typeof RmFileRequestSchema> = {
+		path,
+	};
+
+	const queryParams = new URLSearchParams();
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/fs/${API_VERSION}/rm/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.post<z.infer<typeof RmFileResponseSchema>>(
+		url,
+		body,
+		RmFileResponseSchema,
+		RmFileRequestSchema,
+		signal
+	);
+
+	if (!resp.success) {
+		throw new SandboxResponseError({ message: resp.message, sandboxId });
+	}
+}
+
+const FileInfoSchema = z.object({
+	path: z.string().describe('File path relative to the listed directory'),
+	size: z.number().describe('File size in bytes'),
+	isDir: z.boolean().describe('Whether the entry is a directory'),
+	mode: z.string().describe('Unix permissions as octal string (e.g., "0644")'),
+	modTime: z.string().describe('Modification time in RFC3339 format'),
+});
+
+const ListFilesDataSchema = z.object({
+	files: z.array(FileInfoSchema).describe('Array of file information'),
+});
+
+const ListFilesResponseSchema = z.discriminatedUnion('success', [
+	z.object({
+		success: z.literal<false>(false),
+		message: z.string().describe('the error message'),
+	}),
+	z.object({
+		success: z.literal<true>(true),
+		data: ListFilesDataSchema,
+	}),
+]);
+
+export interface FileInfo {
+	path: string;
+	size: number;
+	isDir: boolean;
+	mode: string;
+	modTime: string;
+}
+
+export interface ListFilesParams {
+	sandboxId: string;
+	path?: string;
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+export interface ListFilesResult {
+	files: FileInfo[];
+}
+
+/**
+ * Lists files in a sandbox workspace directory.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID and optional path
+ * @returns The list of files and directories
+ * @throws {SandboxResponseError} If the list request fails
+ */
+export async function sandboxListFiles(
+	client: APIClient,
+	params: ListFilesParams
+): Promise<ListFilesResult> {
+	const { sandboxId, path, orgId, signal } = params;
+
+	const queryParams = new URLSearchParams();
+	if (path) {
+		queryParams.set('path', path);
+	}
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/fs/${API_VERSION}/list/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.get<z.infer<typeof ListFilesResponseSchema>>(
+		url,
+		ListFilesResponseSchema,
+		signal
+	);
+
+	if (resp.success) {
+		return {
+			files: resp.data.files,
+		};
+	}
+
+	throw new SandboxResponseError({ message: resp.message, sandboxId });
+}
+
+export type ArchiveFormat = 'zip' | 'tar.gz';
+
+export interface DownloadArchiveParams {
+	sandboxId: string;
+	path?: string;
+	format?: ArchiveFormat;
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+/**
+ * Downloads files from a sandbox as a compressed archive.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID, path, and format
+ * @returns A ReadableStream of the archive contents
+ * @throws {SandboxResponseError} If the download request fails
+ */
+export async function sandboxDownloadArchive(
+	client: APIClient,
+	params: DownloadArchiveParams
+): Promise<ReadableStream<Uint8Array>> {
+	const { sandboxId, path, format, orgId, signal } = params;
+
+	const queryParams = new URLSearchParams();
+	if (path) {
+		queryParams.set('path', path);
+	}
+	if (format) {
+		queryParams.set('format', format);
+	}
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/fs/${API_VERSION}/download/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const response = await client.rawGet(url, signal);
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => 'Unknown error');
+		throw new SandboxResponseError({
+			message: `Failed to download archive: ${response.status} ${text}`,
+			sandboxId,
+		});
+	}
+
+	if (!response.body) {
+		throw new SandboxResponseError({
+			message: 'No response body',
+			sandboxId,
+		});
+	}
+
+	return response.body;
+}
+
+export interface UploadArchiveParams {
+	sandboxId: string;
+	archive: Uint8Array | ArrayBuffer | ReadableStream<Uint8Array>;
+	path?: string;
+	format?: ArchiveFormat | '';
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+const UploadArchiveResponseSchema = z.discriminatedUnion('success', [
+	z.object({
+		success: z.literal<false>(false),
+		message: z.string().describe('the error message'),
+	}),
+	z.object({
+		success: z.literal<true>(true),
+	}),
+]);
+
+/**
+ * Uploads a compressed archive to a sandbox and extracts it.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID, archive data, path, and optional format
+ * @throws {SandboxResponseError} If the upload request fails
+ */
+export async function sandboxUploadArchive(
+	client: APIClient,
+	params: UploadArchiveParams
+): Promise<void> {
+	const { sandboxId, archive, path, format, orgId, signal } = params;
+
+	const queryParams = new URLSearchParams();
+	if (path) {
+		queryParams.set('path', path);
+	}
+	if (format) {
+		queryParams.set('format', format);
+	}
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/fs/${API_VERSION}/upload/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const response = await client.rawPost(url, archive, 'application/octet-stream', signal);
+
+	if (!response.ok) {
+		const text = await response.text().catch(() => 'Unknown error');
+		throw new SandboxResponseError({
+			message: `Failed to upload archive: ${response.status} ${text}`,
+			sandboxId,
+		});
+	}
+
+	const body = await response.json();
+	const result = UploadArchiveResponseSchema.parse(body);
+
+	if (!result.success) {
+		throw new SandboxResponseError({ message: result.message, sandboxId });
+	}
+}
+
+const SetEnvRequestSchema = z.object({
+	env: z
+		.record(z.string(), z.string().nullable())
+		.describe('Environment variables to set (null to delete)'),
+});
+
+const SetEnvDataSchema = z.object({
+	env: z.record(z.string(), z.string()).describe('Current environment variables after update'),
+});
+
+const SetEnvResponseSchema = z.discriminatedUnion('success', [
+	z.object({
+		success: z.literal<false>(false),
+		message: z.string().describe('the error message'),
+	}),
+	z.object({
+		success: z.literal<true>(true),
+		data: SetEnvDataSchema,
+	}),
+]);
+
+export interface SetEnvParams {
+	sandboxId: string;
+	env: Record<string, string | null>;
+	orgId?: string;
+	signal?: AbortSignal;
+}
+
+export interface SetEnvResult {
+	env: Record<string, string>;
+}
+
+/**
+ * Sets environment variables on a sandbox. Pass null to delete a variable.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including sandbox ID and env key/value pairs
+ * @returns The current environment variables after the update
+ * @throws {SandboxResponseError} If the request fails
+ */
+export async function sandboxSetEnv(
+	client: APIClient,
+	params: SetEnvParams
+): Promise<SetEnvResult> {
+	const { sandboxId, env, orgId, signal } = params;
+
+	const body: z.infer<typeof SetEnvRequestSchema> = { env };
+
+	const queryParams = new URLSearchParams();
+	if (orgId) {
+		queryParams.set('orgId', orgId);
+	}
+	const queryString = queryParams.toString();
+	const url = `/sandbox/env/${API_VERSION}/${sandboxId}${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.patch<z.infer<typeof SetEnvResponseSchema>>(
+		url,
+		body,
+		SetEnvResponseSchema,
+		SetEnvRequestSchema,
+		signal
+	);
+
+	if (resp.success) {
+		return {
+			env: resp.data.env,
+		};
+	}
+
+	throw new SandboxResponseError({ message: resp.message, sandboxId });
+}