@agentuity/core 1.0.32 → 1.0.34

package/src/services/{keyvalue.ts → keyvalue/service.ts}

@@ -1,6 +1,7 @@
-import { FetchAdapter } from './adapter.ts';
-import { buildUrl, toServiceException, toPayload } from './_util.ts';
-import type { SortDirection } from './pagination.ts';
+import { FetchAdapter } from '../adapter.ts';
+import { buildUrl, toServiceException, toPayload } from '../_util.ts';
+import { ListParamsSchema, SortDirectionSchema } from '../pagination.ts';
+import { z } from 'zod';
 
 /**
  * Minimum TTL value in seconds (1 minute)
@@ -20,46 +21,69 @@ export const KV_DEFAULT_TTL_SECONDS = 604800;
 /**
  * the result of a data operation when the data is found
  */
-export interface DataResultFound<T> {
-	/**
-	 * the data from the result of the operation
-	 */
+export const DataResultFoundSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
+	z.object({
+		/**
+		 * the data from the result of the operation
+		 */
+		data: dataSchema.describe('the data from the result of the operation'),
+
+		/**
+		 * the content type of the data
+		 */
+		contentType: z.string().describe('the content type of the data'),
+
+		/**
+		 * the data was found
+		 */
+		exists: z.literal(true).describe('the data was found'),
+
+		/**
+		 * the expiration time of the data as an ISO 8601 timestamp.
+		 * undefined if the key does not expire.
+		 */
+		expiresAt: z
+			.string()
+			.optional()
+			.describe('the expiration time of the data as an ISO 8601 timestamp.'),
+	});
+
+export type DataResultFound<T> = {
+	/** the data from the result of the operation */
 	data: T;
-
-	/**
-	 * the content type of the data
-	 */
+	/** the content type of the data */
 	contentType: string;
-
-	/**
-	 * the data was found
-	 */
+	/** the data was found */
 	exists: true;
-
 	/**
 	 * the expiration time of the data as an ISO 8601 timestamp.
 	 * undefined if the key does not expire.
 	 */
 	expiresAt?: string;
-}
+};
 
 /**
  * the result of a data operation when the data is not found
  */
-export interface DataResultNotFound {
-	data: never;
+export const DataResultNotFoundSchema = z.object({
+	data: z.never(),
 	/**
 	 * the data was not found
 	 */
-	exists: false;
-}
+	exists: z.literal(false).describe('the data was not found'),
+});
+
+export type DataResultNotFound = z.infer<typeof DataResultNotFoundSchema>;
 
 /**
  * the result of a data operation
  */
+export const DataResultSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
+	z.discriminatedUnion('exists', [DataResultFoundSchema(dataSchema), DataResultNotFoundSchema]);
+
 export type DataResult<T> = DataResultFound<T> | DataResultNotFound;
 
-export interface KeyValueStorageSetParams {
+export const KeyValueStorageSetParamsSchema = z.object({
 	/**
 	 * Time-to-live in seconds for the key. Controls when the key expires and is automatically deleted.
 	 * - `undefined` (not provided): Key inherits the namespace's default TTL (7 days if not configured)
@@ -70,17 +94,25 @@ export interface KeyValueStorageSetParams {
 	 * TTL values below 60 seconds are clamped to 60 seconds by the server.
 	 * TTL values above 7,776,000 seconds (90 days) are clamped to 90 days.
 	 */
-	ttl?: number | null;
+	ttl: z
+		.number()
+		.nullable()
+		.optional()
+		.describe(
+			'Time-to-live in seconds for the key. Controls when the key expires and is automatically deleted.'
+		),
 	/**
 	 * the content type of the value
 	 */
-	contentType?: string;
-}
+	contentType: z.string().optional().describe('the content type of the value'),
+});
+
+export type KeyValueStorageSetParams = z.infer<typeof KeyValueStorageSetParamsSchema>;
 
 /**
  * Parameters for creating a namespace
  */
