@agentuity/core 1.0.31 → 1.0.33

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

@@ -0,0 +1,39 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+
+export 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'),
+});
+
+export 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,59 @@
+import { z } from 'zod';
+import { type APIClient, APIResponseSchema } from '../api.ts';
+
+export 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'),
+});
+
+export const EvalRunListResponseData = z.array(EvalRunSchema);
+export const EvalRunListResponseSchema = APIResponseSchema(EvalRunListResponseData);
+
+export type EvalRunListItem = z.infer<typeof EvalRunSchema>;
+export type EvalRunListRequest = {
+	projectId?: string;
+	agentId?: string;
+	evalId?: string;
+	sessionId?: string;
+	orgId?: string;
+};
+
+export async function evalRunList(
+	client: APIClient,
+	request: EvalRunListRequest = {}
+): Promise<EvalRunListItem[]> {
+	const params = new URLSearchParams();
+	if (request.orgId) params.set('orgId', request.orgId);
+	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

@@ -0,0 +1,20 @@
+export * from './config.ts';
+export * from './env.ts';
+export * from './logger.ts';
+export * from './api.ts';
+export * from './apikey/index.ts';
+export * from './storage/index.ts';
+export * from './db/index.ts';
+export * from './eval/index.ts';
+export * from './machine/index.ts';
+export * from './org/index.ts';
+export * from './project/index.ts';
+export * from './queue/index.ts';
+export * from './region/index.ts';
+export * from './webhook/index.ts';
+export * from './sandbox/index.ts';
+export * from './services/index.ts';
+export * from './session/index.ts';
+export * from './stream/index.ts';
+export * from './thread/index.ts';
+export * from './user/index.ts';

package/src/api/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/api/machine/index.ts

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

package/src/api/machine/machine.ts

@@ -0,0 +1,160 @@
+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(),
+	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(),
+	region: z.string(),
+	startedAt: z.string().nullable().optional(),
+	stoppedAt: z.string().nullable().optional(),
+	pausedAt: z.string().nullable().optional(),
+	erroredAt: z.string().nullable().optional(),
+	error: z.string().nullable().optional(),
+	orgId: z.string().nullable().optional(),
+	orgName: z.string().nullable().optional(),
+	createdAt: z.string(),
+	updatedAt: z.string().nullable().optional(),
+	metadata: z.record(z.string(), z.unknown()).nullable().optional(),
+});
+
+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(),
+	name: z.string(),
+	identifier: z.string(),
+	domains: z.array(z.string()),
+});
+
+export type MachineDeploymentProject = z.infer<typeof MachineDeploymentProjectSchema>;
+
+export const MachineDeploymentResourcesSchema = z.object({
+	cpuUnits: z.number(),
+	memoryUnits: z.number(),
+	diskUnits: z.number(),
+});
+
+export type MachineDeploymentResources = z.infer<typeof MachineDeploymentResourcesSchema>;
+
+export const MachineDeploymentSchema = z.object({
+	id: z.string(),
+	identifier: z.string().optional(),
+	state: z.string().optional(),
+	project: MachineDeploymentProjectSchema.nullable().optional(),
+	resources: MachineDeploymentResourcesSchema.nullable().optional(),
+	customDomains: z.array(z.string()),
+	paused: z.boolean(),
+	pausedDuration: z.number(),
+	domainSuffix: z.string(),
+});
+
+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(),
+	})
+);
+
+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(),
+	})
+);
+
+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/api/machine/util.ts

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

package/src/api/org/env-delete.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchemaNoData } from '../api.ts';
+import { OrgResponseError } from './util.ts';
+
+export const OrgEnvDeleteRequestSchema = z.object({
+	id: z.string().describe('the organization id'),
+	env: z.array(z.string()).optional().describe('environment variable keys to delete'),
+	secrets: z.array(z.string()).optional().describe('secret keys to delete'),
+});
+
+export const OrgEnvDeleteResponseSchema = APIResponseSchemaNoData();
+
+export type OrgEnvDeleteRequest = z.infer<typeof OrgEnvDeleteRequestSchema>;
+export type OrgEnvDeleteResponse = z.infer<typeof OrgEnvDeleteResponseSchema>;
+
+/**
+ * Delete environment variables and/or secrets from an organization.
+ * Provide arrays of keys to delete.
+ * Requires admin/owner role.
+ */
+export async function orgEnvDelete(client: APIClient, request: OrgEnvDeleteRequest): Promise<void> {
+	const { id, env, secrets } = request;
+
+	const resp = await client.request<OrgEnvDeleteResponse, Omit<OrgEnvDeleteRequest, 'id'>>(
+		'DELETE',
+		`/cli/organization/${encodeURIComponent(id)}/env`,
+		OrgEnvDeleteResponseSchema,
+		{
+			env,
+			secrets,
+		}
+	);
+
+	if (!resp.success) {
+		throw new OrgResponseError({ message: resp.message ?? 'failed to delete org env' });
+	}
+}

