@agentuity/server 0.1.9 → 0.1.11

package/src/api/api.ts

@@ -208,7 +208,8 @@ export class APIClient {
 		responseSchema?: z.ZodType<TResponse>,
 		body?: TBody,
 		bodySchema?: z.ZodType<TBody>,
-		signal?: AbortSignal
+		signal?: AbortSignal,
+		extraHeaders?: Record<string, string>
 	): Promise<TResponse> {
 		// Validate request body if schema provided
 		if (body !== undefined && bodySchema) {
@@ -221,7 +222,14 @@ export class APIClient {
 			}
 		}
 
-		const response = await this.#makeRequest(method, endpoint, body, signal);
+		const response = await this.#makeRequest(
+			method,
+			endpoint,
+			body,
+			signal,
+			undefined,
+			extraHeaders
+		);
 
 		// Handle empty responses (204 or zero-length body)
 		let data: unknown;
@@ -263,7 +271,8 @@ export class APIClient {
 		endpoint: string,
 		body?: unknown,
 		signal?: AbortSignal,
-		contentType?: string
+		contentType?: string,
+		extraHeaders?: Record<string, string>
 	): Promise<Response> {
 		this.#logger.trace('sending %s to %s%s', method, this.#baseUrl, endpoint);
 
@@ -294,6 +303,11 @@ export class APIClient {
 			);
 		}
 
