@agentuity/server 0.1.23 → 0.1.25

package/src/api/api.ts

@@ -714,6 +714,7 @@ export const APIResponseSchema = <T extends z.ZodType>(dataSchema: T) =>
 		z.object({
 			success: z.literal<false>(false),
 			message: z.string().describe('the error message'),
+			code: z.string().optional().describe('machine-readable error code'),
 		}),
 		z.object({
 			success: z.literal<true>(true),
@@ -726,6 +727,7 @@ export const APIResponseSchemaOptionalData = <T extends z.ZodType>(dataSchema: T
 		z.object({
 			success: z.literal<false>(false),
 			message: z.string().describe('the error message'),
+			code: z.string().optional().describe('machine-readable error code'),
 		}),
 		z.object({
 			success: z.literal<true>(true),
@@ -738,6 +740,7 @@ export const APIResponseSchemaNoData = () =>
 		z.object({
 			success: z.literal<false>(false),
 			message: z.string().describe('the error message'),
+			code: z.string().optional().describe('machine-readable error code'),
 		}),
 		z.object({
 			success: z.literal<true>(true),

package/src/api/eval/get.ts

@@ -0,0 +1,33 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+
+const EvaluationDetailSchema = z.object({
+	id: z.string().describe('Evaluation ID'),
+	name: z.string().describe('Evaluation name'),
+	description: z.string().nullable().describe('Evaluation description'),
+	identifier: z.string().nullable().describe('Stable evaluation identifier'),
+	agentIdentifier: z.string().describe('Agent identifier'),
+	projectId: z.string().describe('Project ID'),
+	orgId: z.string().describe('Organization ID'),
+	devmode: z.boolean().describe('Whether this is a devmode evaluation'),
+	createdAt: z.string().describe('Creation timestamp'),
+	updatedAt: z.string().describe('Last updated timestamp'),
+});
+
+const EvalGetResponseSchema = APIResponseSchema(EvaluationDetailSchema);
+
+export type EvaluationDetail = z.infer<typeof EvaluationDetailSchema>;
+
+export async function evalGet(client: APIClient, id: string): Promise<EvaluationDetail> {
+	const resp = await client.request<z.infer<typeof EvalGetResponseSchema>>(
+		'GET',
+		`/cli/eval/${encodeURIComponent(id)}`,
+		EvalGetResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new Error(resp.message || 'Failed to get evaluation');
+}

package/src/api/eval/index.ts

@@ -0,0 +1,4 @@
+export { evalList, type Evaluation, type EvaluationListRequest } from './list';
+export { evalGet, type EvaluationDetail } from './get';
+export { evalRunList, type EvalRunListItem, type EvalRunListRequest } from './run-list';
+export { evalRunGet, type EvalRunDetail } from './run-get';

package/src/api/eval/list.ts

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+
+const EvaluationSchema = z.object({
+	id: z.string().describe('Evaluation ID'),
+	name: z.string().describe('Evaluation name'),
+	description: z.string().nullable().describe('Evaluation description'),
+	identifier: z.string().nullable().describe('Stable evaluation identifier'),
+	agentIdentifier: z.string().describe('Agent identifier'),
+	projectId: z.string().describe('Project ID'),
+	devmode: z.boolean().describe('Whether this is a devmode evaluation'),
+	createdAt: z.string().describe('Creation timestamp'),
+	updatedAt: z.string().describe('Last updated timestamp'),
+});
+
+const EvalListResponseData = z.array(EvaluationSchema);
+const EvalListResponseSchema = APIResponseSchema(EvalListResponseData);
+
+export type Evaluation = z.infer<typeof EvaluationSchema>;
+export type EvaluationListRequest = {
+	projectId?: string;
+	agentId?: string;
+};
+
+export async function evalList(
+	client: APIClient,
+	request: EvaluationListRequest = {}
+): Promise<Evaluation[]> {
+	const params = new URLSearchParams();
+	if (request.projectId) params.set('projectId', request.projectId);
+	if (request.agentId) params.set('agentId', request.agentId);
+
+	const queryString = params.toString();
+	const url = `/cli/eval${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.request<z.infer<typeof EvalListResponseSchema>>(
+		'GET',
+		url,
+		EvalListResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new Error(resp.message || 'Failed to list evaluations');
+}

package/src/api/eval/run-get.ts

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+
+const EvalRunDetailSchema = z.object({
+	id: z.string().describe('Eval run ID'),
+	sessionId: z.string().describe('Session ID'),
+	evalId: z.string().describe('Evaluation record ID'),
+	evalIdentifier: z.string().nullable().describe('Stable evaluation identifier'),
+	evalName: z.string().nullable().describe('Evaluation name'),
+	agentIdentifier: z.string().nullable().describe('Agent identifier'),
+	projectId: z.string().describe('Project ID'),
+	orgId: z.string().describe('Organization ID'),
+	deploymentId: z.string().nullable().describe('Deployment ID'),
+	devmode: z.boolean().describe('Whether this is a devmode run'),
+	pending: z.boolean().describe('Whether the eval run is pending'),
+	success: z.boolean().describe('Whether the eval run succeeded'),
+	error: z.string().nullable().describe('Error message if failed'),
+	result: z.any().nullable().describe('Eval run result'),
+	createdAt: z.string().describe('Creation timestamp'),
+	updatedAt: z.string().describe('Last updated timestamp'),
+});
+
+const EvalRunGetResponseSchema = APIResponseSchema(EvalRunDetailSchema);
+
+export type EvalRunDetail = z.infer<typeof EvalRunDetailSchema>;
+
+export async function evalRunGet(client: APIClient, id: string): Promise<EvalRunDetail> {
+	const resp = await client.request<z.infer<typeof EvalRunGetResponseSchema>>(
+		'GET',
+		`/cli/eval-run/${encodeURIComponent(id)}`,
+		EvalRunGetResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new Error(resp.message || 'Failed to get eval run');
+}

package/src/api/eval/run-list.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+
+const EvalRunSchema = z.object({
+	id: z.string().describe('Eval run ID'),
+	sessionId: z.string().describe('Session ID'),
+	evalId: z.string().describe('Evaluation record ID'),
+	evalIdentifier: z.string().nullable().describe('Stable evaluation identifier'),
+	evalName: z.string().nullable().describe('Evaluation name'),
+	agentIdentifier: z.string().nullable().describe('Agent identifier'),
+	projectId: z.string().describe('Project ID'),
+	deploymentId: z.string().nullable().describe('Deployment ID'),
+	devmode: z.boolean().describe('Whether this is a devmode run'),
+	pending: z.boolean().describe('Whether the eval run is pending'),
+	success: z.boolean().describe('Whether the eval run succeeded'),
+	error: z.string().nullable().describe('Error message if failed'),
+	result: z.any().nullable().describe('Eval run result'),
+	createdAt: z.string().describe('Creation timestamp'),
+	updatedAt: z.string().describe('Last updated timestamp'),
+});
+
+const EvalRunListResponseData = z.array(EvalRunSchema);
+const EvalRunListResponseSchema = APIResponseSchema(EvalRunListResponseData);
+
+export type EvalRunListItem = z.infer<typeof EvalRunSchema>;
+export type EvalRunListRequest = {
+	projectId?: string;
+	agentId?: string;
+	evalId?: string;
+	sessionId?: string;
+};
+
+export async function evalRunList(
+	client: APIClient,
+	request: EvalRunListRequest = {}
+): Promise<EvalRunListItem[]> {
+	const params = new URLSearchParams();
+	if (request.projectId) params.set('projectId', request.projectId);
+	if (request.agentId) params.set('agentId', request.agentId);
+	if (request.evalId) params.set('evalId', request.evalId);
+	if (request.sessionId) params.set('sessionId', request.sessionId);
+
+	const queryString = params.toString();
+	const url = `/cli/eval-run${queryString ? `?${queryString}` : ''}`;
+
+	const resp = await client.request<z.infer<typeof EvalRunListResponseSchema>>(
+		'GET',
+		url,
+		EvalRunListResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new Error(resp.message || 'Failed to list eval runs');
+}

package/src/api/index.ts

@@ -1,6 +1,7 @@
 export * from './api';
 export * from './apikey';
 export * from './db';
+export * from './eval';
 export * from './machine';
 export * from './org';
 export * from './project';

package/src/api/machine/machine.ts

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { APIResponseSchema, APIClient } from '../api';
+import { APIResponseSchema, APIResponseSchemaNoData, APIClient } from '../api';
 import { MachineResponseError } from './util';
 
 const MachineSchema = z.object({
@@ -7,6 +7,8 @@ const MachineSchema = z.object({
 	instanceId: z.string().nullable().optional(),
 	privateIPv4: z.string().nullable().optional(),
 	availabilityZone: z.string().nullable().optional(),
+	instanceType: z.string().nullable().optional(),
+	instanceTags: z.array(z.string()).nullable().optional(),
 	deploymentCount: z.number().optional(),
 	status: z.string(),
 	provider: z.string(),
@@ -25,7 +27,7 @@ const MachineSchema = z.object({
 
 const MachineListResponseSchema = APIResponseSchema(z.array(MachineSchema));
 const MachineGetResponseSchema = APIResponseSchema(MachineSchema);
-const MachineDeleteResponseSchema = APIResponseSchema(z.boolean());
+const MachineDeleteResponseSchema = APIResponseSchemaNoData();
 
 export type Machine = z.infer<typeof MachineSchema>;
 
@@ -45,12 +47,11 @@ export async function machineGet(client: APIClient, machineId: string): Promise<
 	throw new MachineResponseError({ message: resp.message });
 }
 
-export async function machineDelete(client: APIClient, machineId: string): Promise<boolean> {
+export async function machineDelete(client: APIClient, machineId: string): Promise<void> {
 	const resp = await client.delete(`/machine/${machineId}`, MachineDeleteResponseSchema);
-	if (resp.success) {
-		return resp.data;
+	if (!resp.success) {
+		throw new MachineResponseError({ message: resp.message });
 	}
-	throw new MachineResponseError({ message: resp.message });
 }
 
 const MachineDeploymentProjectSchema = z.object({

package/src/api/project/index.ts

@@ -8,3 +8,4 @@ export * from './env-update';
 export * from './exists';
 export * from './get';
 export * from './list';
+export * from './malware';

package/src/api/project/malware.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api';
+
+const PackageRef = z.object({
+	name: z.string(),
+	version: z.string(),
+});
+
+export type PackageRef = z.infer<typeof PackageRef>;
+
+const MalwareFinding = z.object({
+	name: z.string(),
+	version: z.string(),
+	reason: z.string(),
+});
+
+export type MalwareFinding = z.infer<typeof MalwareFinding>;
+
+const MalwareCheckSummary = z.object({
+	scanned: z.number(),
+	flagged: z.number(),
+});
+
+const MalwareCheckListMetadata = z.object({
+	fetchedAt: z.string(),
+	count: z.number(),
+});
+
+const MalwareCheckResult = z.object({
+	success: z.boolean(),
+	action: z.enum(['allow', 'block']),
+	summary: MalwareCheckSummary,
+	findings: z.array(MalwareFinding),
+	list: MalwareCheckListMetadata.optional(),
+	error: z.string().optional(),
+});
+
+const MalwareCheckResponseSchema = APIResponseSchema(MalwareCheckResult);
+
+export type MalwareCheckResult = z.infer<typeof MalwareCheckResult>;
+
+export async function projectDeploymentMalwareCheck(
+	client: APIClient,
+	deploymentId: string,
+	packages: PackageRef[]
+): Promise<MalwareCheckResult> {
+	const resp = await client.request<z.infer<typeof MalwareCheckResponseSchema>>(
+		'POST',
+		`/security/2026-01-22/${deploymentId}/malware-check`,
+		MalwareCheckResponseSchema,
+		{
+			ecosystem: 'npm',
+			packages,
+		}
+	);
+
+	if (!resp.success) {
+		throw new Error(resp.message || 'Malware check request failed');
+	}
+
+	return resp.data;
+}

package/src/api/queue/types.ts

@@ -372,8 +372,8 @@ export const DeadLetterMessageSchema = z.object({
 	id: z.string(),
 	/** ID of the queue this message belongs to. */
 	queue_id: z.string(),
-	/** ID of the original message that failed. */
-	original_message_id: z.string(),
+	/** ID of the original message that failed (optional until backend includes it). */
+	original_message_id: z.string().optional(),
 	/** Offset of the original message in the queue. */
 	offset: z.number(),
 	/** The message payload (JSON object). */
@@ -384,10 +384,12 @@ export const DeadLetterMessageSchema = z.object({
 	failure_reason: z.string().nullable().optional(),
 	/** Number of delivery attempts before failure. */
 	delivery_attempts: z.number(),
-	/** ISO 8601 timestamp when the message was moved to DLQ. */
-	moved_at: z.string(),
-	/** ISO 8601 timestamp when the original message was published. */
-	original_published_at: z.string(),
+	/** ISO 8601 timestamp when the message was moved to DLQ (optional until backend includes it). */
+	moved_at: z.string().optional(),
+	/** ISO 8601 timestamp when the original message was published (optional, falls back to published_at). */
+	original_published_at: z.string().optional(),
+	/** ISO 8601 timestamp when the message was published (from base message). */
+	published_at: z.string().optional(),
 	/** ISO 8601 timestamp when the DLQ entry was created. */
 	created_at: z.string(),
 });

package/src/api/sandbox/client.ts

@@ -19,6 +19,7 @@ import { sandboxRun } from './run';
 import { executionGet, type ExecutionInfo } from './execution';
 import { ConsoleLogger } from '../../logger';
 import { getServiceUrls } from '../../config';
+import { writeAndDrain } from './util';
 
 const POLL_INTERVAL_MS = 100;
 const MAX_POLL_TIME_MS = 300000; // 5 minutes
@@ -67,10 +68,14 @@ async function waitForExecution(
 }
 
 /**
- * Pipes a remote stream URL to a local writable stream
+ * Pipes a remote stream URL to a local writable stream with proper backpressure handling
  */
-async function pipeStreamToWritable(streamUrl: string, writable: Writable): Promise<void> {
-	const response = await fetch(streamUrl);
+async function pipeStreamToWritable(
+	streamUrl: string,
+	writable: Writable,
+	signal?: AbortSignal
+): Promise<void> {
+	const response = await fetch(streamUrl, { signal });
 	if (!response.ok) {
 		throw new Error(`Failed to fetch stream: ${response.status} ${response.statusText}`);
 	}
@@ -84,10 +89,15 @@ async function pipeStreamToWritable(streamUrl: string, writable: Writable): Prom
 			const { done, value } = await reader.read();
 			if (done) break;
 			if (value) {
-				writable.write(value);
+				await writeAndDrain(writable, value);
 			}
 		}
 	} finally {
+		try {
+			await reader.cancel();
+		} catch {
+			// Ignore cancel errors - stream may already be closed
+		}
 		reader.releaseLock();
 	}
 }
@@ -191,6 +201,16 @@ export interface SandboxInstance {
 	 */
 	execute(options: ExecuteOptions): Promise<Execution>;
 
+	/**
+	 * Write files to the sandbox workspace
+	 */
+	writeFiles(files: FileToWrite[]): Promise<number>;
+
+	/**
+	 * Read a file from the sandbox workspace
+	 */
+	readFile(path: string): Promise<ReadableStream<Uint8Array>>;
+
 	/**
 	 * Get current sandbox information
 	 */
@@ -327,12 +347,20 @@ export class SandboxClient {
 
 					if (pipe.stdout && initialResult.stdoutStreamUrl) {
 						streamPromises.push(
-							pipeStreamToWritable(initialResult.stdoutStreamUrl, pipe.stdout)
+							pipeStreamToWritable(
+								initialResult.stdoutStreamUrl,
+								pipe.stdout,
+								coreOptions.signal
+							)
 						);
 					}
 					if (pipe.stderr && initialResult.stderrStreamUrl) {
 						streamPromises.push(
-							pipeStreamToWritable(initialResult.stderrStreamUrl, pipe.stderr)
+							pipeStreamToWritable(
+								initialResult.stderrStreamUrl,
+								pipe.stderr,
+								coreOptions.signal
+							)
 						);
 					}
 
@@ -360,6 +388,15 @@ export class SandboxClient {
 				};
 			},
 
+			async writeFiles(files: FileToWrite[]): Promise<number> {
+				const result = await sandboxWriteFiles(client, { sandboxId, files, orgId });
+				return result.filesWritten;
+			},
+
+			async readFile(path: string): Promise<ReadableStream<Uint8Array>> {
+				return sandboxReadFile(client, { sandboxId, path, orgId });
+			},
+
 			async get(): Promise<SandboxInfo> {
 				return sandboxGet(client, { sandboxId, orgId });
 			},

package/src/api/sandbox/create.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
-import { SandboxResponseError, API_VERSION } from './util';
+import { throwSandboxError, API_VERSION } from './util';
 import type { SandboxCreateOptions, SandboxStatus } from '@agentuity/core';
 
 const SandboxCreateRequestSchema = z
@@ -64,7 +64,7 @@ const SandboxCreateRequestSchema = z
 						})
 					)
 					.optional()
-					.describe('Files to write before execution'),
+					.describe('Files to write before execution (deprecated: use top-level files)'),
 				mode: z
 					.enum(['oneshot', 'interactive'])
 					.optional()
@@ -72,6 +72,10 @@ const SandboxCreateRequestSchema = z
 			})
 			.optional()
 			.describe('Initial command to run in the sandbox'),
+		files: z
+			.record(z.string(), z.string())
+			.optional()
+			.describe('Files to write to sandbox on creation (path -> base64 content)'),
 		snapshot: z.string().optional().describe('Snapshot ID to restore the sandbox from'),
 		dependencies: z
 			.array(z.string())
@@ -168,6 +172,11 @@ export async function sandboxCreate(
 			})),
 		};
 	}
+	if (options.files && options.files.length > 0) {
+		body.files = Object.fromEntries(
+			options.files.map((f) => [f.path, f.content.toString('base64')])
+		);
+	}
 	if (options.snapshot) {
 		body.snapshot = options.snapshot;
 	}
@@ -196,5 +205,5 @@ export async function sandboxCreate(
 		return resp.data;
 	}
 
-	throw new SandboxResponseError({ message: resp.message });
+	throwSandboxError(resp, {});
 }

package/src/api/sandbox/destroy.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchemaNoData } from '../api';
-import { SandboxResponseError, API_VERSION } from './util';
+import { throwSandboxError, API_VERSION } from './util';
 
 const DestroyResponseSchema = APIResponseSchemaNoData();
 
@@ -37,5 +37,5 @@ export async function sandboxDestroy(
 		return;
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }

package/src/api/sandbox/execute.ts

@@ -1,13 +1,15 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
-import { SandboxResponseError, API_VERSION } from './util';
-import { FileToWriteSchema } from './files';
+import { throwSandboxError, API_VERSION } from './util';
 import type { ExecuteOptions, Execution, ExecutionStatus } from '@agentuity/core';
 
 const ExecuteRequestSchema = z
 	.object({
 		command: z.array(z.string()).describe('Command and arguments to execute'),
-		files: z.array(FileToWriteSchema).optional().describe('Files to write before execution'),
+		files: z
+			.record(z.string(), z.string())
+			.optional()
+			.describe('Files to write before execution (path -> base64 content)'),
 		timeout: z.string().optional().describe('Execution timeout (e.g., "30s", "5m")'),
 		stream: z
 			.object({
@@ -59,11 +61,10 @@ export async function sandboxExecute(
 		command: options.command,
 	};
 
-	if (options.files) {
-		body.files = options.files.map((f) => ({
-			path: f.path,
-			content: f.content.toString('base64'),
-		}));
+	if (options.files && options.files.length > 0) {
+		body.files = Object.fromEntries(
+			options.files.map((f) => [f.path, f.content.toString('base64')])
+		);
 	}
 	if (options.timeout) {
 		body.timeout = options.timeout;
@@ -98,5 +99,5 @@ export async function sandboxExecute(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }

package/src/api/sandbox/execution.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
-import { SandboxResponseError, API_VERSION } from './util';
+import { throwSandboxError, API_VERSION } from './util';
 import type { ExecutionStatus } from '@agentuity/core';
 
 const ExecutionInfoSchema = z
@@ -97,7 +97,7 @@ export async function executionGet(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, executionId });
+	throwSandboxError(resp, { executionId });
 }
 
 export interface ExecutionListParams {
@@ -157,5 +157,5 @@ export async function executionList(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }

package/src/api/sandbox/files.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { APIClient } from '../api';
-import { SandboxResponseError, API_VERSION } from './util';
+import { SandboxResponseError, throwSandboxError, API_VERSION } from './util';
 import type { FileToWrite } from '@agentuity/core';
 
 export const FileToWriteSchema = z.object({
@@ -85,7 +85,7 @@ export async function sandboxWriteFiles(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }
 
 export interface ReadFileParams {
@@ -196,7 +196,7 @@ export async function sandboxMkDir(client: APIClient, params: MkDirParams): Prom
 	);
 
 	if (!resp.success) {
-		throw new SandboxResponseError({ message: resp.message, sandboxId });
+		throwSandboxError(resp, { sandboxId });
 	}
 }
 
@@ -256,7 +256,7 @@ export async function sandboxRmDir(client: APIClient, params: RmDirParams): Prom
 	);
 
 	if (!resp.success) {
-		throw new SandboxResponseError({ message: resp.message, sandboxId });
+		throwSandboxError(resp, { sandboxId });
 	}
 }
 
@@ -313,7 +313,7 @@ export async function sandboxRmFile(client: APIClient, params: RmFileParams): Pr
 	);
 
 	if (!resp.success) {
-		throw new SandboxResponseError({ message: resp.message, sandboxId });
+		throwSandboxError(resp, { sandboxId });
 	}
 }
 
@@ -395,7 +395,7 @@ export async function sandboxListFiles(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }
 
 export type ArchiveFormat = 'zip' | 'tar.gz';
@@ -519,7 +519,7 @@ export async function sandboxUploadArchive(
 	const result = UploadArchiveResponseSchema.parse(body);
 
 	if (!result.success) {
-		throw new SandboxResponseError({ message: result.message, sandboxId, sessionId });
+		throwSandboxError(result, { sandboxId, sessionId });
 	}
 }
 
@@ -592,5 +592,5 @@ export async function sandboxSetEnv(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }

package/src/api/sandbox/get.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
-import { SandboxResponseError, API_VERSION } from './util';
+import { throwSandboxError, API_VERSION } from './util';
 import type {
 	SandboxInfo,
 	SandboxStatus,
@@ -80,7 +80,9 @@ const SandboxSnapshotInfoSchema = z
 				tag: z.string().optional().describe('Snapshot tag'),
 				fullName: z.string().optional().describe('Full name with org slug (@slug/name:tag)'),
 				public: z.literal(true).describe('Public snapshot'),
-				org: SandboxSnapshotOrgInfoSchema.describe('Organization that owns the public snapshot'),
+				org: SandboxSnapshotOrgInfoSchema.describe(
+					'Organization that owns the public snapshot'
+				),
 			})
 			.describe('Public snapshot'),
 		z
@@ -210,5 +212,5 @@ export async function sandboxGet(
 		};
 	}
 
-	throw new SandboxResponseError({ message: resp.message, sandboxId });
+	throwSandboxError(resp, { sandboxId });
 }