@agent-vm/agent-portal-sdk 0.0.113 → 0.0.115

package/dist/contracts-RgGW0RX2.js

@@ -0,0 +1,611 @@
+import { n as withPortableSuperRefinement } from "./portable-refinement-authoring-ZSmR-amG.js";
+import { z } from "zod";
+//#region src/contracts/contract-foundations.ts
+const PORTABLE_MAXIMUM_SAFE_INTEGER = Number.MAX_SAFE_INTEGER;
+const SANDBOX_MAXIMUM_ENVIRONMENT_VARIABLES = 100;
+const SANDBOX_MAXIMUM_IDENTIFIER_CHARACTERS = 256;
+const SANDBOX_MAXIMUM_PATH_CHARACTERS = 1024;
+const SANDBOX_MAXIMUM_TEXT_CHARACTERS = 64 * 1024;
+const SANDBOX_MAXIMUM_BINARY_BYTES = 16 * 1024 * 1024;
+const SANDBOX_MAXIMUM_LIST_ITEMS = 1e3;
+const SANDBOX_MAXIMUM_OPERATION_MILLISECONDS = 3600 * 1e3;
+const BoundedOpaqueIdentifierSchema = z.string().min(1).max(256);
+const PositiveSafeIntegerSchema = z.number().int().positive().max(PORTABLE_MAXIMUM_SAFE_INTEGER);
+const NonnegativeSafeIntegerSchema = z.number().int().nonnegative().max(PORTABLE_MAXIMUM_SAFE_INTEGER);
+const BoundedOperationMillisecondsSchema = PositiveSafeIntegerSchema.max(SANDBOX_MAXIMUM_OPERATION_MILLISECONDS);
+const BoundedByteCountSchema = PositiveSafeIntegerSchema.max(SANDBOX_MAXIMUM_BINARY_BYTES);
+const BoundedTextSchema = z.string().max(SANDBOX_MAXIMUM_TEXT_CHARACTERS);
+const SandboxShellCommandSchema = z.string().min(1).max(SANDBOX_MAXIMUM_TEXT_CHARACTERS).regex(/^[^\0]+$/u);
+const SandboxGuestAbsolutePathSchema = z.string().min(1).max(SANDBOX_MAXIMUM_PATH_CHARACTERS).startsWith("/").regex(/^[^\0]+$/u);
+const SandboxGuestPathSchema = z.string().min(1).max(SANDBOX_MAXIMUM_PATH_CHARACTERS).regex(/^[^\0]+$/u);
+const SandboxEnvironmentVariableNameSchema = z.string().min(1).max(256).regex(/^[A-Za-z_][A-Za-z0-9_]*$/u);
+const SandboxEnvironmentVariableValueSchema = z.string().max(SANDBOX_MAXIMUM_TEXT_CHARACTERS).regex(/^[^\0]*$/u);
+const CanonicalBase64Schema = z.string().max(Math.ceil(SANDBOX_MAXIMUM_BINARY_BYTES / 3) * 4).regex(/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/u);
+const Sha256DigestSchema = z.string().regex(/^sha256:[0-9a-f]{64}$/u);
+const SandboxWorkRelativePathSchema = withPortableSuperRefinement({
+	refinement: (requestedPath, context) => {
+		if (requestedPath.length === 0 || requestedPath.includes("\0") || requestedPath.startsWith("/") || requestedPath.endsWith("/") || requestedPath.split("/").some((segment) => segment === "" || segment === "." || segment === "..")) context.addIssue({
+			code: "custom",
+			message: "Sandbox path must remain relative to the server-selected work root."
+		});
+	},
+	refinementIdentity: "sandbox.path.work-relative",
+	schema: z.string().max(SANDBOX_MAXIMUM_PATH_CHARACTERS)
+});
+const SandboxHandleKindSchema = z.enum([
+	"environment",
+	"process",
+	"stream",
+	"terminal"
+]);
+const SandboxStreamChannelSchema = z.enum([
+	"stdin",
+	"stdout",
+	"stderr",
+	"pty"
+]);
+const SandboxBoundHandleSchema = z.object({
+	handleId: BoundedOpaqueIdentifierSchema,
+	kind: SandboxHandleKindSchema,
+	owningGeneration: BoundedOpaqueIdentifierSchema
+}).strict();
+function createSandboxBoundHandleSchema(kind) {
+	return SandboxBoundHandleSchema.extend({ kind: z.literal(kind) }).strict();
+}
+const SandboxEnvironmentHandleSchema = createSandboxBoundHandleSchema("environment");
+const SandboxProcessHandleSchema = createSandboxBoundHandleSchema("process");
+const SandboxStreamHandleSchema = createSandboxBoundHandleSchema("stream").extend({ channel: SandboxStreamChannelSchema }).strict();
+const SandboxTerminalHandleSchema = createSandboxBoundHandleSchema("terminal");
+const SandboxEnvironmentVariableSchema = z.object({
+	name: SandboxEnvironmentVariableNameSchema,
+	value: SandboxEnvironmentVariableValueSchema
+}).strict().readonly();
+const SandboxDirectShellStartRequestSchema = withPortableSuperRefinement({
+	refinement: (request, context) => {
+		const environmentVariableNames = request.environmentVariables?.map((environmentVariable) => environmentVariable.name) ?? [];
+		if (new Set(environmentVariableNames).size !== environmentVariableNames.length) context.addIssue({
+			code: "custom",
+			message: "Direct Sandbox environment contains a duplicate variable name."
+		});
+	},
+	refinementIdentity: "sandbox.environment-variable.unique-names",
+	schema: z.object({
+		command: SandboxShellCommandSchema,
+		cwd: SandboxGuestAbsolutePathSchema.optional(),
+		environment: SandboxEnvironmentHandleSchema,
+		environmentVariables: z.array(SandboxEnvironmentVariableSchema).max(100).readonly().optional()
+	}).strict()
+});
+function decodedCanonicalBase64ByteLength(contentBase64) {
+	if (contentBase64.length === 0) return 0;
+	const paddingCharacters = contentBase64.endsWith("==") ? 2 : contentBase64.endsWith("=") ? 1 : 0;
+	return contentBase64.length / 4 * 3 - paddingCharacters;
+}
+const SandboxBinaryChunkSchema = withPortableSuperRefinement({
+	refinement: (chunk, context) => {
+		if (chunk.byteLength !== decodedCanonicalBase64ByteLength(chunk.contentBase64)) context.addIssue({
+			code: "custom",
+			message: "Binary chunk byte length does not match decoded canonical base64 content.",
+			path: ["byteLength"]
+		});
+	},
+	refinementIdentity: "sandbox.binary-chunk.byte-length",
+	schema: z.object({
+		byteLength: NonnegativeSafeIntegerSchema.max(SANDBOX_MAXIMUM_BINARY_BYTES),
+		contentBase64: CanonicalBase64Schema,
+		encoding: z.literal("base64")
+	}).strict()
+});
+//#endregion
+//#region src/contracts/operation-contracts.ts
+const SandboxOperationIdentitySchema = z.object({
+	operationId: BoundedOpaqueIdentifierSchema,
+	owningGeneration: BoundedOpaqueIdentifierSchema
+}).strict();
+const SandboxCompletedSucceededOutcomeSchema = z.object({
+	certainty: z.literal("proven"),
+	completion: z.literal("succeeded"),
+	kind: z.literal("completed"),
+	retryClass: z.literal("forbidden")
+}).strict();
+const SandboxCompletedFailedOutcomeSchema = z.object({
+	certainty: z.literal("proven"),
+	completion: z.literal("failed"),
+	kind: z.literal("completed"),
+	retryClass: z.enum(["forbidden", "policy-gated"])
+}).strict();
+const SandboxNotDispatchedOutcomeSchema = z.object({
+	certainty: z.literal("proven"),
+	kind: z.literal("not-dispatched"),
+	retryClass: z.literal("safe-before-dispatch")
+}).strict();
+const SandboxProvenTerminationOutcomeSchema = z.discriminatedUnion("kind", [
+	z.object({
+		certainty: z.literal("proven-terminated"),
+		kind: z.literal("cancelled-proven"),
+		retryClass: z.literal("manual-only")
+	}).strict(),
+	z.object({
+		certainty: z.literal("proven-terminated"),
+		kind: z.literal("timed-out-proven"),
+		retryClass: z.literal("manual-only")
+	}).strict(),
+	z.object({
+		certainty: z.literal("proven-terminated"),
+		kind: z.literal("replaced-proven"),
+		priorSideEffects: z.literal("possible"),
+		retryClass: z.literal("manual-only")
+	}).strict()
+]);
+const SandboxAmbiguousOutcomeSchema = z.object({
+	certainty: z.literal("side-effects-and-termination-unknown"),
+	kind: z.literal("ambiguous"),
+	retryClass: z.literal("forbidden")
+}).strict();
+const SandboxTerminalOutcomeSchema = z.union([
+	SandboxNotDispatchedOutcomeSchema,
+	SandboxCompletedSucceededOutcomeSchema,
+	SandboxCompletedFailedOutcomeSchema,
+	SandboxProvenTerminationOutcomeSchema,
+	SandboxAmbiguousOutcomeSchema
+]);
+const SandboxOperationControlResultSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("running"),
+		operation: SandboxOperationIdentitySchema
+	}).strict(),
+	z.object({
+		kind: z.literal("cancel-request-accepted"),
+		operation: SandboxOperationIdentitySchema
+	}).strict(),
+	z.object({
+		kind: z.literal("cancellation-pending"),
+		operation: SandboxOperationIdentitySchema
+	}).strict(),
+	z.object({
+		kind: z.literal("termination-proven"),
+		operation: SandboxOperationIdentitySchema,
+		outcome: SandboxProvenTerminationOutcomeSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("already-terminal"),
+		operation: SandboxOperationIdentitySchema,
+		outcome: SandboxTerminalOutcomeSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("ambiguous"),
+		operation: SandboxOperationIdentitySchema,
+		outcome: SandboxAmbiguousOutcomeSchema
+	}).strict()
+]);
+const SandboxRetainedResultLookupRequestSchema = z.object({ operation: SandboxOperationIdentitySchema }).strict();
+const SandboxRetainedResultLookupResultSchema = z.discriminatedUnion("kind", [
+	z.object({
+		kind: z.literal("retained"),
+		operation: SandboxOperationIdentitySchema,
+		outcome: SandboxTerminalOutcomeSchema
+	}).strict(),
+	z.object({
+		kind: z.literal("pending"),
+		operation: SandboxOperationIdentitySchema
+	}).strict(),
+	z.object({
+		kind: z.literal("unavailable"),
+		reason: z.literal("not-retained-or-not-authorized")
+	}).strict()
+]);
+//#endregion
+//#region src/contracts/sandbox-environment-contracts.ts
+const SandboxEnvironmentLogicalCwdSchema = SandboxWorkRelativePathSchema.optional();
+const SandboxEnvironmentOpenRequestSchema = z.object({ logicalCwd: SandboxEnvironmentLogicalCwdSchema }).strict();
+const SandboxEnvironmentOpenResultSchema = z.object({
+	environment: SandboxEnvironmentHandleSchema,
+	kind: z.literal("opened"),
+	logicalCwd: SandboxEnvironmentLogicalCwdSchema
+}).strict();
+const SandboxEnvironmentHandleRequestSchema = z.object({ environment: SandboxEnvironmentHandleSchema }).strict();
+const SandboxEnvironmentCloseResultSchema = z.discriminatedUnion("kind", [z.object({
+	environment: SandboxEnvironmentHandleSchema,
+	kind: z.literal("closed")
+}).strict(), z.object({
+	environment: SandboxEnvironmentHandleSchema,
+	kind: z.literal("already-closed")
+}).strict()]);
+const SandboxEnvironmentStatusResultSchema = z.discriminatedUnion("kind", [
+	z.object({
+		environment: SandboxEnvironmentHandleSchema,
+		kind: z.literal("active"),
+		logicalCwd: SandboxEnvironmentLogicalCwdSchema
+	}).strict(),
+	z.object({
+		environment: SandboxEnvironmentHandleSchema,
+		kind: z.literal("closed")
+	}).strict(),
+	z.object({
+		environment: SandboxEnvironmentHandleSchema,
+		kind: z.literal("replaced")
+	}).strict()
+]);
+//#endregion
+//#region src/contracts/sandbox-execution-contracts.ts
+const SandboxExecStartModeSchema = z.discriminatedUnion("kind", [z.object({ kind: z.literal("direct") }).strict(), z.object({
+	attachTimeoutMs: BoundedOperationMillisecondsSchema,
+	kind: z.literal("attachment-reserved"),
+	terminal: z.boolean()
+}).strict()]);
+const SandboxExecStartRequestSchema = SandboxDirectShellStartRequestSchema.extend({
+	mode: SandboxExecStartModeSchema,
+	timeoutMs: BoundedOperationMillisecondsSchema
+}).strict();
+const SandboxExecDirectStartedResultSchema = z.object({
+	kind: z.literal("started"),
+	mode: z.literal("direct"),
+	operation: SandboxOperationIdentitySchema,
+	streams: z.array(SandboxStreamHandleSchema).max(3)
+}).strict();
+const SandboxExecAttachmentReservedResultSchema = z.object({
+	kind: z.literal("started"),
+	mode: z.literal("attachment-reserved"),
+	operation: SandboxOperationIdentitySchema,
+	terminal: SandboxTerminalHandleSchema
+}).strict();
+const SandboxExecStartResultSchema = z.union([SandboxExecDirectStartedResultSchema, SandboxExecAttachmentReservedResultSchema]);
+const SandboxExecWaitRequestSchema = z.object({
+	operation: SandboxOperationIdentitySchema,
+	timeoutMs: BoundedOperationMillisecondsSchema
+}).strict();
+const SandboxExecWaitResultSchema = z.object({
+	exitCode: NonnegativeSafeIntegerSchema.max(255).optional(),
+	operation: SandboxOperationIdentitySchema,
+	outcome: SandboxTerminalOutcomeSchema
+}).strict();
+const SandboxExecCancelRequestSchema = z.object({ operation: SandboxOperationIdentitySchema }).strict();
+const SandboxExecCancelResultSchema = SandboxOperationControlResultSchema;
+const SandboxTerminalSizeSchema = z.object({
+	columns: PositiveSafeIntegerSchema.max(1e3),
+	rows: PositiveSafeIntegerSchema.max(1e3)
+}).strict();
+//#endregion
+//#region src/contracts/sandbox-filesystem-contracts.ts
+const SandboxFilesystemPathRequestSchema = z.object({
+	environment: SandboxEnvironmentHandleSchema,
+	path: SandboxGuestPathSchema
+}).strict();
+const SandboxFsStatRequestSchema = SandboxFilesystemPathRequestSchema;
+const SandboxFilesystemEntrySchema = z.object({
+	byteLength: NonnegativeSafeIntegerSchema.optional(),
+	kind: z.enum([
+		"file",
+		"directory",
+		"symlink"
+	]),
+	path: SandboxGuestPathSchema
+}).strict();
+const SandboxFsStatResultSchema = z.discriminatedUnion("kind", [z.object({
+	entry: SandboxFilesystemEntrySchema,
+	kind: z.literal("stat")
+}).strict(), z.object({
+	kind: z.literal("not-found"),
+	path: SandboxGuestPathSchema
+}).strict()]);
+const SandboxFsListRequestSchema = SandboxFilesystemPathRequestSchema.extend({
+	cursor: BoundedOpaqueIdentifierSchema.optional(),
+	maxDepth: PositiveSafeIntegerSchema.max(32),
+	maxEntries: PositiveSafeIntegerSchema.max(1e3)
+}).strict();
+const SandboxFsListResultSchema = z.object({
+	entries: z.array(SandboxFilesystemEntrySchema).max(1e3),
+	kind: z.literal("listed"),
+	nextCursor: BoundedOpaqueIdentifierSchema.optional()
+}).strict();
+const SandboxFsReadRequestSchema = SandboxFilesystemPathRequestSchema.extend({
+	maxBytes: BoundedByteCountSchema,
+	offsetBytes: NonnegativeSafeIntegerSchema
+}).strict();
+const SandboxFsReadResultSchema = z.object({
+	chunk: SandboxBinaryChunkSchema,
+	eof: z.boolean(),
+	kind: z.literal("read"),
+	nextOffsetBytes: NonnegativeSafeIntegerSchema,
+	path: SandboxGuestPathSchema
+}).strict();
+const SandboxFsWriteRequestSchema = SandboxFilesystemPathRequestSchema.extend({
+	atomic: z.boolean(),
+	content: SandboxBinaryChunkSchema,
+	offsetBytes: NonnegativeSafeIntegerSchema.optional()
+}).strict();
+const SandboxFsWriteResultSchema = z.object({
+	bytesWritten: NonnegativeSafeIntegerSchema,
+	contentDigest: Sha256DigestSchema,
+	kind: z.literal("written"),
+	path: SandboxGuestPathSchema
+}).strict();
+const SandboxFsMkdirRequestSchema = SandboxFilesystemPathRequestSchema.extend({ recursive: z.boolean() }).strict();
+const SandboxFsMkdirResultSchema = z.object({
+	created: z.boolean(),
+	kind: z.literal("directory-ready"),
+	path: SandboxGuestPathSchema
+}).strict();
+const SandboxFsRenameRequestSchema = z.object({
+	destinationPath: SandboxGuestPathSchema,
+	environment: SandboxEnvironmentHandleSchema,
+	replace: z.boolean(),
+	sourcePath: SandboxGuestPathSchema
+}).strict();
+const SandboxFsRenameResultSchema = z.object({
+	destinationPath: SandboxGuestPathSchema,
+	kind: z.literal("renamed"),
+	sourcePath: SandboxGuestPathSchema
+}).strict();
+const SandboxFsRemoveRequestSchema = SandboxFilesystemPathRequestSchema.extend({ recursive: z.boolean() }).strict();
+const SandboxFsRemoveResultSchema = z.object({
+	kind: z.literal("removed"),
+	path: SandboxGuestPathSchema,
+	removed: z.boolean()
+}).strict();
+//#endregion
+//#region src/contracts/sandbox-process-contracts.ts
+const SandboxProcessStartRequestSchema = SandboxDirectShellStartRequestSchema.extend({
+	maxRuntimeMs: BoundedOperationMillisecondsSchema,
+	retainOutputBytes: BoundedByteCountSchema
+}).strict();
+const SandboxProcessStartResultSchema = z.object({
+	kind: z.literal("started"),
+	operation: SandboxOperationIdentitySchema,
+	process: SandboxProcessHandleSchema,
+	streams: z.array(SandboxStreamHandleSchema).max(3)
+}).strict();
+const SandboxProcessHandleRequestSchema = z.object({ process: SandboxProcessHandleSchema }).strict();
+const SandboxProcessStatusResultSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("running"),
+	operation: SandboxOperationIdentitySchema,
+	process: SandboxProcessHandleSchema
+}).strict(), z.object({
+	kind: z.literal("terminal"),
+	operation: SandboxOperationIdentitySchema,
+	outcome: SandboxTerminalOutcomeSchema,
+	process: SandboxProcessHandleSchema
+}).strict()]);
+const SandboxProcessWaitRequestSchema = SandboxProcessHandleRequestSchema.extend({ timeoutMs: BoundedOperationMillisecondsSchema }).strict();
+const SandboxProcessWaitResultSchema = SandboxProcessStatusResultSchema;
+const SandboxProcessLogsRequestSchema = SandboxProcessHandleRequestSchema.extend({
+	channels: z.array(SandboxStreamChannelSchema).min(1).max(4),
+	cursor: BoundedOpaqueIdentifierSchema.optional(),
+	maxBytes: BoundedByteCountSchema
+}).strict();
+const SandboxProcessLogChunkSchema = z.object({
+	channel: SandboxStreamChannelSchema,
+	chunk: SandboxBinaryChunkSchema,
+	sequence: NonnegativeSafeIntegerSchema
+}).strict();
+const SandboxProcessLogsResultSchema = z.object({
+	chunks: z.array(SandboxProcessLogChunkSchema).max(1e3),
+	kind: z.literal("logs"),
+	nextCursor: BoundedOpaqueIdentifierSchema.optional(),
+	process: SandboxProcessHandleSchema,
+	truncated: z.boolean()
+}).strict();
+const SandboxProcessCancelRequestSchema = SandboxProcessHandleRequestSchema;
+const SandboxProcessCancelResultSchema = SandboxOperationControlResultSchema;
+//#endregion
+//#region src/contracts/sandbox-stream-contracts.ts
+const SandboxStreamReadRequestSchema = z.object({
+	cursor: BoundedOpaqueIdentifierSchema.optional(),
+	maxBytes: BoundedByteCountSchema,
+	stream: SandboxStreamHandleSchema
+}).strict();
+const SandboxStreamReadResultSchema = z.object({
+	chunk: SandboxBinaryChunkSchema,
+	eof: z.boolean(),
+	kind: z.literal("read"),
+	nextCursor: BoundedOpaqueIdentifierSchema.optional(),
+	sequence: NonnegativeSafeIntegerSchema,
+	stream: SandboxStreamHandleSchema
+}).strict();
+const SandboxStreamWriteRequestSchema = z.object({
+	content: SandboxBinaryChunkSchema,
+	contentDigest: Sha256DigestSchema,
+	sequence: NonnegativeSafeIntegerSchema,
+	stream: SandboxStreamHandleSchema
+}).strict();
+const SandboxStreamWriteResultSchema = z.discriminatedUnion("kind", [z.object({
+	bytesWritten: NonnegativeSafeIntegerSchema,
+	kind: z.literal("written"),
+	sequence: NonnegativeSafeIntegerSchema,
+	stream: SandboxStreamHandleSchema
+}).strict(), z.object({
+	kind: z.literal("already-written"),
+	sequence: NonnegativeSafeIntegerSchema,
+	stream: SandboxStreamHandleSchema
+}).strict()]);
+const SandboxStreamCloseRequestSchema = z.object({ stream: SandboxStreamHandleSchema }).strict();
+const SandboxStreamCloseResultSchema = z.discriminatedUnion("kind", [z.object({
+	kind: z.literal("closed"),
+	stream: SandboxStreamHandleSchema
+}).strict(), z.object({
+	kind: z.literal("already-closed"),
+	stream: SandboxStreamHandleSchema
+}).strict()]);
+//#endregion
+//#region src/contracts/sandbox-terminal-contracts.ts
+const SandboxTerminalAttachRequestSchema = z.object({
+	operation: SandboxOperationIdentitySchema,
+	size: SandboxTerminalSizeSchema
+}).strict();
+const SandboxTerminalAttachResultSchema = z.object({
+	input: SandboxStreamHandleSchema,
+	kind: z.literal("attached"),
+	output: SandboxStreamHandleSchema,
+	terminal: SandboxTerminalHandleSchema
+}).strict();
+const SandboxTerminalResizeRequestSchema = z.object({
+	size: SandboxTerminalSizeSchema,
+	terminal: SandboxTerminalHandleSchema
+}).strict();
+const SandboxTerminalResizeResultSchema = z.object({
+	kind: z.literal("resized"),
+	size: SandboxTerminalSizeSchema,
+	terminal: SandboxTerminalHandleSchema
+}).strict();
+//#endregion
+//#region src/contracts/trusted-context-contracts.ts
+const GatewayRuntimeFrameworkKindSchema = z.enum(["openclaw", "hermes"]);
+const GatewayRuntimeManagedPluginClientKindSchema = z.enum(["openclaw-managed-plugin", "hermes-managed-plugin"]);
+const GatewayRuntimeFrameworkIdentitySchema = z.discriminatedUnion("kind", [z.object({
+	agentId: BoundedOpaqueIdentifierSchema,
+	kind: z.literal("openclaw")
+}).strict(), z.object({
+	kind: z.literal("hermes"),
+	profileName: BoundedOpaqueIdentifierSchema
+}).strict()]).readonly();
+const GatewayRuntimeProjectionCohortDigestSchema = z.string().regex(/^projection-cohort:[a-f0-9]{64}$/u);
+const ManagedAgentProjectionSchema = z.object({
+	agentId: BoundedOpaqueIdentifierSchema,
+	frameworkIdentity: GatewayRuntimeFrameworkIdentitySchema,
+	profileAssignmentRevision: BoundedOpaqueIdentifierSchema,
+	toolPortalProfileId: BoundedOpaqueIdentifierSchema
+}).strict().readonly();
+const GatewayRuntimeAttachmentMetadataSchema = withPortableSuperRefinement({
+	refinement: (metadata, context) => {
+		if (new Set(metadata.configuredAgentIds).size !== metadata.configuredAgentIds.length) context.addIssue({
+			code: "custom",
+			message: "Gateway attachment metadata contains a duplicate configured agent id.",
+			path: ["configuredAgentIds"]
+		});
+	},
+	refinementIdentity: "gateway.attachment.unique-agent-ids",
+	schema: z.object({
+		attachmentGeneration: PositiveSafeIntegerSchema,
+		clientKind: GatewayRuntimeManagedPluginClientKindSchema,
+		configuredAgentIds: z.array(BoundedOpaqueIdentifierSchema).min(1).max(128),
+		frameworkEpoch: BoundedOpaqueIdentifierSchema,
+		gatewayEpoch: BoundedOpaqueIdentifierSchema,
+		protocolVersion: PositiveSafeIntegerSchema,
+		projectionCohortDigest: GatewayRuntimeProjectionCohortDigestSchema,
+		runtimeEpoch: BoundedOpaqueIdentifierSchema,
+		schemaVersion: PositiveSafeIntegerSchema
+	}).strict()
+});
+const GatewayStablePrincipalDigestSchema = z.string().regex(/^[a-f0-9]{64}$/u);
+const GatewayRuntimeTrustedInvocationPrincipalSchema = z.object({
+	agentId: BoundedOpaqueIdentifierSchema,
+	frameworkIdentity: GatewayRuntimeFrameworkIdentitySchema,
+	profileAssignmentRevision: BoundedOpaqueIdentifierSchema,
+	toolPortalProfileId: BoundedOpaqueIdentifierSchema
+}).strict();
+const GatewayRuntimeTrustedInvocationRequesterSchema = z.object({ authenticatedSubjectId: BoundedOpaqueIdentifierSchema }).strict();
+const GatewayRuntimeTrustedInvocationCorrelationSchema = z.object({
+	runId: BoundedOpaqueIdentifierSchema.optional(),
+	sessionId: BoundedOpaqueIdentifierSchema.optional(),
+	sessionKey: BoundedOpaqueIdentifierSchema.optional(),
+	toolCallId: BoundedOpaqueIdentifierSchema.optional()
+}).strict();
+const GatewayRuntimeTrustedInvocationContextSchema = z.object({
+	correlation: GatewayRuntimeTrustedInvocationCorrelationSchema.optional(),
+	principal: GatewayRuntimeTrustedInvocationPrincipalSchema,
+	requester: GatewayRuntimeTrustedInvocationRequesterSchema.optional()
+}).strict();
+//#endregion
+//#region src/contracts/index.ts
+const SANDBOX_METHOD_CONTRACTS = {
+	"sandbox.environment.close": {
+		request: SandboxEnvironmentHandleRequestSchema,
+		result: SandboxEnvironmentCloseResultSchema
+	},
+	"sandbox.environment.open": {
+		request: SandboxEnvironmentOpenRequestSchema,
+		result: SandboxEnvironmentOpenResultSchema
+	},
+	"sandbox.environment.status": {
+		request: SandboxEnvironmentHandleRequestSchema,
+		result: SandboxEnvironmentStatusResultSchema
+	},
+	"sandbox.exec.cancel": {
+		request: SandboxExecCancelRequestSchema,
+		result: SandboxExecCancelResultSchema
+	},
+	"sandbox.exec.start": {
+		request: SandboxExecStartRequestSchema,
+		result: SandboxExecStartResultSchema
+	},
+	"sandbox.exec.wait": {
+		request: SandboxExecWaitRequestSchema,
+		result: SandboxExecWaitResultSchema
+	},
+	"sandbox.retained-result.lookup": {
+		request: SandboxRetainedResultLookupRequestSchema,
+		result: SandboxRetainedResultLookupResultSchema
+	},
+	"sandbox.fs.list": {
+		request: SandboxFsListRequestSchema,
+		result: SandboxFsListResultSchema
+	},
+	"sandbox.fs.mkdir": {
+		request: SandboxFsMkdirRequestSchema,
+		result: SandboxFsMkdirResultSchema
+	},
+	"sandbox.fs.read": {
+		request: SandboxFsReadRequestSchema,
+		result: SandboxFsReadResultSchema
+	},
+	"sandbox.fs.remove": {
+		request: SandboxFsRemoveRequestSchema,
+		result: SandboxFsRemoveResultSchema
+	},
+	"sandbox.fs.rename": {
+		request: SandboxFsRenameRequestSchema,
+		result: SandboxFsRenameResultSchema
+	},
+	"sandbox.fs.stat": {
+		request: SandboxFsStatRequestSchema,
+		result: SandboxFsStatResultSchema
+	},
+	"sandbox.fs.write": {
+		request: SandboxFsWriteRequestSchema,
+		result: SandboxFsWriteResultSchema
+	},
+	"sandbox.process.cancel": {
+		request: SandboxProcessCancelRequestSchema,
+		result: SandboxProcessCancelResultSchema
+	},
+	"sandbox.process.logs": {
+		request: SandboxProcessLogsRequestSchema,
+		result: SandboxProcessLogsResultSchema
+	},
+	"sandbox.process.start": {
+		request: SandboxProcessStartRequestSchema,
+		result: SandboxProcessStartResultSchema
+	},
+	"sandbox.process.status": {
+		request: SandboxProcessHandleRequestSchema,
+		result: SandboxProcessStatusResultSchema
+	},
+	"sandbox.process.wait": {
+		request: SandboxProcessWaitRequestSchema,
+		result: SandboxProcessWaitResultSchema
+	},
+	"sandbox.stream.close": {
+		request: SandboxStreamCloseRequestSchema,
+		result: SandboxStreamCloseResultSchema
+	},
+	"sandbox.stream.read": {
+		request: SandboxStreamReadRequestSchema,
+		result: SandboxStreamReadResultSchema
+	},
+	"sandbox.stream.write": {
+		request: SandboxStreamWriteRequestSchema,
+		result: SandboxStreamWriteResultSchema
+	},
+	"sandbox.terminal.attach": {
+		request: SandboxTerminalAttachRequestSchema,
+		result: SandboxTerminalAttachResultSchema
+	},
+	"sandbox.terminal.resize": {
+		request: SandboxTerminalResizeRequestSchema,
+		result: SandboxTerminalResizeResultSchema
+	}
+};
+//#endregion
+export { SandboxExecStartResultSchema as $, SandboxProcessStartResultSchema as A, SandboxBinaryChunkSchema as At, SandboxFsReadResultSchema as B, SandboxProcessHandleSchema as Bt, SandboxProcessCancelRequestSchema as C, SANDBOX_MAXIMUM_BINARY_BYTES as Ct, SandboxProcessLogsRequestSchema as D, SANDBOX_MAXIMUM_OPERATION_MILLISECONDS as Dt, SandboxProcessLogChunkSchema as E, SANDBOX_MAXIMUM_LIST_ITEMS as Et, SandboxFsListRequestSchema as F, SandboxEnvironmentVariableSchema as Ft, SandboxFsStatRequestSchema as G, SandboxWorkRelativePathSchema as Gt, SandboxFsRemoveResultSchema as H, SandboxStreamChannelSchema as Ht, SandboxFsListResultSchema as I, SandboxEnvironmentVariableValueSchema as It, SandboxFsWriteResultSchema as J, SandboxFsStatResultSchema as K, Sha256DigestSchema as Kt, SandboxFsMkdirRequestSchema as L, SandboxGuestAbsolutePathSchema as Lt, SandboxProcessWaitRequestSchema as M, SandboxDirectShellStartRequestSchema as Mt, SandboxProcessWaitResultSchema as N, SandboxEnvironmentHandleSchema as Nt, SandboxProcessLogsResultSchema as O, SANDBOX_MAXIMUM_PATH_CHARACTERS as Ot, SandboxFilesystemEntrySchema as P, SandboxEnvironmentVariableNameSchema as Pt, SandboxExecStartRequestSchema as Q, SandboxFsMkdirResultSchema as R, SandboxGuestPathSchema as Rt, SandboxStreamWriteResultSchema as S, PositiveSafeIntegerSchema as St, SandboxProcessHandleRequestSchema as T, SANDBOX_MAXIMUM_IDENTIFIER_CHARACTERS as Tt, SandboxFsRenameRequestSchema as U, SandboxStreamHandleSchema as Ut, SandboxFsRemoveRequestSchema as V, SandboxShellCommandSchema as Vt, SandboxFsRenameResultSchema as W, SandboxTerminalHandleSchema as Wt, SandboxExecCancelResultSchema as X, SandboxExecCancelRequestSchema as Y, SandboxExecStartModeSchema as Z, SandboxStreamCloseRequestSchema as _, BoundedOperationMillisecondsSchema as _t, GatewayRuntimeManagedPluginClientKindSchema as a, SandboxEnvironmentOpenRequestSchema as at, SandboxStreamReadResultSchema as b, NonnegativeSafeIntegerSchema as bt, GatewayRuntimeTrustedInvocationCorrelationSchema as c, SandboxAmbiguousOutcomeSchema as ct, GatewayStablePrincipalDigestSchema as d, SandboxProvenTerminationOutcomeSchema as dt, SandboxExecWaitRequestSchema as et, ManagedAgentProjectionSchema as f, SandboxRetainedResultLookupRequestSchema as ft, SandboxTerminalResizeResultSchema as g, BoundedOpaqueIdentifierSchema as gt, SandboxTerminalResizeRequestSchema as h, BoundedByteCountSchema as ht, GatewayRuntimeFrameworkKindSchema as i, SandboxEnvironmentHandleRequestSchema as it, SandboxProcessStatusResultSchema as j, SandboxBoundHandleSchema as jt, SandboxProcessStartRequestSchema as k, SANDBOX_MAXIMUM_TEXT_CHARACTERS as kt, GatewayRuntimeTrustedInvocationPrincipalSchema as l, SandboxOperationControlResultSchema as lt, SandboxTerminalAttachResultSchema as m, SandboxTerminalOutcomeSchema as mt, GatewayRuntimeAttachmentMetadataSchema as n, SandboxTerminalSizeSchema as nt, GatewayRuntimeProjectionCohortDigestSchema as o, SandboxEnvironmentOpenResultSchema as ot, SandboxTerminalAttachRequestSchema as p, SandboxRetainedResultLookupResultSchema as pt, SandboxFsWriteRequestSchema as q, createSandboxBoundHandleSchema as qt, GatewayRuntimeFrameworkIdentitySchema as r, SandboxEnvironmentCloseResultSchema as rt, GatewayRuntimeTrustedInvocationContextSchema as s, SandboxEnvironmentStatusResultSchema as st, SANDBOX_METHOD_CONTRACTS as t, SandboxExecWaitResultSchema as tt, GatewayRuntimeTrustedInvocationRequesterSchema as u, SandboxOperationIdentitySchema as ut, SandboxStreamCloseResultSchema as v, BoundedTextSchema as vt, SandboxProcessCancelResultSchema as w, SANDBOX_MAXIMUM_ENVIRONMENT_VARIABLES as wt, SandboxStreamWriteRequestSchema as x, PORTABLE_MAXIMUM_SAFE_INTEGER as xt, SandboxStreamReadRequestSchema as y, CanonicalBase64Schema as yt, SandboxFsReadRequestSchema as z, SandboxHandleKindSchema as zt };
+
+//# sourceMappingURL=contracts-RgGW0RX2.js.map