+		// Apply per-request extra headers (e.g., x-agentuity-orgid for CLI auth)
+		if (extraHeaders) {
+			Object.keys(extraHeaders).forEach((key) => (headers[key] = extraHeaders[key]));
+		}
+
 		const canRetry = !(body instanceof ReadableStream); // we cannot safely retry a ReadableStream as body
 
 		for (let attempt = 0; attempt <= maxRetries; attempt++) {

package/src/api/org/resources.ts

@@ -34,27 +34,32 @@ export type OrgDBResource = z.infer<typeof OrgDBResource>;
 export interface ListOrgResourcesOptions {
 	/** Filter by resource type (default: "all") */
 	type?: 'all' | 's3' | 'db';
+	/** Organization ID (required for CLI auth, extracted from context for SDK auth) */
+	orgId?: string;
 }
 
 /**
  * List all resources for the authenticated organization (across all regions)
- * Extracts orgId from authentication context (API key, SDK, or CLI token)
  *
  * @param client - Catalyst API client (must be authenticated)
- * @param options - Optional filters
+ * @param options - Optional filters including orgId for CLI auth
  * @returns List of S3 and DB resources with their cloud regions
  *
  * @example
- * // Get all resources
+ * // Get all resources (SDK auth - orgId from context)
  * const all = await listOrgResources(client);
  *
  * @example
+ * // Get all resources (CLI auth - orgId required)
+ * const all = await listOrgResources(client, { orgId: 'org_123' });
+ *
+ * @example
  * // Get only S3 buckets
- * const s3Only = await listOrgResources(client, { type: 's3' });
+ * const s3Only = await listOrgResources(client, { type: 's3', orgId: 'org_123' });
  *
  * @example
  * // Get only DBs
- * const dbsOnly = await listOrgResources(client, { type: 'db' });
+ * const dbsOnly = await listOrgResources(client, { type: 'db', orgId: 'org_123' });
  */
 export async function listOrgResources(
 	client: APIClient,
@@ -68,10 +73,20 @@ export async function listOrgResources(
 	const query = params.toString();
 	const url = `/resource/2025-11-16${query ? `?${query}` : ''}`;
 
+	// Build headers - include orgId for CLI auth
+	const headers: Record<string, string> = {};
+	if (options?.orgId) {
+		headers['x-agentuity-orgid'] = options.orgId;
+	}
+
 	const resp = await client.request<OrgResourceListResponse>(
 		'GET',
 		url,
-		OrgResourceListResponseSchema
+		OrgResourceListResponseSchema,
+		undefined,
+		undefined,
+		undefined,
+		headers
 	);
 	if (resp.success) {
 		return resp.data;

package/src/api/project/deployment.ts

@@ -90,6 +90,34 @@ export async function projectDeploymentGet(
 	throw new ProjectResponseError({ message: resp.message });
 }
 
+const DeploymentLookupSchema = z.object({
+	id: z.string(),
+	projectId: z.string(),
+	orgId: z.string(),
+	cloudRegion: z.string().nullable().optional(),
+	state: z.string().nullable().optional(),
+	active: z.boolean(),
+});
+
+const DeploymentLookupResponseSchema = APIResponseSchema(DeploymentLookupSchema);
+
+export type DeploymentLookup = z.infer<typeof DeploymentLookupSchema>;
+
+/**
+ * Get deployment info by ID only (without requiring project ID).
+ * Useful for looking up region/project info for a deployment.
+ */
+export async function deploymentGet(
+	client: APIClient,
+	deploymentId: string
+): Promise<DeploymentLookup> {
+	const resp = await client.get(`/cli/deployment/${deploymentId}`, DeploymentLookupResponseSchema);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new ProjectResponseError({ message: resp.message });
+}
+
 export async function projectDeploymentDelete(
 	client: APIClient,
 	projectId: string,

package/src/api/sandbox/create.ts

@@ -5,10 +5,7 @@ import type { SandboxCreateOptions, SandboxStatus } from '@agentuity/core';
 
 const SandboxCreateRequestSchema = z
 	.object({
-		runtime: z
-			.string()
-			.optional()
-			.describe('Runtime name (e.g., "bun:1", "python:3.14")'),
+		runtime: z.string().optional().describe('Runtime name (e.g., "bun:1", "python:3.14")'),
 		runtimeId: z.string().optional().describe('Runtime ID (e.g., "srt_xxx")'),
 		name: z.string().optional().describe('Optional sandbox name'),
 		description: z.string().optional().describe('Optional sandbox description'),

package/src/api/sandbox/execution.ts

@@ -7,7 +7,10 @@ const ExecutionInfoSchema = z
 	.object({
 		executionId: z.string().describe('Unique identifier for the execution'),
 		sandboxId: z.string().describe('ID of the sandbox where the execution ran'),
-		type: z.string().optional().describe('Type of execution (e.g., exec, write_files, read_file)'),
+		type: z
+			.string()
+			.optional()
+			.describe('Type of execution (e.g., exec, write_files, read_file)'),
 		status: z
 			.enum(['queued', 'running', 'completed', 'failed', 'timeout', 'cancelled'])
 			.describe('Current status of the execution'),

package/src/api/sandbox/get.ts

@@ -11,6 +11,35 @@ const SandboxResourcesSchema = z
 	})
 	.describe('Resource limits for the sandbox');
 
+const SandboxUserInfoSchema = z
+	.object({
+		id: z.string().describe('User ID'),
+		firstName: z.string().optional().describe("User's first name"),
+		lastName: z.string().optional().describe("User's last name"),
+	})
+	.describe('User who created the sandbox');
+
+const SandboxAgentInfoSchema = z
+	.object({
+		id: z.string().describe('Agent ID'),
+		name: z.string().describe('Agent name'),
+	})
+	.describe('Agent associated with the sandbox');
+
+const SandboxProjectInfoSchema = z
+	.object({
+		id: z.string().describe('Project ID'),
+		name: z.string().describe('Project name'),
+	})
+	.describe('Project associated with the sandbox');
+
+const SandboxOrgInfoSchema = z
+	.object({
+		id: z.string().describe('Organization ID'),
+		name: z.string().describe('Organization name'),
+	})
+	.describe('Organization associated with the sandbox');
+
 const SandboxInfoDataSchema = z
 	.object({
 		sandboxId: z.string().describe('Unique identifier for the sandbox'),
@@ -43,6 +72,10 @@ const SandboxInfoDataSchema = z
 		memoryByteSec: z.number().optional().describe('Total memory usage in byte-seconds'),
 		networkEgressBytes: z.number().optional().describe('Total network egress in bytes'),
 		networkEnabled: z.boolean().optional().describe('Whether network access is enabled'),
+		user: SandboxUserInfoSchema.optional().describe('User who created the sandbox'),
+		agent: SandboxAgentInfoSchema.optional().describe('Agent associated with the sandbox'),
+		project: SandboxProjectInfoSchema.optional().describe('Project associated with the sandbox'),
+		org: SandboxOrgInfoSchema.describe('Organization associated with the sandbox'),
 	})
 	.describe('Detailed information about a sandbox');
 
@@ -106,6 +139,10 @@ export async function sandboxGet(
 			memoryByteSec: resp.data.memoryByteSec,
 			networkEgressBytes: resp.data.networkEgressBytes,
 			networkEnabled: resp.data.networkEnabled,
+			user: resp.data.user,
+			agent: resp.data.agent,
+			project: resp.data.project,
+			org: resp.data.org,
 		};
 	}
 

package/src/api/sandbox/index.ts

@@ -49,7 +49,15 @@ export type {
 	SetEnvParams,
 	SetEnvResult,
 } from './files';
-export { snapshotCreate, snapshotGet, snapshotList, snapshotDelete, snapshotTag } from './snapshot';
+export {
+	snapshotCreate,
+	snapshotGet,
+	snapshotList,
+	snapshotDelete,
+	snapshotTag,
+	snapshotBuildInit,
+	snapshotBuildFinalize,
+} from './snapshot';
 export type {
 	SnapshotInfo,
 	SnapshotFileInfo,
@@ -59,4 +67,9 @@ export type {
 	SnapshotListResponse,
 	SnapshotDeleteParams,
 	SnapshotTagParams,
+	SnapshotBuildInitParams,
+	SnapshotBuildInitResponse,
+	SnapshotBuildFinalizeParams,
 } from './snapshot';
+export { SnapshotBuildFileSchema } from './snapshot-build';
+export type { SnapshotBuildFile } from './snapshot-build';

package/src/api/sandbox/list.ts

@@ -3,6 +3,13 @@ import { APIClient, APIResponseSchema } from '../api';
 import { SandboxResponseError, API_VERSION } from './util';
 import type { ListSandboxesParams, ListSandboxesResponse, SandboxStatus } from '@agentuity/core';
 
+const SandboxOrgInfoSchema = z
+	.object({
+		id: z.string().describe('Organization ID'),
+		name: z.string().describe('Organization name'),
+	})
+	.describe('Organization associated with the sandbox');
+
 const SandboxInfoSchema = z
 	.object({
 		sandboxId: z.string().describe('Unique identifier for the sandbox'),
@@ -23,6 +30,7 @@ const SandboxInfoSchema = z
 		stdoutStreamUrl: z.string().optional().describe('URL for streaming stdout output'),
 		stderrStreamUrl: z.string().optional().describe('URL for streaming stderr output'),
 		networkEnabled: z.boolean().optional().describe('Whether network access is enabled'),
+		org: SandboxOrgInfoSchema.describe('Organization associated with the sandbox'),
 	})
 	.describe('Summary information about a sandbox');
 
@@ -103,6 +111,7 @@ export async function sandboxList(
 				stdoutStreamUrl: s.stdoutStreamUrl,
 				stderrStreamUrl: s.stderrStreamUrl,
 				networkEnabled: s.networkEnabled,
+				org: s.org,
 			})),
 			total: resp.data.total,
 		};

package/src/api/sandbox/runtime.ts

@@ -61,14 +61,16 @@ export async function runtimeList(
 
 	if (resp.success) {
 		return {
-			runtimes: resp.data.runtimes.map((r): SandboxRuntime => ({
-				id: r.id,
-				name: r.name,
-				description: r.description,
-				iconUrl: r.iconUrl,
-				url: r.url,
-				tags: r.tags,
-			})),
+			runtimes: resp.data.runtimes.map(
+				(r): SandboxRuntime => ({
+					id: r.id,
+					name: r.name,
+					description: r.description,
+					iconUrl: r.iconUrl,
+					url: r.url,
+					tags: r.tags,
+				})
+			),
 			total: resp.data.total,
 		};
 	}

package/src/api/sandbox/snapshot-build.ts

@@ -0,0 +1,62 @@
+import { z } from 'zod';
+
+/**
+ * Base schema for snapshot build configuration file (agentuity-snapshot.yaml)
+ * This is the canonical schema - used for JSON Schema generation.
+ */
+export const SnapshotBuildFileBaseSchema = z
+	.object({
+		version: z.literal(1).describe('Schema version, must be 1'),
+		runtime: z
+			.string()
+			.describe('Runtime identifier (name:tag format, e.g., bun:1, node:20, python:3.12)'),
+		name: z
+			.string()
+			.regex(/^[a-zA-Z0-9_-]+$/)
+			.optional()
+			.describe('Snapshot name (alphanumeric, underscores, dashes only)'),
+		description: z.string().optional().describe('Human-readable description of the snapshot'),
+		dependencies: z
+			.array(z.string())
+			.optional()
+			.describe(
+				'List of apt packages to install. Supports version pinning: package=version or package=version* for prefix matching'
+			),
+		files: z
+			.array(z.string())
+			.optional()
+			.describe(
+				'Glob patterns for files to include from the build context. Supports negative patterns with ! prefix for exclusions'
+			),
+		env: z
+			.record(z.string(), z.string())
+			.optional()
+			.describe(
+				'Environment variables to set. Use ${VAR} syntax for build-time substitution via --env flag'
+			),
+		metadata: z
+			.record(z.string(), z.string())
+			.optional()
+			.describe(
+				'User-defined metadata key-value pairs. Use ${VAR} syntax for build-time substitution via --metadata flag'
+			),
+	})
+	.describe('Agentuity Snapshot Build File - defines a reproducible sandbox environment');
+
+/**
+ * Schema with validation refinement - use this for parsing/validation.
+ * Ensures at least one of dependencies, files, or env is specified.
+ */
+export const SnapshotBuildFileSchema = SnapshotBuildFileBaseSchema.refine(
+	(data) => {
+		const hasDependencies = data.dependencies && data.dependencies.length > 0;
+		const hasFiles = data.files && data.files.length > 0;
+		const hasEnv = data.env && Object.keys(data.env).length > 0;
+		return hasDependencies || hasFiles || hasEnv;
+	},
+	{
+		message: 'At least one of dependencies, files, or env must be specified',
+	}
+);
+
+export type SnapshotBuildFile = z.infer<typeof SnapshotBuildFileSchema>;

package/src/api/sandbox/snapshot.ts

@@ -12,8 +12,16 @@ const SnapshotFileInfoSchema = z
 const SnapshotInfoSchema = z
 	.object({
 		snapshotId: z.string().describe('Unique identifier for the snapshot'),
-		runtimeId: z.string().nullable().optional().describe('Runtime ID associated with this snapshot'),
-		name: z.string().describe('Display name for the snapshot (URL-safe: letters, numbers, underscores, dashes)'),
+		runtimeId: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('Runtime ID associated with this snapshot'),
+		name: z
+			.string()
+			.describe(
+				'Display name for the snapshot (URL-safe: letters, numbers, underscores, dashes)'
+			),
 		description: z.string().nullable().optional().describe('Description of the snapshot'),
 		tag: z.string().nullable().optional().describe('Tag for the snapshot (defaults to "latest")'),
 		sizeBytes: z.number().describe('Total size of the snapshot in bytes'),
@@ -25,7 +33,16 @@ const SnapshotInfoSchema = z
 			.describe('ID of the parent snapshot (for incremental snapshots)'),
 		createdAt: z.string().describe('ISO timestamp when the snapshot was created'),
 		downloadUrl: z.string().optional().describe('URL to download the snapshot archive'),
-		files: z.array(SnapshotFileInfoSchema).nullable().optional().describe('List of files in the snapshot'),
+		files: z
+			.array(SnapshotFileInfoSchema)
+			.nullable()
+			.optional()
+			.describe('List of files in the snapshot'),
+		userMetadata: z
+			.record(z.string(), z.string())
+			.nullable()
+			.optional()
+			.describe('User-defined metadata key-value pairs'),
 	})
 	.describe('Detailed information about a snapshot');
 
@@ -40,60 +57,56 @@ const SnapshotListDataSchema = z
 const SnapshotListResponseSchema = APIResponseSchema(SnapshotListDataSchema);
 const SnapshotDeleteResponseSchema = APIResponseSchemaNoData();
 
-export interface SnapshotFileInfo {
-	path: string;
-	size: number;
-}
-
-export interface SnapshotInfo {
-	snapshotId: string;
-	runtimeId?: string | null;
-	name: string;
-	description?: string | null;
-	tag?: string | null;
-	sizeBytes: number;
-	fileCount: number;
-	parentSnapshotId?: string | null;
-	createdAt: string;
-	downloadUrl?: string;
-	files?: SnapshotFileInfo[] | null;
-}
+export type SnapshotFileInfo = z.infer<typeof SnapshotFileInfoSchema>;
+export type SnapshotInfo = z.infer<typeof SnapshotInfoSchema>;
+export type SnapshotListResponse = z.infer<typeof SnapshotListDataSchema>;
 
-export interface SnapshotCreateParams {
-	sandboxId: string;
-	name?: string;
-	description?: string;
-	tag?: string;
-	orgId?: string;
-}
+const _SnapshotCreateParamsSchema = z
+	.object({
+		sandboxId: z.string().describe('ID of the sandbox to snapshot'),
+		name: z.string().optional().describe('Display name for the snapshot'),
+		description: z.string().optional().describe('Description of the snapshot'),
+		tag: z.string().optional().describe('Tag for the snapshot'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for creating a snapshot');
 
-export interface SnapshotGetParams {
-	snapshotId: string;
-	orgId?: string;
-}
+const _SnapshotGetParamsSchema = z
+	.object({
+		snapshotId: z.string().describe('ID of the snapshot to retrieve'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for getting a snapshot');
 
-export interface SnapshotListParams {
-	sandboxId?: string;
-	limit?: number;
-	offset?: number;
-	orgId?: string;
-}
+const _SnapshotListParamsSchema = z
+	.object({
+		sandboxId: z.string().optional().describe('Filter by sandbox ID'),
+		limit: z.number().optional().describe('Maximum number of snapshots to return'),
+		offset: z.number().optional().describe('Number of snapshots to skip'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for listing snapshots');
 
-export interface SnapshotListResponse {
-	snapshots: SnapshotInfo[];
-	total: number;
-}
+const _SnapshotDeleteParamsSchema = z
+	.object({
+		snapshotId: z.string().describe('ID of the snapshot to delete'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for deleting a snapshot');
 
-export interface SnapshotDeleteParams {
-	snapshotId: string;
-	orgId?: string;
-}
+const _SnapshotTagParamsSchema = z
+	.object({
+		snapshotId: z.string().describe('ID of the snapshot to tag'),
+		tag: z.string().nullable().describe('New tag (or null to remove)'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for tagging a snapshot');
 
-export interface SnapshotTagParams {
-	snapshotId: string;
-	tag: string | null;
-	orgId?: string;
-}
+export type SnapshotCreateParams = z.infer<typeof _SnapshotCreateParamsSchema>;
+export type SnapshotGetParams = z.infer<typeof _SnapshotGetParamsSchema>;
+export type SnapshotListParams = z.infer<typeof _SnapshotListParamsSchema>;
+export type SnapshotDeleteParams = z.infer<typeof _SnapshotDeleteParamsSchema>;
+export type SnapshotTagParams = z.infer<typeof _SnapshotTagParamsSchema>;
 
 function buildQueryString(params: Record<string, string | number | undefined>): string {
 	const query = new URLSearchParams();
@@ -255,3 +268,133 @@ export async function snapshotTag(
 
 	throw new SandboxResponseError({ message: resp.message });
 }
+
+// ===== Snapshot Build API =====
+
+const _SnapshotBuildInitParamsSchema = z
+	.object({
+		runtime: z.string().describe('Runtime identifier (name:tag or runtime ID)'),
+		name: z.string().optional().describe('Display name for the snapshot'),
+		tag: z.string().optional().describe('Tag for the snapshot'),
+		description: z.string().optional().describe('Description of the snapshot'),
+		contentHash: z.string().optional().describe('SHA-256 hash of snapshot content for change detection'),
+		force: z.boolean().optional().describe('Force rebuild even if content is unchanged'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for initializing a snapshot build');
+
+const SnapshotBuildInitResponseSchema = z
+	.object({
+		snapshotId: z.string().optional().describe('Unique identifier for the snapshot being built'),
+		uploadUrl: z.string().optional().describe('Pre-signed URL for uploading the snapshot archive'),
+		s3Key: z.string().optional().describe('S3 key where the snapshot will be stored'),
+		unchanged: z.boolean().optional().describe('True if snapshot content is unchanged'),
+		existingId: z.string().optional().describe('ID of existing unchanged snapshot'),
+		existingName: z.string().optional().describe('Name of existing unchanged snapshot'),
+		existingTag: z.string().optional().describe('Tag of existing unchanged snapshot'),
+	})
+	.describe('Response from snapshot build init API');
+
+const SnapshotBuildInitAPIResponseSchema = APIResponseSchema(SnapshotBuildInitResponseSchema);
+
+const _SnapshotBuildFinalizeParamsSchema = z
+	.object({
+		snapshotId: z.string().describe('Snapshot ID from init response'),
+		sizeBytes: z.number().describe('Total size of the snapshot in bytes'),
+		fileCount: z.number().describe('Number of files in the snapshot'),
+		files: z
+			.array(SnapshotFileInfoSchema)
+			.describe('List of files with path and size'),
+		dependencies: z
+			.array(z.string())
+			.optional()
+			.describe('List of apt packages to install'),
+		env: z
+			.record(z.string(), z.string())
+			.optional()
+			.describe('Environment variables to set'),
+		metadata: z
+			.record(z.string(), z.string())
+			.optional()
+			.describe('User-defined metadata key-value pairs'),
+		orgId: z.string().optional().describe('Organization ID'),
+	})
+	.describe('Parameters for finalizing a snapshot build');
+
+export type SnapshotBuildInitParams = z.infer<typeof _SnapshotBuildInitParamsSchema>;
+export type SnapshotBuildInitResponse = z.infer<typeof SnapshotBuildInitResponseSchema>;
+export type SnapshotBuildFinalizeParams = z.infer<typeof _SnapshotBuildFinalizeParamsSchema>;
+
+/**
+ * Initialize a snapshot build by getting a presigned upload URL.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including runtime and optional name/tag/description
+ * @returns Snapshot ID and presigned upload URL
+ * @throws {SandboxResponseError} If the initialization fails
+ */
+export async function snapshotBuildInit(
+	client: APIClient,
+	params: SnapshotBuildInitParams
+): Promise<SnapshotBuildInitResponse> {
+	const { runtime, name, description, tag, contentHash, force, orgId } = params;
+	const queryString = buildQueryString({ orgId });
+	const url = `/sandbox/${API_VERSION}/snapshots/build${queryString}`;
+
+	const body: Record<string, string | boolean> = { runtime };
+	if (name) body.name = name;
+	if (description) body.description = description;
+	if (tag) body.tag = tag;
+	if (contentHash) body.contentHash = contentHash;
+	if (force) body.force = force;
+
+	const resp = await client.post<z.infer<typeof SnapshotBuildInitAPIResponseSchema>>(
+		url,
+		body,
+		SnapshotBuildInitAPIResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new SandboxResponseError({ message: resp.message });
+}
+
+/**
+ * Finalize a snapshot build after uploading the archive.
+ *
+ * @param client - The API client to use for the request
+ * @param params - Parameters including snapshot details and file metadata
+ * @returns The created snapshot information
+ * @throws {SandboxResponseError} If the finalization fails
+ */
+export async function snapshotBuildFinalize(
+	client: APIClient,
+	params: SnapshotBuildFinalizeParams
+): Promise<SnapshotInfo> {
+	const { snapshotId, sizeBytes, fileCount, files, dependencies, env, metadata, orgId } = params;
+	const queryString = buildQueryString({ orgId });
+	const url = `/sandbox/${API_VERSION}/snapshots/${snapshotId}/finalize${queryString}`;
+
+	const body: Record<string, unknown> = {
+		sizeBytes,
+		fileCount,
+		files,
+	};
+	if (dependencies) body.dependencies = dependencies;
+	if (env) body.env = env;
+	if (metadata) body.metadata = metadata;
+
+	const resp = await client.post<z.infer<typeof SnapshotGetResponseSchema>>(
+		url,
+		body,
+		SnapshotGetResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new SandboxResponseError({ message: resp.message });
+}

package/src/config.ts

@@ -41,7 +41,7 @@ export function getServiceUrls(region?: string): ServiceUrls {
 }
 
 function getDomainSuffix(region?: string) {
-	if (region === 'local') {
+	if (region === 'local' || region === 'l') {
 		return 'agentuity.io';
 	}
 	return 'agentuity.cloud';