package/src/api/org/env-get.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api.ts';
+import { OrgResponseError } from './util.ts';
+
+export const OrgEnvDataSchema = z.object({
+	id: z.string().describe('the organization id'),
+	env: z.record(z.string(), z.string()).optional().describe('environment variables'),
+	secrets: z.record(z.string(), z.string()).optional().describe('secrets (may be masked)'),
+});
+
+export const OrgEnvGetResponseSchema = APIResponseSchema(OrgEnvDataSchema);
+
+interface OrgEnvGetRequest {
+	id: string;
+	mask?: boolean;
+}
+export type OrgEnvGetResponse = z.infer<typeof OrgEnvGetResponseSchema>;
+
+export type OrgEnv = z.infer<typeof OrgEnvDataSchema>;
+
+/**
+ * Get environment variables and secrets for an organization.
+ * Secrets are masked by default unless mask=false is specified.
+ * Note: Unmasked values require admin/owner role.
+ */
+export async function orgEnvGet(client: APIClient, request: OrgEnvGetRequest): Promise<OrgEnv> {
+	const { id, mask = true } = request;
+
+	const resp = await client.get<OrgEnvGetResponse>(
+		`/cli/organization/${encodeURIComponent(id)}/env?mask=${mask}`,
+		OrgEnvGetResponseSchema
+	);
+
+	if (!resp.success) {
+		throw new OrgResponseError({ message: resp.message ?? 'failed to get org env' });
+	}
+
+	if (!resp.data) {
+		throw new OrgResponseError({ message: 'failed to get org env: no data returned' });
+	}
+
+	return resp.data;
+}

package/src/api/org/env-update.ts

@@ -0,0 +1,38 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchemaNoData } from '../api.ts';
+import { OrgResponseError } from './util.ts';
+
+export const OrgEnvUpdateRequestSchema = z.object({
+	id: z.string().describe('the organization id'),
+	env: z.record(z.string(), z.string()).optional().describe('environment variables to set/update'),
+	secrets: z.record(z.string(), z.string()).optional().describe('secrets to set/update'),
+});
+
+export const OrgEnvUpdateResponseSchema = APIResponseSchemaNoData();
+
+export type OrgEnvUpdateRequest = z.infer<typeof OrgEnvUpdateRequestSchema>;
+export type OrgEnvUpdateResponse = z.infer<typeof OrgEnvUpdateResponseSchema>;
+
+/**
+ * Update environment variables and/or secrets for an organization.
+ * This will merge the provided env/secrets with existing values.
+ * Requires admin/owner role.
+ * Keys starting with 'AGENTUITY_' (except AGENTUITY_PUBLIC_) are filtered out.
+ */
+export async function orgEnvUpdate(client: APIClient, request: OrgEnvUpdateRequest): Promise<void> {
+	const { id, env, secrets } = request;
+
+	const resp = await client.request<OrgEnvUpdateResponse, Omit<OrgEnvUpdateRequest, 'id'>>(
+		'PUT',
+		`/cli/organization/${id}/env`,
+		OrgEnvUpdateResponseSchema,
+		{
+			env,
+			secrets,
+		}
+	);
+
+	if (!resp.success) {
+		throw new OrgResponseError({ message: resp.message ?? 'failed to update org env' });
+	}
+}

package/src/api/org/index.ts

@@ -0,0 +1,6 @@
+export * from './env-delete.ts';
+export * from './env-get.ts';
+export * from './env-update.ts';
+export * from './list.ts';
+export * from './resources.ts';
+export * from './util.ts';

package/src/api/org/list.ts

@@ -0,0 +1,28 @@
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api.ts';
+import { OrgResponseError } from './util.ts';
+
+export const ListOrganizationsResponse = z.array(
+	z.object({
+		id: z.string().describe('the unique id for the organization'),
+		name: z.string().describe('the name of the organization'),
+	})
+);
+export const ListOrganizationsResponseSchema = APIResponseSchema(ListOrganizationsResponse);
+
+export type ListOrganizationsResponse = z.infer<typeof ListOrganizationsResponseSchema>;
+export type OrganizationList = z.infer<typeof ListOrganizationsResponse>;
+
+/**
+ * List all organizations
+ *
+ * @param client
+ * @returns
+ */
+export async function listOrganizations(client: APIClient): Promise<OrganizationList> {
+	const resp = await client.get('/cli/organization', ListOrganizationsResponseSchema);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new OrgResponseError({ message: resp.message });
+}

package/src/api/org/resources.ts

