@agentuity/server 1.0.0 → 1.0.2

package/src/api/project/malware.ts

@@ -1,42 +1,42 @@
 import { z } from 'zod';
 import { type APIClient, APIResponseSchema } from '../api';
 
-const PackageRef = z.object({
+export const PackageRefSchema = z.object({
 	name: z.string(),
 	version: z.string(),
 });
 
-export type PackageRef = z.infer<typeof PackageRef>;
+export type PackageRef = z.infer<typeof PackageRefSchema>;
 
-const MalwareFinding = z.object({
+export const MalwareFindingSchema = z.object({
 	name: z.string(),
 	version: z.string(),
 	reason: z.string(),
 });
 
-export type MalwareFinding = z.infer<typeof MalwareFinding>;
+export type MalwareFinding = z.infer<typeof MalwareFindingSchema>;
 
-const MalwareCheckSummary = z.object({
+export const MalwareCheckSummarySchema = z.object({
 	scanned: z.number(),
 	flagged: z.number(),
 });
 
-const MalwareCheckListMetadata = z.object({
+export const MalwareCheckListMetadataSchema = z.object({
 	fetchedAt: z.string(),
 	count: z.number(),
 });
 
-const MalwareCheckResult = z.object({
+export const MalwareCheckResultSchema = z.object({
 	action: z.enum(['allow', 'block']),
-	summary: MalwareCheckSummary,
-	findings: z.array(MalwareFinding),
-	list: MalwareCheckListMetadata.optional(),
+	summary: MalwareCheckSummarySchema,
+	findings: z.array(MalwareFindingSchema),
+	list: MalwareCheckListMetadataSchema.optional(),
 	error: z.string().optional(),
 });
 
-const MalwareCheckResponseSchema = APIResponseSchema(MalwareCheckResult);
+const MalwareCheckResponseSchema = APIResponseSchema(MalwareCheckResultSchema);
 
-export type MalwareCheckResult = z.infer<typeof MalwareCheckResult>;
+export type MalwareCheckResult = z.infer<typeof MalwareCheckResultSchema>;
 
 export async function projectDeploymentMalwareCheck(
 	client: APIClient,

package/src/api/project/update-region.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
 import { ProjectResponseError } from './util';
 
-const UpdateRegionRequestSchema = z.object({
+export const UpdateRegionRequestSchema = z.object({
 	cloudRegion: z.string().describe('the cloud region to update the project to'),
 });
 

package/src/api/region/create.ts

@@ -120,27 +120,27 @@ function isIPv4Address(s: string): boolean {
 	return true;
 }
 
-const ResourceSpec = z.object({
+export const ResourceSpec = z.object({
 	type: z.enum(['db', 's3']).describe('the resource type'),
 	name: z.string().optional().describe('optional custom name for db'),
 	description: z.string().optional().describe('optional description for db'),
 });
 
-const CreateResourcesRequest = z.object({
+export const CreateResourcesRequest = z.object({
 	resources: z.array(ResourceSpec).describe('list of resources to create'),
 });
 
-const CreatedResource = z.object({
+export const CreatedResource = z.object({
 	type: z.string().describe('the resource type'),
 	name: z.string().describe('the resource name'),
 	env: z.record(z.string(), z.string()).describe('environment variables for the resource'),
 });
 
-const CreateResourcesResponse = z.object({
+export const CreateResourcesResponse = z.object({
 	created: z.array(CreatedResource),
 });
 
-const CreateResourcesResponseSchema = APIResponseSchema(CreateResourcesResponse);
+export const CreateResourcesResponseSchema = APIResponseSchema(CreateResourcesResponse);
 
 export type CreateResourcesRequest = z.infer<typeof CreateResourcesRequest>;
 export type CreateResourcesResponse = z.infer<typeof CreateResourcesResponseSchema>;

package/src/api/region/delete.ts

@@ -2,26 +2,26 @@ import { z } from 'zod';
 import { APIResponseSchema, APIClient } from '../api';
 import { RegionResponseError } from './util';
 
-const DeleteResourceSpec = z.object({
+export const DeleteResourceSpec = z.object({
 	type: z.enum(['db', 's3']).describe('the resource type'),
 	name: z.string().describe('the resource name (bucket_name for S3, db_name for DB)'),
 });
 
-const DeleteResourcesRequest = z.object({
+export const DeleteResourcesRequest = z.object({
 	resources: z.array(DeleteResourceSpec).describe('list of resources to delete'),
 });
 
-const DeletedResource = z.object({
+export const DeletedResource = z.object({
 	type: z.string().describe('the resource type'),
 	name: z.string().describe('the resource name'),
 	env_keys: z.array(z.string()).describe('environment variable keys to remove'),
 });
 
-const DeleteResourcesResponse = z.object({
+export const DeleteResourcesResponse = z.object({
 	deleted: z.array(DeletedResource).describe('list of deleted resources'),
 });
 
-const DeleteResourcesResponseSchema = APIResponseSchema(DeleteResourcesResponse);
+export const DeleteResourcesResponseSchema = APIResponseSchema(DeleteResourcesResponse);
 
 export type DeleteResourcesRequest = z.infer<typeof DeleteResourcesRequest>;
 export type DeleteResourcesResponse = z.infer<typeof DeleteResourcesResponseSchema>;

package/src/api/region/list.ts

@@ -2,13 +2,13 @@ import { z } from 'zod';
 import { APIResponseSchema, APIClient } from '../api';
 import { RegionResponseError } from './util';
 
-const ListRegionsResponse = z.array(
+export const ListRegionsResponse = z.array(
 	z.object({
 		region: z.string().describe('the region identifier'),
 		description: z.string().describe('the human-readable description of the region'),
 	})
 );
-const ListRegionsResponseSchema = APIResponseSchema(ListRegionsResponse);
+export const ListRegionsResponseSchema = APIResponseSchema(ListRegionsResponse);
 
 export type ListRegionsResponse = z.infer<typeof ListRegionsResponseSchema>;
 export type RegionList = z.infer<typeof ListRegionsResponse>;

package/src/api/region/resources.ts

@@ -2,7 +2,7 @@ import { z } from 'zod';
 import { APIResponseSchema, APIClient } from '../api';
 import { RegionResponseError } from './util';
 
-const ResourceListResponse = z.object({
+export const ResourceListResponse = z.object({
 	s3: z.array(
 		z.object({
 			bucket_name: z.string().describe('the S3 bucket name'),
@@ -39,7 +39,7 @@ const ResourceListResponse = z.object({
 		})
 		.optional(),
 });
-const ResourceListResponseSchema = APIResponseSchema(ResourceListResponse);
+export const ResourceListResponseSchema = APIResponseSchema(ResourceListResponse);
 
 export type ResourceListResponse = z.infer<typeof ResourceListResponseSchema>;
 export type ResourceList = z.infer<typeof ResourceListResponse>;

package/src/api/sandbox/cli-list.ts

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+import { APIClient, APIResponseSchema } from '../api';
+import { SandboxResponseError } from './util';
+
+const SandboxInfoSchema = z.object({
+	id: z.string().describe('the sandbox id'),
+	name: z.string().nullable().describe('the sandbox name'),
+	description: z.string().nullable().describe('the sandbox description'),
+	status: z.string().describe('sandbox status'),
+	region: z.string().nullable().describe('cloud region'),
+	createdAt: z.string().nullable().describe('ISO 8601 creation timestamp'),
+	orgId: z.string().describe('the organization id'),
+	orgName: z.string().nullable().describe('the organization name'),
+	projectId: z.string().nullable().describe('the project id'),
+});
+
+const SandboxListDataSchema = z.object({
+	sandboxes: z.array(SandboxInfoSchema).describe('list of sandboxes'),
+	total: z.number().describe('total count of matching sandboxes'),
+});
+
+const SandboxListResponseSchema = APIResponseSchema(SandboxListDataSchema);
+
+export type CLISandboxListResponse = z.infer<typeof SandboxListResponseSchema>;
+export type CLISandboxListData = z.infer<typeof SandboxListDataSchema>;
+export type CLISandboxInfo = z.infer<typeof SandboxInfoSchema>;
+
+export interface CLISandboxListOptions {
+	/**
+	 * Filter by specific project ID
+	 */
+	projectId?: string;
+	/**
+	 * Filter by specific organization ID
+	 */
+	orgId?: string;
+	/**
+	 * Filter by sandbox status
+	 */
+	status?: 'creating' | 'idle' | 'running' | 'terminated' | 'failed';
+	/**
+	 * Maximum number of sandboxes to return (default: 50, max: 100)
+	 */
+	limit?: number;
+	/**
+	 * Number of sandboxes to skip for pagination
+	 */
+	offset?: number;
+}
+
+/**
+ * List sandboxes with optional filtering using the CLI API endpoint.
+ *
+ * This endpoint searches across all organizations the user is a member of,
+ * unlike the Catalyst API which requires an orgId.
+ *
+ * @param client - The API client
+ * @param options - Filtering and pagination options
+ * @returns A promise that resolves to the list of sandboxes
+ *
+ * @example
+ * // List all sandboxes across all orgs
+ * const result = await cliSandboxList(client);
+ * console.log(`Found ${result.total} sandboxes`);
+ *
+ * @example
+ * // List running sandboxes
+ * const result = await cliSandboxList(client, { status: 'running' });
+ *
+ * @example
+ * // List sandboxes for a specific project
+ * const result = await cliSandboxList(client, { projectId: 'proj_123' });
+ */
+export async function cliSandboxList(
+	client: APIClient,
+	options: CLISandboxListOptions = {}
+): Promise<CLISandboxListData> {
+	const { projectId, orgId, status, limit, offset } = options;
+	const params = new URLSearchParams();
+
+	if (projectId) params.set('projectId', projectId);
+	if (orgId) params.set('orgId', orgId);
+	if (status) params.set('status', status);
+	if (limit !== undefined) params.set('limit', limit.toString());
+	if (offset !== undefined) params.set('offset', offset.toString());
+
+	const queryString = params.toString();
+	const resp = await client.request<CLISandboxListResponse>(
+		'GET',
+		`/cli/sandbox${queryString ? `?${queryString}` : ''}`,
+		SandboxListResponseSchema
+	);
+
+	if (resp.success) {
+		return resp.data;
+	}
+
+	throw new SandboxResponseError({ message: resp.message });
+}

package/src/api/sandbox/files.ts

@@ -8,19 +8,19 @@ export const FileToWriteSchema = z.object({
 	content: z.string().describe('Base64-encoded file content'),
 });
 
-const WriteFilesRequestSchema = z
+export const WriteFilesRequestSchema = z
 	.object({
 		files: z.array(FileToWriteSchema).describe('Array of files to write'),
 	})
 	.describe('Request body for writing files to a sandbox');
 
-const WriteFilesDataSchema = z
+export const WriteFilesDataSchema = z
 	.object({
 		filesWritten: z.number().describe('Number of files successfully written'),
 	})
 	.describe('Response data from writing files');
 
-const WriteFilesResponseSchema = z.discriminatedUnion('success', [
+export const WriteFilesResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),
@@ -140,14 +140,14 @@ export async function sandboxReadFile(
 	return response.body;
 }
 
-const MkDirRequestSchema = z
+export const MkDirRequestSchema = z
 	.object({
 		path: z.string().describe('Path to the directory to create'),
 		recursive: z.boolean().optional().describe('Create parent directories if needed'),
 	})
 	.describe('Request body for creating a directory');
 
-const MkDirResponseSchema = z.discriminatedUnion('success', [
+export const MkDirResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),
@@ -200,14 +200,14 @@ export async function sandboxMkDir(client: APIClient, params: MkDirParams): Prom
 	}
 }
 
-const RmDirRequestSchema = z
+export const RmDirRequestSchema = z
 	.object({
 		path: z.string().describe('Path to the directory to remove'),
 		recursive: z.boolean().optional().describe('Remove directory and all contents'),
 	})
 	.describe('Request body for removing a directory');
 
-const RmDirResponseSchema = z.discriminatedUnion('success', [
+export const RmDirResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),
@@ -260,13 +260,13 @@ export async function sandboxRmDir(client: APIClient, params: RmDirParams): Prom
 	}
 }
 
-const RmFileRequestSchema = z
+export const RmFileRequestSchema = z
 	.object({
 		path: z.string().describe('Path to the file to remove'),
 	})
 	.describe('Request body for removing a file');
 
-const RmFileResponseSchema = z.discriminatedUnion('success', [
+export const RmFileResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),
@@ -317,7 +317,7 @@ export async function sandboxRmFile(client: APIClient, params: RmFileParams): Pr
 	}
 }
 
-const FileInfoSchema = z.object({
+export const FileInfoSchema = z.object({
 	path: z.string().describe('File path relative to the listed directory'),
 	size: z.number().describe('File size in bytes'),
 	isDir: z.boolean().describe('Whether the entry is a directory'),
@@ -325,11 +325,11 @@ const FileInfoSchema = z.object({
 	modTime: z.string().describe('Modification time in RFC3339 format'),
 });
 
-const ListFilesDataSchema = z.object({
+export const ListFilesDataSchema = z.object({
 	files: z.array(FileInfoSchema).describe('Array of file information'),
 });
 
-const ListFilesResponseSchema = z.discriminatedUnion('success', [
+export const ListFilesResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),
@@ -467,7 +467,7 @@ export interface UploadArchiveParams {
 	signal?: AbortSignal;
 }
 
-const UploadArchiveResponseSchema = z.discriminatedUnion('success', [
+export const UploadArchiveResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),
@@ -523,17 +523,17 @@ export async function sandboxUploadArchive(
 	}
 }
 
-const SetEnvRequestSchema = z.object({
+export const SetEnvRequestSchema = z.object({
 	env: z
 		.record(z.string(), z.string().nullable())
 		.describe('Environment variables to set (null to delete)'),
 });
 
-const SetEnvDataSchema = z.object({
+export const SetEnvDataSchema = z.object({
 	env: z.record(z.string(), z.string()).describe('Current environment variables after update'),
 });
 
-const SetEnvResponseSchema = z.discriminatedUnion('success', [
+export const SetEnvResponseSchema = z.discriminatedUnion('success', [
 	z.object({
 		success: z.literal<false>(false),
 		message: z.string().describe('the error message'),

package/src/api/sandbox/index.ts

@@ -4,8 +4,12 @@ export { sandboxExecute } from './execute';
 export type { SandboxExecuteParams } from './execute';
 export { sandboxGet } from './get';
 export type { SandboxGetParams } from './get';
+export { sandboxResolve, SandboxResolveError } from './resolve';
+export type { ResolvedSandboxInfo } from './resolve';
 export { sandboxList } from './list';
 export type { SandboxListParams } from './list';
+export { cliSandboxList } from './cli-list';
+export type { CLISandboxListOptions, CLISandboxListData, CLISandboxInfo } from './cli-list';
 export { runtimeList } from './runtime';
 export type { RuntimeListParams } from './runtime';
 export { sandboxDestroy } from './destroy';
@@ -48,6 +52,23 @@ export {
 	sandboxDownloadArchive,
 	sandboxUploadArchive,
 	sandboxSetEnv,
+	FileToWriteSchema,
+	WriteFilesRequestSchema,
+	WriteFilesDataSchema,
+	WriteFilesResponseSchema,
+	MkDirRequestSchema,
+	MkDirResponseSchema,
+	RmDirRequestSchema,
+	RmDirResponseSchema,
+	RmFileRequestSchema,
+	RmFileResponseSchema,
+	FileInfoSchema,
+	ListFilesDataSchema,
+	ListFilesResponseSchema,
+	UploadArchiveResponseSchema,
+	SetEnvRequestSchema,
+	SetEnvDataSchema,
+	SetEnvResponseSchema,
 } from './files';
 export type {
 	WriteFilesParams,

package/src/api/sandbox/resolve.ts

@@ -0,0 +1,98 @@
+import { z } from 'zod';
+import { StructuredError } from '@agentuity/core';
+import { APIResponseSchemaOptionalData, type APIClient } from '../api';
+
+/**
+ * Data schema for sandbox resolve endpoint
+ */
+const SandboxResolveDataSchema = z.object({
+	id: z.string(),
+	name: z.string().nullable(),
+	region: z.string(),
+	status: z.string(),
+	orgId: z.string(),
+	projectId: z.string().nullable(),
+});
+
+/**
+ * Response schema for sandbox resolve endpoint using standardized discriminated union
+ */
+const SandboxResolveResponseSchema = APIResponseSchemaOptionalData(SandboxResolveDataSchema);
+
+/**
+ * Resolved sandbox info returned from the CLI API
+ */
+export interface ResolvedSandboxInfo {
+	id: string;
+	name: string | null;
+	region: string;
+	status: string;
+	orgId: string;
+	projectId: string | null;
+}
+
+/**
+ * Error thrown when sandbox resolution fails.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   await sandboxResolve(client, 'sbx_123');
+ * } catch (error) {
+ *   if (error._tag === 'SandboxResolveError') {
+ *     console.error(`Sandbox not found: ${error.sandboxId}`);
+ *   }
+ * }
+ * ```
+ */
+export const SandboxResolveError = StructuredError('SandboxResolveError')<{
+	sandboxId?: string;
+	statusCode?: number;
+}>();
+
+/**
+ * Resolve a sandbox by ID across all organizations the user has access to.
+ * Uses the CLI API endpoint which searches across all user's orgs.
+ *
+ * @param client - API client configured for CLI endpoints
+ * @param sandboxId - The sandbox ID to resolve
+ * @returns Resolved sandbox info including region and orgId
+ * @throws {SandboxResolveError} If sandbox not found or request fails
+ */
+export async function sandboxResolve(
+	client: APIClient,
+	sandboxId: string
+): Promise<ResolvedSandboxInfo> {
+	const response = await client.get<z.infer<typeof SandboxResolveResponseSchema>>(
+		`/cli/sandbox/${sandboxId}`,
+		SandboxResolveResponseSchema
+	);
+
+	if (!response.success) {
+		// Extract status code from error code if present (e.g., "NOT_FOUND" -> 404)
+		// Fall back to 404 if no code is provided
+		const statusCode = response.code === 'NOT_FOUND' ? 404 : response.code ? 400 : 404;
+		throw new SandboxResolveError({
+			message: response.message || 'Sandbox not found',
+			sandboxId,
+			statusCode,
+		});
+	}
+
+	if (!response.data) {
+		throw new SandboxResolveError({
+			message: 'Sandbox not found',
+			sandboxId,
+			statusCode: 404,
+		});
+	}
+
+	return {
+		id: response.data.id,
+		name: response.data.name,
+		region: response.data.region,
+		status: response.data.status,
+		orgId: response.data.orgId,
+		projectId: response.data.projectId,
+	};
+}

package/src/api/sandbox/run.ts

@@ -1,7 +1,7 @@
 import type { Logger } from '@agentuity/core';
 import type { Readable, Writable } from 'node:stream';
 import { PassThrough } from 'node:stream';
-import { APIClient } from '../api';
+import { APIClient, PaymentRequiredError } from '../api';
 import { sandboxCreate } from './create';
 import { sandboxDestroy } from './destroy';
 import { sandboxGet } from './get';
@@ -286,6 +286,11 @@ async function createStdinStream(
 	});
 
 	if (!response.ok) {
+		if (response.status === 402) {
+			throw new PaymentRequiredError({
+				url: url,
+			});
+		}
 		throw new Error(`Failed to create stdin stream: ${response.status} ${response.statusText}`);
 	}
 

package/src/api/session/get.ts

@@ -1,13 +1,13 @@
 import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
-import { SessionSchema } from './list';
+import { SessionSchema, type Session } from './list';
 import { SessionResponseError } from './util';
 
-const _SessionGetRequestSchema = z.object({
+export const _SessionGetRequestSchema = z.object({
 	id: z.string().describe('the session id'),
 });
 
-const EvalRunSchema = z.object({
+export const SessionEvalRunSchema = z.object({
 	id: z.string().describe('eval run id'),
 	created_at: z.string().describe('creation timestamp'),
 	eval_id: z.string().describe('evaluation id'),
@@ -26,7 +26,7 @@ export interface SpanNode {
 	error?: string;
 }
 
-const SpanNodeSchema: z.ZodType<SpanNode> = z.lazy(() =>
+export const SpanNodeSchema: z.ZodType<SpanNode> = z.lazy(() =>
 	z.object({
 		id: z.string().describe('span ID'),
 		duration: z.number().describe('duration in milliseconds'),
@@ -37,7 +37,7 @@ const SpanNodeSchema: z.ZodType<SpanNode> = z.lazy(() =>
 	})
 );
 
-const RouteInfoSchema = z
+export const RouteInfoSchema = z
 	.object({
 		id: z.string().describe('route id'),
 		method: z.string().describe('HTTP method'),
@@ -45,25 +45,23 @@ const RouteInfoSchema = z
 	})
 	.nullable();
 
-const AgentInfoSchema = z.object({
+export const AgentInfoSchema = z.object({
 	name: z.string().describe('agent name'),
 	identifier: z.string().describe('agent identifier'),
 });
 
-const EnrichedSessionDataSchema = z.object({
+export const EnrichedSessionDataSchema = z.object({
 	session: SessionSchema,
 	agents: z.array(AgentInfoSchema).describe('resolved agents'),
-	eval_runs: z.array(EvalRunSchema).describe('eval runs for this session'),
+	eval_runs: z.array(SessionEvalRunSchema).describe('eval runs for this session'),
 	route: RouteInfoSchema.describe('route information'),
 });
 
-const SessionGetResponseSchema = APIResponseSchema(EnrichedSessionDataSchema);
+export const SessionGetResponseSchema = APIResponseSchema(EnrichedSessionDataSchema);
 
 type SessionGetRequest = z.infer<typeof _SessionGetRequestSchema>;
 type SessionGetResponse = z.infer<typeof SessionGetResponseSchema>;
 
-export type Session = z.infer<typeof SessionSchema>;
-
 /**
  * Get a single session by id
  *
@@ -71,13 +69,15 @@ export type Session = z.infer<typeof SessionSchema>;
  * @param request
  * @returns
  */
-export type EvalRun = z.infer<typeof EvalRunSchema>;
+export type SessionEvalRun = z.infer<typeof SessionEvalRunSchema>;
+/** @deprecated Use SessionEvalRun instead */
+export type EvalRun = SessionEvalRun;
 export type RouteInfo = z.infer<typeof RouteInfoSchema>;
 export type AgentInfo = z.infer<typeof AgentInfoSchema>;
 export type EnrichedSession = {
 	session: Session;
 	agents: AgentInfo[];
-	evalRuns: EvalRun[];
+	evalRuns: SessionEvalRun[];
 	timeline: SpanNode | null;
 	route: RouteInfo;
 };

package/src/api/session/index.ts

@@ -1,6 +1,3 @@
-export { sessionGet } from './get';
-export type { Session, EnrichedSession, EvalRun, SpanNode, RouteInfo, AgentInfo } from './get';
-export { sessionList, SessionSchema } from './list';
-export type { SessionList, SessionListResponse, SessionListOptions } from './list';
-export { sessionLogs } from './logs';
-export type { SessionLog } from './logs';
+export * from './get';
+export * from './list';
+export * from './logs';

package/src/api/session/list.ts

@@ -42,9 +42,9 @@ const SessionSchema = z.object({
 
 export { SessionSchema };
 
-const SessionListResponse = z.array(SessionSchema);
+export const SessionListResponse = z.array(SessionSchema);
 
-const SessionListResponseSchema = APIResponseSchema(SessionListResponse);
+export const SessionListResponseSchema = APIResponseSchema(SessionListResponse);
 
 export type SessionListResponse = z.infer<typeof SessionListResponseSchema>;
 export type SessionList = z.infer<typeof SessionListResponse>;

package/src/api/session/logs.ts

@@ -2,19 +2,19 @@ import { z } from 'zod';
 import { APIClient, APIResponseSchema } from '../api';
 import { SessionResponseError } from './util';
 
-const _SessionLogsRequestSchema = z.object({
+export const _SessionLogsRequestSchema = z.object({
 	id: z.string().describe('the session id'),
 });
 
-const LogSchema = z.object({
+export const LogSchema = z.object({
 	body: z.string().describe('the log body'),
 	severity: z.string().describe('the log severity'),
 	timestamp: z.string().describe('the log timestamp'),
 });
 
-const SessionLogsResponse = z.array(LogSchema);
+export const SessionLogsResponse = z.array(LogSchema);
 
-const SessionLogsResponseSchema = APIResponseSchema(SessionLogsResponse);
+export const SessionLogsResponseSchema = APIResponseSchema(SessionLogsResponse);
 
 type SessionLogsRequest = z.infer<typeof _SessionLogsRequestSchema>;
 type SessionLogsResponse = z.infer<typeof SessionLogsResponseSchema>;