@agentuity/core 1.0.33 → 1.0.35

package/src/index.ts

@@ -1,6 +1,7 @@
 // env-example.ts exports
 export type { EnvField, ResourceType } from './env-example.ts';
 export { detectResourceFromKey, parseEnvExample } from './env-example.ts';
+
 // error.ts exports
 export { isStructuredError, RichError, StructuredError } from './error.ts';
 
@@ -9,234 +10,9 @@ export { safeStringify } from './json.ts';
 
 // logger.ts exports
 export type { Logger, LogLevel } from './logger.ts';
-export { buildUrl, fromResponse, toPayload, toServiceException } from './services/_util.ts';
+
 // services exports
-export type {
-	Body,
-	FetchAdapter,
-	FetchErrorResponse,
-	FetchRequest,
-	FetchResponse,
-	FetchSuccessResponse,
-	HttpMethod,
-} from './services/adapter.ts';
-export {
-	type EmailActivityDataPoint,
-	type EmailActivityParams,
-	type EmailActivityResult,
-	type EmailAddress,
-	type EmailAttachment,
-	type EmailConnectionConfig,
-	type EmailDestination,
-	type EmailInbound,
-	type EmailOutbound,
-	type EmailProtocolConfig,
-	type EmailSendParams,
-	type EmailService,
-	EmailStorageService,
-	type EmailStoredAttachment,
-} from './services/email.ts';
-export {
-	type EvalRunCompleteEvent,
-	EvalRunCompleteEventDelayedSchema,
-	EvalRunCompleteEventSchema,
-	type EvalRunEventProvider,
-	type EvalRunStartEvent,
-	EvalRunStartEventDelayedSchema,
-	EvalRunStartEventSchema,
-} from './services/evalrun.ts';
-export { ServiceException } from './services/exception.ts';
-export {
-	type CreateNamespaceParams,
-	type DataResult,
-	type DataResultFound,
-	type DataResultNotFound,
-	type GetAllStatsParams,
-	type KeyValueItemWithMetadata,
-	type KeyValueStats,
-	type KeyValueStatsPaginated,
-	type KeyValueStorage,
-	KeyValueStorageService,
-	type KeyValueStorageSetParams,
-	KV_DEFAULT_TTL_SECONDS,
-	KV_MAX_TTL_SECONDS,
-	KV_MIN_TTL_SECONDS,
-	type KVSortField,
-} from './services/keyvalue.ts';
-export type {
-	ListParams,
-	PaginatedList,
-	PaginationParams,
-	SortDirection,
-	SortParams,
-} from './services/pagination.ts';
-export {
-	type QueueCreateParams,
-	type QueueCreateResult,
-	QueueNotFoundError,
-	QueuePublishError,
-	type QueuePublishParams,
-	type QueuePublishResult,
-	type QueueService,
-	QueueStorageService,
-	QueueValidationError,
-} from './services/queue.ts';
-export {
-	type ExecuteOptions,
-	type Execution,
-	type ExecutionStatus,
-	type FileToWrite,
-	type ListRuntimesParams,
-	type ListRuntimesResponse,
-	type ListSandboxesParams,
-	type ListSandboxesResponse,
-	type RuntimeSortField,
-	type Sandbox,
-	type SandboxAgentInfo,
-	type SandboxCommand,
-	type SandboxCreateOptions,
-	SandboxError,
-	type SandboxInfo,
-	type SandboxNetworkConfig,
-	type SandboxOrgInfo,
-	type SandboxProjectInfo,
-	type SandboxResources,
-	type SandboxRunOptions,
-	type SandboxRunResult,
-	type SandboxRuntime,
-	type SandboxRuntimeInfo,
-	type SandboxRuntimeRequirements,
-	type SandboxService,
-	type SandboxSnapshotInfo,
-	type SandboxSnapshotInfoPrivate,
-	type SandboxSnapshotInfoPublic,
-	type SandboxSnapshotOrgInfo,
-	type SandboxSnapshotUserInfo,
-	type SandboxSortField,
-	type SandboxStatus,
-	type SandboxStreamConfig,
-	type SandboxTimeoutConfig,
-	type SandboxUserInfo,
-	type SnapshotCreateOptions,
-	// Snapshot types
-	type SnapshotFileInfo,
-	type SnapshotInfo,
-	type SnapshotListParams,
-	type SnapshotListResponse,
-	type SnapshotOrgInfo,
-	type SnapshotService,
-	type SnapshotSortField,
-	type SnapshotUserInfo,
-	type StreamReader,
-} from './services/sandbox.ts';
-export {
-	type CreateScheduleDestinationParams,
-	type CreateScheduleParams,
-	type Schedule,
-	type ScheduleCreateResult,
-	type ScheduleDelivery,
-	type ScheduleDeliveryListResult,
-	type ScheduleDestination,
-	type ScheduleGetResult,
-	type ScheduleListResult,
-	ScheduleService,
-	type UpdateScheduleParams,
-} from './services/schedule.ts';
-export {
-	type SessionCompleteEvent,
-	SessionCompleteEventDelayedSchema,
-	SessionCompleteEventSchema,
-	type SessionEventProvider,
-	type SessionStartEvent,
-	SessionStartEventDelayedSchema,
-	SessionStartEventSchema,
-} from './services/session.ts';
-export {
-	type CreateStreamProps,
-	type ListStreamsParams,
-	type ListStreamsResponse,
-	STREAM_DEFAULT_TTL_SECONDS,
-	STREAM_MAX_TTL_SECONDS,
-	STREAM_MIN_TTL_SECONDS,
-	type Stream,
-	type StreamInfo,
-	type StreamSortField,
-	type StreamStorage,
-	StreamStorageService,
-} from './services/stream.ts';
-export {
-	type Attachment,
-	type BatchDeletedTask,
-	type BatchDeleteTasksParams,
-	type BatchDeleteTasksResult,
-	type Comment,
-	type CreateAttachmentParams,
-	type CreateTaskParams,
-	type EntityRef,
-	type ListAttachmentsResult,
-	type ListCommentsResult,
-	type ListProjectsResult,
-	type ListTagsResult,
-	type ListTasksParams,
-	type ListTasksResult,
-	type ListUsersResult,
-	type PresignDownloadResponse,
-	type PresignUploadResponse,
-	type Tag,
-	type Task,
-	type TaskActivityDataPoint,
-	type TaskActivityParams,
-	type TaskActivityResult,
-	type TaskChangelogEntry,
-	type TaskChangelogResult,
-	type TaskPriority,
-	type TaskStatus,
-	type TaskStorage,
-	TaskStorageService,
-	type TaskType,
-	type UpdateTaskParams,
-	type UserEntityRef,
-	type UserType,
-} from './services/task.ts';
-export {
-	VECTOR_DEFAULT_TTL_SECONDS,
-	VECTOR_MAX_TTL_SECONDS,
-	VECTOR_MIN_TTL_SECONDS,
-	type VectorGetAllStatsParams,
-	type VectorItemStats,
-	type VectorNamespaceStats,
-	type VectorNamespaceStatsWithSamples,
-	type VectorResult,
-	type VectorResultFound,
-	type VectorResultNotFound,
-	type VectorSearchParams,
-	type VectorSearchResult,
-	type VectorSearchResultWithDocument,
-	type VectorSortField,
-	type VectorStatsPaginated,
-	type VectorStorage,
-	VectorStorageService,
-	type VectorUpsertBase,
-	type VectorUpsertEmbeddings,
-	type VectorUpsertParams,
-	type VectorUpsertResult,
-	type VectorUpsertText,
-} from './services/vector.ts';
-export {
-	type CreateWebhookDestinationParams,
-	type CreateWebhookParams,
-	type UpdateWebhookParams,
-	type Webhook,
-	type WebhookCreateResult,
-	type WebhookDelivery,
-	type WebhookDeliveryListResult,
-	type WebhookDestination,
-	type WebhookGetResult,
-	type WebhookListResult,
-	type WebhookReceipt,
-	type WebhookReceiptListResult,
-	WebhookService,
-} from './services/webhook.ts';
+export * from './services/index.ts';
 
 // standard_schema.ts exports
 export type { StandardSchemaV1 } from './standard_schema.ts';