-export interface CreateNamespaceParams {
+export const CreateNamespaceParamsSchema = z.object({
 	/**
 	 * Default TTL for keys in this namespace (in seconds).
 	 * - If undefined/omitted: uses server default (7 days / 604,800 seconds)
@@ -91,23 +123,60 @@ export interface CreateNamespaceParams {
 	 * Active keys are automatically extended (sliding expiration) when read
 	 * if their remaining TTL is less than 50% of the original TTL.
 	 */
-	defaultTTLSeconds?: number;
-}
+	defaultTTLSeconds: z
+		.number()
+		.optional()
+		.describe('Default TTL for keys in this namespace (in seconds).'),
+});
+
+export type CreateNamespaceParams = z.infer<typeof CreateNamespaceParamsSchema>;
 
 /**
  * Statistics for a key-value store namespace
  */
-export interface KeyValueStats {
-	sum: number;
-	count: number;
-	createdAt?: number;
-	lastUsedAt?: number;
-}
+export const KeyValueStatsSchema = z.object({
+	sum: z.number().describe('Total size in bytes for the namespace.'),
+	count: z.number().describe('Number of records in the namespace.'),
+	createdAt: z
+		.number()
+		.optional()
+		.describe('Unix timestamp (milliseconds) when the namespace was created.'),
+	lastUsedAt: z
+		.number()
+		.optional()
+		.describe('Unix timestamp (milliseconds) when the namespace was last used.'),
+});
+
+export type KeyValueStats = z.infer<typeof KeyValueStatsSchema>;
 
 /**
  * Item with metadata from search results
  */