@@ -0,0 +1,140 @@
+import type { SortDirection } from '../../services/pagination.ts';
+import { z } from 'zod';
+import { APIResponseSchema, APIClient } from '../api.ts';
+import { OrgResourceResponseError } from './util.ts';
+
+export const OrgS3Resource = z.object({
+	bucket_name: z.string().describe('the S3 bucket name'),
+	access_key: z.string().nullable().optional().describe('the S3 access key'),
+	secret_key: z.string().nullable().optional().describe('the S3 secret key'),
+	region: z.string().nullable().optional().describe('the S3 region'),
+	endpoint: z.string().nullable().optional().describe('the S3 endpoint'),
+	cloud_region: z.string().describe('the cloud region where this resource is provisioned'),
+	org_id: z.string().describe('the organization ID that owns this resource'),
+	org_name: z.string().describe('the organization name that owns this resource'),
+	bucket_type: z.string().describe('the bucket type (user or snapshots)'),
+	internal: z.boolean().describe('whether this is a system-managed bucket'),
+	description: z.string().nullable().optional().describe('optional description of the bucket'),
+	object_count: z
+		.number()
+		.int()
+		.nonnegative()
+		.optional()
+		.describe('number of objects in this bucket'),
+	total_size: z.number().int().nonnegative().optional().describe('total size of objects in bytes'),
+	last_event_at: z.string().optional().describe('last activity timestamp (ISO8601)'),
+});
+
+export const OrgDBResource = z.object({
+	name: z.string().describe('the database name'),
+	description: z.string().nullable().optional().describe('optional description of the database'),
+	username: z.string().nullable().optional().describe('the database username'),
+	password: z.string().nullable().optional().describe('the database password'),
+	url: z.string().nullable().optional().describe('the full database connection URL'),
+	cloud_region: z.string().describe('the cloud region where this resource is provisioned'),
+	org_id: z.string().describe('the organization ID that owns this resource'),
+	org_name: z.string().describe('the organization name that owns this resource'),
+	internal: z.boolean().describe('whether this is a system-managed database (KV/Vector/Queue)'),
+});
+
+export const OrgResourceListResponse = z.object({
+	s3: z.array(OrgS3Resource),
+	db: z.array(OrgDBResource),
+});
+
+export const OrgResourceListResponseSchema = APIResponseSchema(OrgResourceListResponse);
+
+export type OrgResourceListResponse = z.infer<typeof OrgResourceListResponseSchema>;
+export type OrgResourceList = z.infer<typeof OrgResourceListResponse>;
+export type OrgS3Resource = z.infer<typeof OrgS3Resource>;
+export type OrgDBResource = z.infer<typeof OrgDBResource>;
+
+export type ResourceSortField = 'name' | 'created' | 'region';
+
+export interface ListOrgResourcesOptions {
+	/** Filter by resource type (default: "all") */
+	type?: 'all' | 's3' | 'db';
+	/** Filter by resource name substring */
+	name?: string;
+	/** Organization ID (required for CLI auth, extracted from context for SDK auth) */
+	orgId?: string;
+	/** Maximum number of resources to return */
+	limit?: number;
+	/** Number of resources to skip for pagination */
+	offset?: number;
+	/** Field to sort by */
+	sort?: ResourceSortField;
+	/** Sort direction (default: 'desc') */
+	direction?: SortDirection;
+}
+
+/**
+ * List all resources for the authenticated organization (across all regions)
+ *
+ * @param client - Catalyst API client (must be authenticated)
+ * @param options - Optional filters including orgId for CLI auth
+ * @returns List of S3 and DB resources with their cloud regions
+ *
+ * @example
+ * // 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', orgId: 'org_123' });
+ *
+ * @example
+ * // Get only DBs
+ * const dbsOnly = await listOrgResources(client, { type: 'db', orgId: 'org_123' });
+ */
+export async function listOrgResources(
+	client: APIClient,
+	options?: ListOrgResourcesOptions
+): Promise<OrgResourceList> {
+	const params = new URLSearchParams();
+	if (options?.type && options.type !== 'all') {
+		params.set('type', options.type);
+	}
+	if (options?.name) {
+		params.set('name', options.name);
+	}
+	if (options?.limit !== undefined) {
+		params.set('limit', options.limit.toString());
+	}
+	if (options?.offset !== undefined) {
+		params.set('offset', options.offset.toString());
+	}
+	if (options?.sort) {
+		params.set('sort', options.sort);
+	}
+	if (options?.direction) {
+		params.set('direction', options.direction);
+	}
+
+	const query = params.toString();
+	const url = `/resource${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,
+		undefined,
+		undefined,
+		undefined,
+		headers
+	);
+	if (resp.success) {
+		return resp.data;
+	}
+	throw new OrgResourceResponseError({ message: resp.message });
+}

package/src/api/org/util.ts

@@ -0,0 +1,4 @@
+import { StructuredError } from '../../error.ts';
+
+export const OrgResponseError = StructuredError('OrgResponseError');
+export const OrgResourceResponseError = StructuredError('OrgResourceResponseError');