@agentuity/core 2.0.7 → 2.0.9-v3.48d5810

package/src/services/coder/workspaces.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod/v4';
+import { type APIClient } from '../api.ts';
+import {
+	CoderCreateWorkspaceRequestSchema,
+	CoderWorkspaceDetailSchema,
+	CoderWorkspaceListResponseSchema,
+	type CoderCreateWorkspaceRequest,
+	type CoderWorkspaceDetail,
+	type CoderWorkspaceListResponse,
+} from './types.ts';
+
+const WorkspaceGetResponseSchema = z
+	.object({
+		workspace: CoderWorkspaceDetailSchema.describe('Workspace payload returned by coder hub'),
+	})
+	.passthrough()
+	.describe('Wrapped workspace response from coder hub');
+
+const WorkspaceCreateResponseSchema = z
+	.object({
+		workspace: CoderWorkspaceDetailSchema.describe(
+			'Created workspace payload returned by coder hub'
+		),
+	})
+	.passthrough()
+	.describe('Wrapped workspace create response from coder hub');
+
+const OkResponseSchema = z
+	.object({
+		ok: z.boolean().describe('Operation success indicator'),
+	})
+	.passthrough()
+	.describe('Generic ok response from coder hub');
+
+export async function coderListWorkspaces(client: APIClient): Promise<CoderWorkspaceListResponse> {
+	return client.get<CoderWorkspaceListResponse>(
+		'/hub/workspaces',
+		CoderWorkspaceListResponseSchema
+	);
+}
+
+export async function coderGetWorkspace(
+	client: APIClient,
+	params: { workspaceId: string }
+): Promise<CoderWorkspaceDetail> {
+	const path = `/hub/workspaces/${encodeURIComponent(params.workspaceId)}`;
+	const resp = await client.get<z.infer<typeof WorkspaceGetResponseSchema>>(
+		path,
+		WorkspaceGetResponseSchema
+	);
+	return resp.workspace;
+}
+
+export async function coderCreateWorkspace(
+	client: APIClient,
+	params: { body: CoderCreateWorkspaceRequest }
+): Promise<CoderWorkspaceDetail> {
+	const resp = await client.post<
+		z.infer<typeof WorkspaceCreateResponseSchema>,
+		CoderCreateWorkspaceRequest
+	>(
+		'/hub/workspaces',
+		params.body,
+		WorkspaceCreateResponseSchema,
+		CoderCreateWorkspaceRequestSchema
+	);
+
+	return resp.workspace;
+}
+
+export async function coderDeleteWorkspace(
+	client: APIClient,
+	params: { workspaceId: string }
+): Promise<void> {
+	const path = `/hub/workspaces/${encodeURIComponent(params.workspaceId)}`;
+	await client.delete(path, OkResponseSchema);
+}

package/src/services/index.ts

@@ -9,6 +9,7 @@ export * from './task/index.ts';
 export * from './vector/index.ts';
 
 export * from './config.ts';
+export * from './coder/index.ts';
 export * from './env.ts';
 export * from './logger.ts';
 export * from './api.ts';

package/src/services/oauth/types.ts

@@ -20,6 +20,7 @@ export const OAuthClientSchema = z.object({
 	id_token_lifetime_seconds: z.number().optional(),
 	allowed_user_ids: z.array(z.string()),
 	internal: z.boolean().optional().default(false),
+	is_public: z.boolean().default(true),
 	created_at: z.string(),
 	updated_at: z.string(),
 });
@@ -50,6 +51,7 @@ export const OAuthClientCreateRequestSchema = z.object({
 	refresh_token_lifetime_seconds: z.number().optional(),
 	id_token_lifetime_seconds: z.number().optional(),
 	allowed_user_ids: z.array(z.string()).optional(),
+	is_public: z.boolean().optional(),
 });
 
 export type OAuthClientCreateRequest = z.infer<typeof OAuthClientCreateRequestSchema>;
@@ -77,6 +79,7 @@ export const OAuthClientUpdateRequestSchema = z.object({
 	refresh_token_lifetime_seconds: z.number().optional(),
 	id_token_lifetime_seconds: z.number().optional(),
 	allowed_user_ids: z.array(z.string()).optional(),
+	is_public: z.boolean().optional(),
 });
 
 export type OAuthClientUpdateRequest = z.infer<typeof OAuthClientUpdateRequestSchema>;
@@ -313,6 +316,7 @@ export const OAuthUserInfoSchema = z
 		name: z.string().optional(),
 		given_name: z.string().optional(),
 		family_name: z.string().optional(),