-export interface KeyValueItemWithMetadata<T = unknown> {
+export const KeyValueItemWithMetadataSchema = <T extends z.ZodTypeAny>(valueSchema: T) =>
+	z.object({
+		value: valueSchema.describe('Stored value for this key.'),
+		contentType: z.string().describe('Content type of the stored value.'),
+		contentEncoding: z
+			.string()
+			.nullish()
+			.describe('Optional content encoding for the stored value.'),
+		size: z.number().describe('Size in bytes for the stored value.'),
+		expiresAt: z
+			.string()
+			.nullish()
+			.describe('Expiration timestamp as ISO 8601, null/undefined if no expiration.'),
+		firstUsed: z
+			.number()
+			.nullish()
+			.describe('Unix timestamp (milliseconds) when the key was first accessed.'),
+		lastUsed: z
+			.number()
+			.nullish()
+			.describe('Unix timestamp (milliseconds) when the key was last accessed.'),
+		count: z.number().nullish().describe('Number of times the key was accessed.'),
+	});
+
+export type KeyValueItemWithMetadata<T = unknown> = {
 	value: T;
 	contentType: string;
 	contentEncoding?: string | null;
@@ -116,77 +185,65 @@ export interface KeyValueItemWithMetadata<T = unknown> {
 	firstUsed?: number | null;
 	lastUsed?: number | null;
 	count?: number | null;
-}
+};
+
+export const KVSortFieldSchema = z.enum(['name', 'size', 'records', 'created', 'lastUsed']);
 
-export type KVSortField = 'name' | 'size' | 'records' | 'created' | 'lastUsed';
+export type KVSortField = z.infer<typeof KVSortFieldSchema>;
 
 /**
  * Parameters for getting all namespace statistics with optional pagination
  */
-export interface GetAllStatsParams {
-	/**
-	 * Filter namespaces by name substring
-	 */
-	name?: string;
-	/**
-	 * Maximum number of namespaces to return (default: 100, max: 1000)
-	 */
-	limit?: number;
-	/**
-	 * Number of namespaces to skip for pagination (default: 0)
-	 */
-	offset?: number;
-	/**
-	 * Field to sort by
-	 */
-	sort?: KVSortField;
-	/**
-	 * Sort direction (default: 'desc')
-	 */
-	direction?: SortDirection;
-	/**
-	 * Filter by project ID
-	 */
-	projectId?: string;
-	/**
-	 * Filter by agent ID
-	 */
-	agentId?: string;
-	/**
-	 * Filter by project name
-	 */
-	projectName?: string;
-	/**
-	 * Filter by agent name
-	 */
-	agentName?: string;
-}
+export const GetAllStatsParamsSchema = ListParamsSchema(KVSortFieldSchema).extend({
+	name: z.string().optional().describe('Filter namespaces by name substring'),
+	projectId: z.string().optional().describe('Filter by project ID'),
+	agentId: z.string().optional().describe('Filter by agent ID'),
+	projectName: z.string().optional().describe('Filter by project name'),
+	agentName: z.string().optional().describe('Filter by agent name'),
+	// re-describe inherited fields to preserve this file's docs
+	limit: z
+		.number()
+		.optional()
+		.describe('Maximum number of namespaces to return (default: 100, max: 1000)'),
+	offset: z
+		.number()
+		.optional()
+		.describe('Number of namespaces to skip for pagination (default: 0)'),
+	sort: KVSortFieldSchema.optional().describe('Field to sort by'),
+	direction: SortDirectionSchema.optional().describe("Sort direction (default: 'desc')"),
+});
+
+export type GetAllStatsParams = z.infer<typeof GetAllStatsParamsSchema>;
 
 /**
  * Paginated response for namespace statistics
  */
-export interface KeyValueStatsPaginated {
+export const KeyValueStatsPaginatedSchema = z.object({
 	/**
 	 * Map of namespace names to their statistics
 	 */
-	namespaces: Record<string, KeyValueStats>;
+	namespaces: z
+		.record(z.string(), KeyValueStatsSchema)
+		.describe('Map of namespace names to their statistics'),
 	/**
 	 * Total number of namespaces across all pages
 	 */
-	total: number;
+	total: z.number().describe('Total number of namespaces across all pages'),
 	/**
 	 * Number of namespaces requested per page
 	 */
-	limit: number;
+	limit: z.number().describe('Number of namespaces requested per page'),
 	/**
 	 * Number of namespaces skipped
 	 */
-	offset: number;
+	offset: z.number().describe('Number of namespaces skipped'),
 	/**
 	 * Whether there are more namespaces available
 	 */
-	hasMore: boolean;
-}
+	hasMore: z.boolean().describe('Whether there are more namespaces available'),
+});
+
+export type KeyValueStatsPaginated = z.infer<typeof KeyValueStatsPaginatedSchema>;
 
 export interface KeyValueStorage {
 	/**
@@ -344,7 +401,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	async get<T>(name: string, key: string): Promise<DataResult<T>> {
 		const url = buildUrl(
 			this.#baseUrl,
-			`/kv/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}`
+			`/kv/${encodeURIComponent(name)}/${encodeURIComponent(key)}`
 		);
 		const signal = AbortSignal.timeout(30_000); // 30s timeout for Neon cold starts
 		const res = await this.#adapter.invoke<T>(url, {
@@ -406,7 +463,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 		}
 		const url = buildUrl(
 			this.#baseUrl,
-			`/kv/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}${ttlstr}`
+			`/kv/${encodeURIComponent(name)}/${encodeURIComponent(key)}${ttlstr}`
 		);
 		const [body, contentType] = await toPayload(value);
 		const signal = AbortSignal.timeout(30_000);
@@ -433,7 +490,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	async delete(name: string, key: string): Promise<void> {
 		const url = buildUrl(
 			this.#baseUrl,
-			`/kv/2025-03-17/${encodeURIComponent(name)}/${encodeURIComponent(key)}`
+			`/kv/${encodeURIComponent(name)}/${encodeURIComponent(key)}`
 		);
 		const signal = AbortSignal.timeout(30_000);
 		const res = await this.#adapter.invoke(url, {
@@ -454,7 +511,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	}
 
 	async getStats(name: string): Promise<KeyValueStats> {
-		const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/stats/${encodeURIComponent(name)}`);
+		const url = buildUrl(this.#baseUrl, `/kv/stats/${encodeURIComponent(name)}`);
 		const signal = AbortSignal.timeout(30_000); // 30s timeout for Neon cold starts
 		const res = await this.#adapter.invoke<KeyValueStats>(url, {
 			method: 'GET',
@@ -502,10 +559,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 			queryParams.set('agent_name', params.agentName);
 		}
 		const queryString = queryParams.toString();
-		const url = buildUrl(
-			this.#baseUrl,
-			`/kv/2025-03-17/stats${queryString ? `?${queryString}` : ''}`
-		);
+		const url = buildUrl(this.#baseUrl, `/kv/stats${queryString ? `?${queryString}` : ''}`);
 		const signal = AbortSignal.timeout(30_000); // 30s timeout for Neon cold starts
 		const res = await this.#adapter.invoke<
 			Record<string, KeyValueStats> | KeyValueStatsPaginated
@@ -524,7 +578,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	}
 
 	async getNamespaces(): Promise<string[]> {
-		const url = buildUrl(this.#baseUrl, '/kv/2025-03-17/namespaces');
+		const url = buildUrl(this.#baseUrl, '/kv/namespaces');
 		const signal = AbortSignal.timeout(30_000); // 30s timeout for Neon cold starts
 		const res = await this.#adapter.invoke<string[]>(url, {
 			method: 'GET',
@@ -546,7 +600,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	): Promise<Record<string, KeyValueItemWithMetadata<T>>> {
 		const url = buildUrl(
 			this.#baseUrl,
-			`/kv/2025-03-17/search/${encodeURIComponent(name)}/${encodeURIComponent(keyword)}`
+			`/kv/search/${encodeURIComponent(name)}/${encodeURIComponent(keyword)}`
 		);
 		const signal = AbortSignal.timeout(30_000);
 		const res = await this.#adapter.invoke<Record<string, KeyValueItemWithMetadata<T>>>(url, {
@@ -564,7 +618,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	}
 
 	async getKeys(name: string): Promise<string[]> {
-		const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/keys/${encodeURIComponent(name)}`);
+		const url = buildUrl(this.#baseUrl, `/kv/keys/${encodeURIComponent(name)}`);
 		const signal = AbortSignal.timeout(30_000);
 		const res = await this.#adapter.invoke<string[]>(url, {
 			method: 'GET',
@@ -581,7 +635,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	}
 
 	async deleteNamespace(name: string): Promise<void> {
-		const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/${encodeURIComponent(name)}`);
+		const url = buildUrl(this.#baseUrl, `/kv/${encodeURIComponent(name)}`);
 		const signal = AbortSignal.timeout(30_000);
 		const res = await this.#adapter.invoke(url, {
 			method: 'DELETE',
@@ -598,7 +652,7 @@ export class KeyValueStorageService implements KeyValueStorage {
 	}
 
 	async createNamespace(name: string, params?: CreateNamespaceParams): Promise<void> {
-		const url = buildUrl(this.#baseUrl, `/kv/2025-03-17/${encodeURIComponent(name)}`);
+		const url = buildUrl(this.#baseUrl, `/kv/${encodeURIComponent(name)}`);
 		const signal = AbortSignal.timeout(30_000); // 30s timeout for Neon cold starts
 
 		const body =

package/src/services/logger.ts

@@ -0,0 +1,24 @@
+import type { Logger } from '../logger.ts';
+
+/**
+ * Create a minimal logger that works in any environment (browser + server).
+ * Used as default when no logger is provided.
+ */
+export function createMinimalLogger(): Logger {
+	const noop = () => {};
+	const logger: Logger = {
+		trace: noop,
+		debug: noop,
+		info: console.log.bind(console),
+		warn: console.warn.bind(console),
+		error: console.error.bind(console),
+		fatal(...args: unknown[]): never {
+			console.error(...args);
+			throw new Error(String(args[0] ?? 'fatal'));
+		},
+		child() {
+			return createMinimalLogger();
+		},
+	};
+	return logger;
+}

package/src/services/machine/index.ts

@@ -0,0 +1,2 @@
+export * from './machine.ts';
+export * from './util.ts';

package/src/services/machine/machine.ts

@@ -0,0 +1,228 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIResponseSchemaNoData, APIClient } from '../api.ts';
+import { MachineResponseError } from './util.ts';
+
+// TODO: The old /cli/auth/machine/* endpoints should be aliased to redirect
+// to /cli/auth/org/* in the backend (app repo). Remove aliases in follow-up PR.
+
+export const MachineSchema = z
+	.object({
+		id: z.string().describe('Unique identifier for the machine.'),
+		instanceId: z.string().nullable().optional().describe('Cloud provider instance ID.'),
+		privateIPv4: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('Private IPv4 address of the machine.'),
+		availabilityZone: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('Cloud provider availability zone.'),
+		instanceType: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('Cloud provider instance type (e.g., n1-standard-2).'),
+		instanceTags: z
+			.array(z.string())
+			.nullable()
+			.optional()
+			.describe('Tags assigned to the cloud instance.'),
+		deploymentCount: z
+			.number()
+			.optional()
+			.describe('Number of active deployments on this machine.'),
+		status: z
+			.string()
+			.describe('Current status of the machine (e.g., running, stopped, errored).'),
+		provider: z.string().describe('Cloud provider (e.g., gcp, aws).'),
+		region: z.string().describe('Cloud region where the machine is deployed.'),
+		startedAt: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('ISO 8601 timestamp when the machine was started.'),
+		stoppedAt: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('ISO 8601 timestamp when the machine was stopped.'),
+		pausedAt: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('ISO 8601 timestamp when the machine was paused.'),
+		erroredAt: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('ISO 8601 timestamp when the machine entered error state.'),
+		error: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('Error message if the machine is in an error state.'),
+		orgId: z.string().nullable().optional().describe('Organization ID that owns this machine.'),
+		orgName: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('Organization name that owns this machine.'),
+		createdAt: z.string().describe('ISO 8601 timestamp when the machine was created.'),
+		updatedAt: z
+			.string()
+			.nullable()
+			.optional()
+			.describe('ISO 8601 timestamp when the machine was last updated.'),
+		metadata: z
+			.record(z.string(), z.unknown())
+			.nullable()
+			.optional()
+			.describe('Arbitrary metadata associated with the machine.'),
+	})
+	.describe('Machine instance in the Agentuity infrastructure.');
+
+export const MachineListResponseSchema = APIResponseSchema(z.array(MachineSchema));
+export const MachineGetResponseSchema = APIResponseSchema(MachineSchema);
+export const MachineDeleteResponseSchema = APIResponseSchemaNoData();
+
+export type Machine = z.infer<typeof MachineSchema>;
+
+export async function machineList(
+	client: APIClient,
+	options?: { orgId?: string }
+): Promise<Machine[]> {
+	const headers = options?.orgId ? { 'x-agentuity-orgid': options.orgId } : undefined;
+	const resp = await client.get('/machine', MachineListResponseSchema, undefined, headers);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new MachineResponseError({ message: resp.message });
+}
+
+export async function machineGet(client: APIClient, machineId: string): Promise<Machine> {
+	const resp = await client.get(`/machine/${machineId}`, MachineGetResponseSchema);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new MachineResponseError({ message: resp.message });
+}
+
+export async function machineDelete(client: APIClient, machineId: string): Promise<void> {
+	const resp = await client.delete(`/machine/${machineId}`, MachineDeleteResponseSchema);
+	if (!resp.success) {
+		throw new MachineResponseError({ message: resp.message });
+	}
+}
+
+export const MachineDeploymentProjectSchema = z
+	.object({
+		id: z.string().describe('Unique identifier for the project.'),
+		name: z.string().describe('Human-readable project name.'),
+		identifier: z.string().describe('URL-safe project identifier.'),
+		domains: z.array(z.string()).describe('Custom domains assigned to this project.'),
+	})
+	.describe('Project associated with a machine deployment.');
+
+export type MachineDeploymentProject = z.infer<typeof MachineDeploymentProjectSchema>;
+
+export const MachineDeploymentResourcesSchema = z
+	.object({
+		cpuUnits: z.number().describe('CPU units allocated to the deployment.'),
+		memoryUnits: z.number().describe('Memory units allocated to the deployment.'),
+		diskUnits: z.number().describe('Disk units allocated to the deployment.'),
+	})
+	.describe('Resource allocation for a machine deployment.');
+
+export type MachineDeploymentResources = z.infer<typeof MachineDeploymentResourcesSchema>;
+
+export const MachineDeploymentSchema = z
+	.object({
+		id: z.string().describe('Unique identifier for the deployment.'),
+		identifier: z.string().optional().describe('URL-safe deployment identifier.'),
+		state: z.string().optional().describe('Current state of the deployment.'),
+		project: MachineDeploymentProjectSchema.nullable()
+			.optional()
+			.describe('Project associated with this deployment.'),
+		resources: MachineDeploymentResourcesSchema.nullable()
+			.optional()
+			.describe('Resource allocation for this deployment.'),
+		customDomains: z.array(z.string()).describe('Custom domains configured for this deployment.'),
+		paused: z.boolean().describe('Whether the deployment is currently paused.'),
+		pausedDuration: z.number().describe('Duration in seconds the deployment has been paused.'),
+		domainSuffix: z.string().describe('Domain suffix for the deployment URL.'),
+	})
+	.describe('Deployment running on a machine.');
+
+export const MachineDeploymentsResponseSchema = APIResponseSchema(z.array(MachineDeploymentSchema));
+
+export type MachineDeployment = z.infer<typeof MachineDeploymentSchema>;
+
+export async function machineDeployments(
+	client: APIClient,
+	machineId: string
+): Promise<MachineDeployment[]> {
+	const resp = await client.get(
+		`/machine/deployments/${machineId}`,
+		MachineDeploymentsResponseSchema
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new MachineResponseError({ message: resp.message });
+}
+
+export const OrgAuthEnrollResponseSchema = APIResponseSchema(
+	z.object({
+		orgId: z.string().describe('Organization ID that was enrolled.'),
+	})
+);
+
+export async function orgAuthEnroll(
+	client: APIClient,
+	orgId: string,
+	publicKey: string
+): Promise<{ orgId: string }> {
+	const resp = await client.post(
+		'/cli/auth/org/enroll',
+		{ orgId, publicKey },
+		OrgAuthEnrollResponseSchema
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new MachineResponseError({ message: resp.message });
+}
+
+export const OrgAuthStatusResponseSchema = APIResponseSchema(
+	z.object({
+		publicKey: z
+			.string()
+			.nullable()
+			.describe('Public key for the organization, or null if not enrolled.'),
+	})
+);
+
+export async function orgAuthStatus(
+	client: APIClient,
+	orgId: string
+): Promise<{ publicKey: string | null }> {
+	const resp = await client.get(`/cli/auth/org/status/${orgId}`, OrgAuthStatusResponseSchema);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new MachineResponseError({ message: resp.message });
+}
+
+export const OrgAuthUnenrollResponseSchema = APIResponseSchemaNoData();
+
+export async function orgAuthUnenroll(client: APIClient, orgId: string): Promise<void> {
+	const resp = await client.delete(
+		`/cli/auth/org/unenroll/${orgId}`,
+		OrgAuthUnenrollResponseSchema
+	);
+	if (!resp.success) {
+		throw new MachineResponseError({ message: resp.message });
+	}
+}

package/src/services/machine/util.ts

@@ -0,0 +1,5 @@
+import { StructuredError } from '../../error.ts';
+
+export const MachineResponseError = StructuredError('MachineResponseError')<{
+	message: string;
+}>();