@@ -246,24 +22,10 @@ export { toCamelCase, toPascalCase } from './string.ts';
 
 // typehelper.ts exports
 export type { InferInput, InferOutput } from './typehelper.ts';
+
 // webrtc.ts exports
-export type {
-	ConnectionQualitySummary,
-	DataChannelConfig,
-	DataChannelMessage,
-	DataChannelState,
-	ICECandidate,
-	RecordingHandle,
-	RecordingOptions,
-	RecordingState,
-	SDPDescription,
-	SignalMessage,
-	SignalMsg,
-	TrackSource,
-	WebRTCConnectionState,
-	WebRTCDisconnectReason,
-	WebRTCSignalingCallbacks,
-} from './webrtc.ts';
+export type * from './webrtc.ts';
+
 // workbench exports
 export {
 	decodeWorkbenchConfig,
@@ -275,6 +37,3 @@ export {
 } from './workbench-config.ts';
 
 // Client code moved to @agentuity/frontend for better bundler compatibility
-
-// API client and modules (moved from @agentuity/server)
-export * from './api/index.ts';

package/src/services/adapter.ts

@@ -1,34 +1,79 @@
-export interface FetchSuccessResponse<TData> {
+import { z } from 'zod';
+
+export const FetchSuccessResponseSchema = <TData extends z.ZodTypeAny>(dataSchema: TData) =>
+	z.object({
+		ok: z.literal(true).describe('Indicates the fetch request was successful.'),
+		data: dataSchema.describe('The parsed response data.'),
+		response: z.instanceof(Response).describe('The raw Response object.'),
+	});
+
+export type FetchSuccessResponse<TData> = {
 	ok: true;
 	data: TData;
 	response: Response;
-}
+};
 
-export interface FetchErrorResponse {
-	ok: false;
-	data: never;
-	response: Response;
-}
+export const FetchErrorResponseSchema = z
+	.object({
+		ok: z.literal(false).describe('Indicates the fetch request failed.'),
+		data: z.never().describe('No data is available for failed requests.'),
+		response: z.instanceof(Response).describe('The raw Response object.'),
+	})
+	.describe('Error response from a fetch request.');
+
+export type FetchErrorResponse = z.infer<typeof FetchErrorResponseSchema>;
+
+export const FetchResponseSchema = <T extends z.ZodTypeAny>(dataSchema: T) =>
+	z.union([FetchErrorResponseSchema, FetchSuccessResponseSchema(dataSchema)]);
 
 export type FetchResponse<T> = FetchErrorResponse | FetchSuccessResponse<T>;
 
-export type Body = string | Uint8Array | ArrayBuffer | ReadableStream;
-
-export type HttpMethod = 'GET' | 'PUT' | 'POST' | 'DELETE' | 'HEAD' | 'OPTIONS' | 'PATCH';
-
-export interface FetchRequest {
-	method: HttpMethod;
-	body?: Body;
-	signal?: AbortSignal;
-	contentType?: string;
-	headers?: Record<string, string>;
-	telemetry?: {
-		name: string;
-		attributes?: Record<string, string>;
-	};
-	binary?: true;
-	duplex?: 'half';
-}
+export const BodySchema = z
+	.union([
+		z.string(),
+		z.custom<Uint8Array>((value) => value instanceof Uint8Array),
+		z.instanceof(ArrayBuffer),
+		z.custom<ReadableStream>((value) => value instanceof ReadableStream),
+	])
+	.describe('Request body content (string, Uint8Array, ArrayBuffer, or ReadableStream).');
+
+export type Body = z.infer<typeof BodySchema>;
+
+export const HttpMethodSchema = z
+	.enum(['GET', 'PUT', 'POST', 'DELETE', 'HEAD', 'OPTIONS', 'PATCH'])
+	.describe('HTTP request method.');
+
+export type HttpMethod = z.infer<typeof HttpMethodSchema>;
+
+export const FetchRequestSchema = z
+	.object({
+		method: HttpMethodSchema.describe('HTTP method for the request.'),
+		body: BodySchema.optional().describe('Optional request body.'),
+		signal: z
+			.instanceof(AbortSignal)
+			.optional()
+			.describe('Optional AbortSignal for request cancellation.'),
+		contentType: z.string().optional().describe('Content-Type header value.'),
+		headers: z.record(z.string(), z.string()).optional().describe('Additional HTTP headers.'),
+		telemetry: z
+			.object({
+				name: z.string().describe('Telemetry span name.'),
+				attributes: z
+					.record(z.string(), z.string())
+					.optional()
+					.describe('Additional telemetry attributes.'),
+			})
+			.optional()
+			.describe('Optional OpenTelemetry configuration for the request.'),
+		binary: z.literal(true).optional().describe('If true, treat the response as binary data.'),
+		duplex: z
+			.literal('half')
+			.optional()
+			.describe('Enable half-duplex streaming for the request.'),
+	})
+	.describe('Configuration for a fetch request.');
+
+export type FetchRequest = z.infer<typeof FetchRequestSchema>;
 
 export interface FetchAdapter {
 	invoke<T>(url: string, options: FetchRequest): Promise<FetchResponse<T>>;