+		picture: z.string().optional(),
 		email: z.string().optional(),
 		email_verified: z.boolean().optional(),
 	})

package/src/services/project/deploy.ts

@@ -73,33 +73,71 @@ export const BuildAgentSchema = z.object({
 	...BaseAgentFields,
 });
 
+/**
+ * Launch process definition — describes how to start the application.
+ * Produced by the buildpack pipeline for any framework.
+ */
+export const LaunchProcessSchema = z.object({
+	type: z.string().describe('process type (e.g., web, worker)'),
+	command: z.string().describe('command to execute'),
+	default: z.boolean().describe('whether this is the default process'),
+	workingDirectory: z.string().optional().describe('working directory relative to app root'),
+});
+
+export const LaunchMetadataSchema = z.object({
+	processes: z.array(LaunchProcessSchema).describe('application processes'),
+	framework: z.object({
+		name: z.string().describe('detected framework name'),
+		version: z.string().optional().describe('framework version'),
+	}),
+	runtime: z.object({
+		name: z.string().describe('runtime binary (node, bun, deno)'),
+		port: z.number().optional().describe('port the app listens on'),
+	}),
+	build: z.object({
+		date: z.string().describe('build timestamp'),
+		duration: z.number().describe('build duration in ms'),
+	}),
+});
+
+export type LaunchMetadata = z.infer<typeof LaunchMetadataSchema>;
+
 export const BuildMetadataSchema = z.object({
-	routes: z.array(
-		z.object({
-			id: z.string().describe('the unique calculated id for the route'),
-			filename: z.string().describe('the relative path for the file'),
-			path: z.string().describe('the route path'),
-			method: z.enum(['get', 'post', 'put', 'delete', 'patch']).describe('the HTTP method'),
-			version: z.string().describe('the SHA256 content of the file'),
-			type: z.enum(['api', 'sms', 'email', 'cron', 'websocket', 'sse', 'stream']),
-			agentIds: z
-				.array(z.string())
-				.optional()
-				.describe('the agent ids associated with this route'),
-			config: z
-				.record(z.string(), z.unknown())
-				.optional()
-				.describe('type specific configuration'),
-			schema: z
-				.object({
-					input: z.string().optional().describe('JSON schema for input (stringified JSON)'),
-					output: z.string().optional().describe('JSON schema for output (stringified JSON)'),
-				})
-				.optional()
-				.describe('input and output JSON schemas for the route'),
-		})
-	),
-	agents: z.array(BuildAgentSchema),
+	routes: z
+		.array(
+			z.object({
+				id: z.string().describe('the unique calculated id for the route'),
+				filename: z.string().describe('the relative path for the file'),
+				path: z.string().describe('the route path'),
+				method: z.enum(['get', 'post', 'put', 'delete', 'patch']).describe('the HTTP method'),
+				version: z.string().describe('the SHA256 content of the file'),
+				type: z.enum(['api', 'sms', 'email', 'cron', 'websocket', 'sse', 'stream']),
+				agentIds: z
+					.array(z.string())
+					.optional()
+					.describe('the agent ids associated with this route'),
+				config: z
+					.record(z.string(), z.unknown())
+					.optional()
+					.describe('type specific configuration'),
+				schema: z
+					.object({
+						input: z.string().optional().describe('JSON schema for input (stringified JSON)'),
+						output: z
+							.string()
+							.optional()
+							.describe('JSON schema for output (stringified JSON)'),
+					})
+					.optional()
+					.describe('input and output JSON schemas for the route'),
+			})
+		)
+		.default([])
+		.describe('routes — only present for Agentuity native apps'),
+	agents: z
+		.array(BuildAgentSchema)
+		.default([])
+		.describe('agents — only present for Agentuity native apps'),
 	assets: z.array(
 		z.object({
 			filename: z.string().describe('the relative path for the file'),
@@ -176,6 +214,9 @@ export const BuildMetadataSchema = z.object({
 			}),
 		})
 	),
+	launch: LaunchMetadataSchema.optional().describe(
+		'launch metadata — how to start the application (processes, framework, runtime)'
+	),
 });
 
 export type BuildMetadata = z.infer<typeof BuildMetadataSchema>;

package/src/services/queue/service.ts

@@ -308,6 +308,14 @@ export interface QueueService {
  */
 export const QueuePublishError = StructuredError('QueuePublishError');
 
+/**
+ * Error thrown when a queue creation operation fails.
+ *
+ * This is a general error for create failures that aren't specifically
+ * validation, not-found, or conflict (409) errors.
+ */
+export const QueueCreateError = StructuredError('QueueCreateError');
+
 /**
  * Error thrown when a queue is not found.
  *
@@ -389,6 +397,33 @@ function validatePayloadInternal(payload: string): void {
 	}
 }
 
+/**
+ * Unwraps the standard API response envelope.
+ *
+ * The queue server returns responses wrapped in:
+ *   { success: true, data: { [key]: { ...actual data... } } }
+ *
+ * Since `fromResponse()` parses the raw JSON body, `res.data` from the
+ * adapter is the full envelope. This helper extracts the nested data by key.
+ *
+ * Falls back to treating the input as already-unwrapped data (e.g., in tests
+ * using mock adapters that provide flat data directly).
+ *
+ * @internal
+ */
+function unwrapApiResponse<T>(data: unknown, key: string): T {
+	if (data !== null && typeof data === 'object') {
+		const body = data as Record<string, unknown>;
+		if (body.success === true && typeof body.data === 'object' && body.data !== null) {
+			const envelope = body.data as Record<string, unknown>;
+			if (key in envelope) {
+				return envelope[key] as T;
+			}
+		}
+	}
+	return data as T;
+}
+
 // ============================================================================
 // QueueStorageService Implementation
 // ============================================================================
@@ -496,16 +531,18 @@ export class QueueStorageService implements QueueService {
 		});
 
 		if (res.ok) {
-			const data = res.data as unknown as {
-				id: string;
-				offset: number;
-				published_at: string;
-			};
-			return {
+			const data = unwrapApiResponse<Record<string, unknown>>(res.data, 'message');
+			const result = QueuePublishResultSchema.safeParse({
 				id: data.id,
 				offset: data.offset,
 				publishedAt: data.published_at,
-			};
+			});
+			if (result.success) {
+				return result.data;
+			}
+			throw new QueuePublishError({
+				message: `Queue publish returned an unexpected response format: ${result.error.message}`,
+			});
 		}
 
 		if (res.response.status === 404) {
@@ -579,12 +616,18 @@ export class QueueStorageService implements QueueService {
 		});
 
 		if (res.ok) {
-			const data = res.data as unknown as Record<string, unknown>;
-			this.#knownQueues.add(queueName);
-			return {
-				name: (data.name as string) ?? queueName,
-				queueType: (data.queue_type as string) ?? params?.queueType ?? 'worker',
-			};
+			const data = unwrapApiResponse<Record<string, unknown>>(res.data, 'queue');
+			const result = QueueCreateResultSchema.safeParse({
+				name: data.name,
+				queueType: data.queue_type,
+			});
+			if (result.success) {
+				this.#knownQueues.add(queueName);
+				return result.data;
+			}
+			throw new QueueCreateError({
+				message: `Queue create returned an unexpected response format: ${result.error.message}`,
+			});
 		}
 
 		if (res.response.status === 409) {

package/src/services/sandbox/client.ts

@@ -257,14 +257,16 @@ export interface SandboxInstance {
 	mkDir(path: string, recursive?: boolean): Promise<void>;
 
 	/**
-	 * Remove a file from the sandbox workspace
+	 * Remove a file from the sandbox workspace.
+	 * @returns Object with `found` indicating whether the file existed before removal
 	 */
-	rmFile(path: string): Promise<void>;
+	rmFile(path: string): Promise<{ found: boolean }>;
 
 	/**
-	 * Remove a directory from the sandbox workspace
+	 * Remove a directory from the sandbox workspace.
+	 * @returns Object with `found` indicating whether the directory existed before removal
 	 */
-	rmDir(path: string, recursive?: boolean): Promise<void>;
+	rmDir(path: string, recursive?: boolean): Promise<{ found: boolean }>;
 
 	/**
 	 * Set environment variables on the sandbox. Pass null to delete a variable.
@@ -380,12 +382,12 @@ function createSandboxInstanceMethods(
 			await sandboxMkDir(client, { sandboxId, path, recursive, orgId });
 		},
 
-		async rmFile(path: string): Promise<void> {
-			await sandboxRmFile(client, { sandboxId, path, orgId });
+		async rmFile(path: string): Promise<{ found: boolean }> {
+			return sandboxRmFile(client, { sandboxId, path, orgId });
 		},
 
-		async rmDir(path: string, recursive?: boolean): Promise<void> {
-			await sandboxRmDir(client, { sandboxId, path, recursive, orgId });
+		async rmDir(path: string, recursive?: boolean): Promise<{ found: boolean }> {
+			return sandboxRmDir(client, { sandboxId, path, recursive, orgId });
 		},
 
 		async setEnv(env: Record<string, string | null>): Promise<Record<string, string>> {

package/src/services/sandbox/files.ts

@@ -217,6 +217,13 @@ export const RmDirResponseSchema = z.discriminatedUnion('success', [
 	}),
 	z.object({
 		success: z.literal<true>(true),
+		found: z
+			.boolean()
+			.optional()
+			.default(true)
+			.describe(
+				'Whether the directory existed before removal. False when already removed (idempotent).'
+			),
 	}),
 ]);
 
@@ -235,9 +242,13 @@ export type RmDirParams = z.infer<typeof RmDirParamsSchema>;
  *
  * @param client - The API client to use for the request
  * @param params - Parameters including sandbox ID, path, and recursive flag
+ * @returns Object with `found` indicating whether the directory existed before removal
  * @throws {SandboxResponseError} If the rmdir request fails
  */
-export async function sandboxRmDir(client: APIClient, params: RmDirParams): Promise<void> {
+export async function sandboxRmDir(
+	client: APIClient,
+	params: RmDirParams
+): Promise<{ found: boolean }> {
 	const { sandboxId, path, recursive, orgId, signal } = params;
 
 	const body: z.infer<typeof RmDirRequestSchema> = {
@@ -263,6 +274,8 @@ export async function sandboxRmDir(client: APIClient, params: RmDirParams): Prom
 	if (!resp.success) {
 		throwSandboxError(resp, { sandboxId });
 	}
+
+	return { found: resp.found };
 }
 
 export const RmFileRequestSchema = z
@@ -278,6 +291,13 @@ export const RmFileResponseSchema = z.discriminatedUnion('success', [
 	}),
 	z.object({
 		success: z.literal<true>(true),
+		found: z
+			.boolean()
+			.optional()
+			.default(true)
+			.describe(
+				'Whether the file existed before removal. False when already removed (idempotent).'
+			),
 	}),
 ]);
 
@@ -295,9 +315,13 @@ export type RmFileParams = z.infer<typeof RmFileParamsSchema>;
  *
  * @param client - The API client to use for the request
  * @param params - Parameters including sandbox ID and path
+ * @returns Object with `found` indicating whether the file existed before removal
  * @throws {SandboxResponseError} If the rm request fails
  */
-export async function sandboxRmFile(client: APIClient, params: RmFileParams): Promise<void> {
+export async function sandboxRmFile(
+	client: APIClient,
+	params: RmFileParams
+): Promise<{ found: boolean }> {
 	const { sandboxId, path, orgId, signal } = params;
 
 	const body: z.infer<typeof RmFileRequestSchema> = {
@@ -322,6 +346,8 @@ export async function sandboxRmFile(client: APIClient, params: RmFileParams): Pr
 	if (!resp.success) {
 		throwSandboxError(resp, { sandboxId });
 	}
+
+	return { found: resp.found };
 }
 
 export const FileInfoSchema = z.object({

package/src/services/sandbox/types.ts

@@ -383,14 +383,16 @@ export const SandboxSchema = z.object({
 	mkDir: z
 		.custom<(path: string, recursive?: boolean) => Promise<void>>()
 		.describe('Create a directory in the sandbox workspace.'),
-	/** Remove a file from the sandbox workspace. */
+	/** Remove a file from the sandbox workspace. Returns whether the file was found. */
 	rmFile: z
-		.custom<(path: string) => Promise<void>>()
-		.describe('Remove a file from the sandbox workspace.'),
-	/** Remove a directory from the sandbox workspace. */
+		.custom<(path: string) => Promise<{ found: boolean }>>()
+		.describe('Remove a file from the sandbox workspace. Returns whether the file was found.'),
+	/** Remove a directory from the sandbox workspace. Returns whether the directory was found. */
 	rmDir: z
-		.custom<(path: string, recursive?: boolean) => Promise<void>>()
-		.describe('Remove a directory from the sandbox workspace.'),
+		.custom<(path: string, recursive?: boolean) => Promise<{ found: boolean }>>()
+		.describe(
+			'Remove a directory from the sandbox workspace. Returns whether the directory was found.'
+		),
 	/** Set environment variables on the sandbox. Pass null to delete a variable. */
 	setEnv: z
 		.custom<(env: Record<string, string | null>) => Promise<Record<string, string>>>()