@opengeni/contracts 0.39.0 → 0.44.1

package/dist/chunk-52SGB2QO.js

@@ -0,0 +1,688 @@
+// src/video-generation.ts
+import { z as z2 } from "zod";
+
+// src/retained-output.ts
+import { z } from "zod";
+var RETAINED_OUTPUT_MAX_PAGE_BYTES = 1024 * 1024;
+var RETAINED_OUTPUT_DEFAULT_PAGE_BYTES = 256 * 1024;
+var RETAINED_OUTPUT_RECEIPT_MAX_BYTES = 2 * 1024;
+var COMPUTER_SCREENSHOT_MAX_BYTES = 32 * 1024 * 1024;
+var COMPUTER_SCREENSHOT_MAX_DIMENSION = 16384;
+var COMPUTER_SCREENSHOT_MAX_PIXELS = 67108864;
+var COMPUTER_SCREENSHOT_RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var COMPUTER_SCREENSHOT_WORKSPACE_QUOTA_BYTES = 5 * 1024 * 1024 * 1024;
+var GENERATED_IMAGE_MAX_BYTES = 64 * 1024 * 1024;
+var GENERATED_VIDEO_MAX_BYTES = 512 * 1024 * 1024;
+var encoder = new TextEncoder();
+var LOWERCASE_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+var LOWERCASE_SHA256 = /^[0-9a-f]{64}$/;
+var CANONICAL_MEDIA_TYPE = /^[a-z0-9][a-z0-9!#$&^_.+-]{0,62}\/[a-z0-9][a-z0-9!#$&^_.+-]{0,62}$/;
+var WORKSPACE_RETRIEVAL_PATH = /^\/v1\/workspaces\/([0-9a-f-]+)\/artifacts\/([0-9a-f-]+)\/content$/;
+var SESSION_RETRIEVAL_PATH = /^\/v1\/workspaces\/([0-9a-f-]+)\/sessions\/([0-9a-f-]+)\/artifacts\/([0-9a-f-]+)\/content$/;
+var RetainedOutputKind = z.enum([
+  "tool_result",
+  "assistant_completion",
+  "internal_update",
+  "event_media",
+  "computer_screenshot",
+  "generated_image",
+  "generated_video",
+  "file"
+]);
+var RetainedOutputUnavailableReason = z.enum([
+  "not_retained",
+  "pending",
+  "failed",
+  "expired",
+  "deleted",
+  "missing_storage",
+  "storage_write_failed",
+  "quota_exceeded",
+  "invalid_content",
+  "oversized",
+  "unsupported"
+]);
+var RetainedOutputUnavailableEvidenceSchema = z.object({
+  available: z.literal(false),
+  reason: RetainedOutputUnavailableReason
+}).strict();
+var RetainedArtifactReferenceSchema = z.object({
+  available: z.literal(true),
+  artifactId: z.string().regex(LOWERCASE_UUID),
+  kind: RetainedOutputKind,
+  contentType: z.string().max(127).regex(CANONICAL_MEDIA_TYPE),
+  originalBytes: z.number().int().nonnegative().safe(),
+  sha256: z.string().regex(LOWERCASE_SHA256),
+  retainedAt: z.string().datetime({ offset: true }),
+  dimensions: z.object({
+    width: z.number().int().positive().max(COMPUTER_SCREENSHOT_MAX_DIMENSION),
+    height: z.number().int().positive().max(COMPUTER_SCREENSHOT_MAX_DIMENSION)
+  }).strict().optional(),
+  retention: z.union([
+    z.object({
+      policy: z.literal("workspace_file"),
+      expiresAt: z.null()
+    }).strict(),
+    z.object({
+      policy: z.literal("session_screenshot"),
+      expiresAt: z.string().datetime({ offset: true })
+    }).strict()
+  ]),
+  retrieval: z.object({
+    method: z.literal("GET"),
+    path: z.string().max(256),
+    acceptRanges: z.literal("bytes"),
+    maxRangeBytes: z.number().int().positive().max(RETAINED_OUTPUT_MAX_PAGE_BYTES)
+  }).strict()
+}).strict().superRefine((value, ctx) => {
+  const workspaceMatch = WORKSPACE_RETRIEVAL_PATH.exec(value.retrieval.path);
+  const sessionMatch = SESSION_RETRIEVAL_PATH.exec(value.retrieval.path);
+  const workspaceId = workspaceMatch?.[1] ?? sessionMatch?.[1];
+  const sessionId = sessionMatch?.[2];
+  const artifactId = workspaceMatch?.[2] ?? sessionMatch?.[3];
+  if (!workspaceId || !LOWERCASE_UUID.test(workspaceId) || sessionId !== void 0 && !LOWERCASE_UUID.test(sessionId) || artifactId !== value.artifactId) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["retrieval", "path"],
+      message: "retrieval path must be a workspace/session API content path for this artifact"
+    });
+  }
+  if (value.kind === "computer_screenshot" || value.kind === "generated_image" || value.kind === "generated_video") {
+    if (!value.dimensions) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["dimensions"],
+        message: `${value.kind} receipts require exact dimensions`
+      });
+    } else if (value.dimensions.width * value.dimensions.height > COMPUTER_SCREENSHOT_MAX_PIXELS) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["dimensions"],
+        message: `${value.kind} dimensions exceed the pixel limit`
+      });
+    }
+  }
+  if (value.kind === "generated_image") {
+    if (value.retention.policy !== "workspace_file" || !workspaceMatch || sessionMatch) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["retention"],
+        message: "generated images require permanent workspace-file retrieval"
+      });
+    }
+    if (!["image/png", "image/jpeg", "image/webp"].includes(value.contentType) || value.originalBytes <= 0 || value.originalBytes > GENERATED_IMAGE_MAX_BYTES) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["contentType"],
+        message: "generated image media metadata is invalid"
+      });
+    }
+  }
+  if (value.kind === "generated_video") {
+    if (value.retention.policy !== "workspace_file" || !workspaceMatch || sessionMatch) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["retention"],
+        message: "generated videos require permanent workspace-file retrieval"
+      });
+    }
+    if (value.contentType !== "video/mp4" || value.originalBytes <= 0 || value.originalBytes > GENERATED_VIDEO_MAX_BYTES) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["contentType"],
+        message: "generated video media metadata is invalid"
+      });
+    }
+  }
+  if (value.kind === "computer_screenshot") {
+    if (value.retention.policy !== "session_screenshot" || !sessionMatch) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["retention"],
+        message: "computer screenshots require session-scoped expiring retrieval"
+      });
+    }
+  }
+  if (encoder.encode(JSON.stringify(value)).byteLength > RETAINED_OUTPUT_RECEIPT_MAX_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      message: "retained-output receipt exceeds its byte envelope"
+    });
+  }
+});
+var RetainedOutputEvidenceSchema = z.discriminatedUnion("available", [
+  RetainedOutputUnavailableEvidenceSchema,
+  RetainedArtifactReferenceSchema
+]);
+var RetainedArtifactUnavailableSchema = z.object({
+  available: z.literal(false),
+  artifactId: z.string().regex(LOWERCASE_UUID),
+  reason: RetainedOutputUnavailableReason
+}).strict();
+var RetainedArtifactMetadataSchema = z.union([
+  RetainedArtifactReferenceSchema,
+  RetainedArtifactUnavailableSchema
+]);
+function retainedArtifactReferenceFromFile(file, kind = "file") {
+  if (file.status !== "ready" || !file.sha256) return null;
+  const value = {
+    available: true,
+    artifactId: file.id,
+    kind,
+    contentType: canonicalRetainedContentType(file.contentType),
+    originalBytes: file.sizeBytes,
+    sha256: file.sha256,
+    retainedAt: file.updatedAt,
+    retention: {
+      policy: "workspace_file",
+      expiresAt: null
+    },
+    retrieval: {
+      method: "GET",
+      path: `/v1/workspaces/${file.workspaceId}/artifacts/${file.id}/content`,
+      acceptRanges: "bytes",
+      maxRangeBytes: RETAINED_OUTPUT_MAX_PAGE_BYTES
+    }
+  };
+  const parsed = RetainedArtifactReferenceSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+function retainedScreenshotReferenceFromFile(file) {
+  if (file.status !== "ready" || !file.sha256 || file.sizeBytes <= 0) return null;
+  const value = {
+    available: true,
+    artifactId: file.id,
+    kind: "computer_screenshot",
+    contentType: canonicalRetainedContentType(file.contentType),
+    originalBytes: file.sizeBytes,
+    sha256: file.sha256,
+    retainedAt: file.updatedAt,
+    dimensions: { width: file.width, height: file.height },
+    retention: {
+      policy: "session_screenshot",
+      expiresAt: file.expiresAt
+    },
+    retrieval: {
+      method: "GET",
+      path: `/v1/workspaces/${file.workspaceId}/sessions/${file.sessionId}/artifacts/${file.id}/content`,
+      acceptRanges: "bytes",
+      maxRangeBytes: RETAINED_OUTPUT_MAX_PAGE_BYTES
+    }
+  };
+  const parsed = RetainedArtifactReferenceSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+function retainedGeneratedImageReferenceFromFile(file) {
+  if (file.status !== "ready" || !file.sha256 || file.sizeBytes <= 0 || file.sizeBytes > GENERATED_IMAGE_MAX_BYTES) {
+    return null;
+  }
+  const value = {
+    available: true,
+    artifactId: file.id,
+    kind: "generated_image",
+    contentType: canonicalRetainedContentType(file.contentType),
+    originalBytes: file.sizeBytes,
+    sha256: file.sha256,
+    retainedAt: file.updatedAt,
+    dimensions: { width: file.width, height: file.height },
+    retention: {
+      policy: "workspace_file",
+      expiresAt: null
+    },
+    retrieval: {
+      method: "GET",
+      path: `/v1/workspaces/${file.workspaceId}/artifacts/${file.id}/content`,
+      acceptRanges: "bytes",
+      maxRangeBytes: RETAINED_OUTPUT_MAX_PAGE_BYTES
+    }
+  };
+  const parsed = RetainedArtifactReferenceSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+function retainedGeneratedVideoReferenceFromFile(file) {
+  if (file.status !== "ready" || file.contentType !== "video/mp4" || !file.sha256 || file.sizeBytes <= 0 || file.sizeBytes > GENERATED_VIDEO_MAX_BYTES) {
+    return null;
+  }
+  const value = {
+    available: true,
+    artifactId: file.id,
+    kind: "generated_video",
+    contentType: "video/mp4",
+    originalBytes: file.sizeBytes,
+    sha256: file.sha256,
+    retainedAt: file.updatedAt,
+    dimensions: { width: file.width, height: file.height },
+    retention: {
+      policy: "workspace_file",
+      expiresAt: null
+    },
+    retrieval: {
+      method: "GET",
+      path: `/v1/workspaces/${file.workspaceId}/artifacts/${file.id}/content`,
+      acceptRanges: "bytes",
+      maxRangeBytes: RETAINED_OUTPUT_MAX_PAGE_BYTES
+    }
+  };
+  const parsed = RetainedArtifactReferenceSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+function canonicalRetainedContentType(value) {
+  const mediaType = value.split(";", 1)[0]?.trim().toLowerCase() ?? "";
+  return CANONICAL_MEDIA_TYPE.test(mediaType) ? mediaType : "application/octet-stream";
+}
+function validateRetainedOutputEvidence(value) {
+  const parsed = RetainedOutputEvidenceSchema.safeParse(value);
+  return parsed.success ? parsed.data : null;
+}
+function retainedOutputUnavailable(reason = "not_retained") {
+  return { available: false, reason };
+}
+function resolveRetainedOutputRange(rangeHeader, totalBytes, maxPageBytes = RETAINED_OUTPUT_DEFAULT_PAGE_BYTES) {
+  assertRangeInputs(totalBytes, maxPageBytes);
+  if (rangeHeader === null || rangeHeader === void 0 || rangeHeader === "") {
+    if (totalBytes === 0) {
+      return {
+        kind: "empty",
+        length: 0,
+        totalBytes: 0,
+        status: 200,
+        contentRange: null,
+        acceptRanges: "bytes"
+      };
+    }
+    const end = Math.min(totalBytes - 1, maxPageBytes - 1);
+    const partial = end + 1 < totalBytes;
+    return resolvedRange(0, end, totalBytes, partial ? 206 : 200);
+  }
+  if (rangeHeader.length > 128 || /[^\x20-\x7e]/.test(rangeHeader)) {
+    return invalidRange("malformed", maxPageBytes);
+  }
+  if (rangeHeader.includes(",")) {
+    return invalidRange("multipart_not_supported", maxPageBytes);
+  }
+  const match = /^bytes=(\d*)-(\d*)$/.exec(rangeHeader);
+  if (!match || !match[1] && !match[2]) {
+    return invalidRange("malformed", maxPageBytes);
+  }
+  const first = parseRangeInteger(match[1]);
+  const second = parseRangeInteger(match[2]);
+  if (first === "overflow" || second === "overflow") {
+    return invalidRange("numeric_overflow", maxPageBytes);
+  }
+  if (first === null) {
+    const suffixLength = second;
+    if (suffixLength === null) return invalidRange("malformed", maxPageBytes);
+    if (suffixLength === 0) return unsatisfiableRange("zero_suffix", totalBytes);
+    if (suffixLength > maxPageBytes) return invalidRange("range_too_large", maxPageBytes);
+    if (totalBytes === 0) return unsatisfiableRange("empty_artifact", totalBytes);
+    const length = Math.min(suffixLength, totalBytes);
+    return resolvedRange(totalBytes - length, totalBytes - 1, totalBytes, 206);
+  }
+  if (totalBytes === 0) return unsatisfiableRange("empty_artifact", totalBytes);
+  if (first >= totalBytes) return unsatisfiableRange("start_out_of_bounds", totalBytes);
+  if (second === null) {
+    const end = Math.min(totalBytes - 1, first + maxPageBytes - 1);
+    return resolvedRange(first, end, totalBytes, 206);
+  }
+  if (second < first) return unsatisfiableRange("end_before_start", totalBytes);
+  if (second - first >= maxPageBytes) {
+    return invalidRange("range_too_large", maxPageBytes);
+  }
+  return resolvedRange(first, Math.min(second, totalBytes - 1), totalBytes, 206);
+}
+function assertRangeInputs(totalBytes, maxPageBytes) {
+  if (!Number.isSafeInteger(totalBytes) || totalBytes < 0) {
+    throw new RangeError("totalBytes must be a nonnegative safe integer");
+  }
+  if (!Number.isSafeInteger(maxPageBytes) || maxPageBytes <= 0 || maxPageBytes > RETAINED_OUTPUT_MAX_PAGE_BYTES) {
+    throw new RangeError(
+      `maxPageBytes must be an integer between 1 and ${RETAINED_OUTPUT_MAX_PAGE_BYTES}`
+    );
+  }
+}
+function parseRangeInteger(value) {
+  if (!value) return null;
+  if (value.length > 16) return "overflow";
+  const parsed = Number(value);
+  return Number.isSafeInteger(parsed) ? parsed : "overflow";
+}
+function resolvedRange(start, end, totalBytes, status) {
+  return {
+    kind: "range",
+    start,
+    end,
+    length: end - start + 1,
+    totalBytes,
+    status,
+    contentRange: status === 206 ? `bytes ${start}-${end}/${totalBytes}` : null,
+    acceptRanges: "bytes"
+  };
+}
+function invalidRange(reason, maxPageBytes) {
+  return { kind: "invalid", reason, maxPageBytes };
+}
+function unsatisfiableRange(reason, totalBytes) {
+  return {
+    kind: "unsatisfiable",
+    reason,
+    totalBytes,
+    contentRange: `bytes */${totalBytes}`
+  };
+}
+
+// src/video-generation.ts
+var VIDEO_GENERATION_SCHEMA_VERSION = 1;
+var SEEDANCE_2_5_MODEL_ID = "bytedance/seedance-2.5";
+var VideoGenerationSourceMode = z2.enum([
+  "text",
+  "first_frame",
+  "first_and_last_frames",
+  "image_reference",
+  "video_reference"
+]);
+var VideoGenerationResolution = z2.enum(["480p", "720p"]);
+var VideoGenerationFundingSource = z2.enum(["opengeni_credits", "workspace_gateway"]);
+var VideoGenerationAspectRatio = z2.enum([
+  "16:9",
+  "4:3",
+  "1:1",
+  "3:4",
+  "9:16",
+  "21:9",
+  "adaptive"
+]);
+var SandboxVideoReferencePath = z2.string().min(1).max(1024).refine((value) => value.startsWith("/workspace/"), {
+  message: "video references must use an absolute /workspace path"
+});
+var VideoGenerationSource = z2.discriminatedUnion("mode", [
+  z2.object({ mode: z2.literal("text") }).strict(),
+  z2.object({
+    mode: z2.literal("first_frame"),
+    imagePath: SandboxVideoReferencePath
+  }).strict(),
+  z2.object({
+    mode: z2.literal("first_and_last_frames"),
+    firstFramePath: SandboxVideoReferencePath,
+    lastFramePath: SandboxVideoReferencePath
+  }).strict().refine((value) => value.firstFramePath !== value.lastFramePath, {
+    path: ["lastFramePath"],
+    message: "first and last frame paths must differ"
+  }),
+  z2.object({
+    mode: z2.literal("image_reference"),
+    imagePath: SandboxVideoReferencePath
+  }).strict(),
+  z2.object({
+    mode: z2.literal("video_reference"),
+    videoPath: SandboxVideoReferencePath
+  }).strict()
+]);
+var GenerateVideoToolInput = z2.object({
+  prompt: z2.string().min(1).max(32e3).refine((value) => value.trim().length > 0),
+  modelId: z2.string().min(1).max(256).optional(),
+  source: VideoGenerationSource.optional(),
+  durationSeconds: z2.number().int().min(4).max(30).optional(),
+  aspectRatio: VideoGenerationAspectRatio.optional(),
+  resolution: VideoGenerationResolution.optional(),
+  generateAudio: z2.boolean().optional()
+}).strict();
+var GetVideoGenerationCapabilitiesToolInput = z2.object({}).strict();
+var VideoGenerationModelCapability = z2.object({
+  modelId: z2.string().min(1).max(256),
+  label: z2.string().min(1).max(128),
+  providerLabel: z2.string().min(1).max(128),
+  sourceModes: z2.array(VideoGenerationSourceMode).min(1).max(5),
+  resolutions: z2.array(VideoGenerationResolution).min(1).max(2),
+  aspectRatios: z2.array(VideoGenerationAspectRatio).min(1).max(7),
+  duration: z2.object({
+    minSeconds: z2.number().int().positive(),
+    maxSeconds: z2.number().int().positive(),
+    stepSeconds: z2.number().int().positive()
+  }).strict().refine((value) => value.maxSeconds >= value.minSeconds),
+  supportsAudio: z2.boolean()
+}).strict();
+var VideoGenerationCapabilities = z2.object({
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  capabilityRevision: z2.string().min(1).max(128),
+  defaultModelId: z2.string().min(1).max(256),
+  models: z2.array(VideoGenerationModelCapability).min(1).max(16)
+}).strict().superRefine((value, ctx) => {
+  const ids = new Set(value.models.map((model) => model.modelId));
+  if (ids.size !== value.models.length) {
+    ctx.addIssue({ code: "custom", path: ["models"], message: "model ids must be unique" });
+  }
+  if (!ids.has(value.defaultModelId)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultModelId"],
+      message: "default model must be present in the enabled model list"
+    });
+  }
+});
+var VideoGenerationPolicy = z2.object({
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  revision: z2.number().int().nonnegative().safe(),
+  fundingSource: VideoGenerationFundingSource,
+  enabledModelIds: z2.array(z2.string().min(1).max(256)).max(16),
+  defaultModelId: z2.string().min(1).max(256).nullable()
+}).strict().superRefine((value, ctx) => {
+  const ids = new Set(value.enabledModelIds);
+  if (ids.size !== value.enabledModelIds.length) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["enabledModelIds"],
+      message: "enabled model ids must be unique"
+    });
+  }
+  if (value.defaultModelId !== null && !ids.has(value.defaultModelId)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["defaultModelId"],
+      message: "default model must be enabled"
+    });
+  }
+});
+var UpdateVideoGenerationPolicyRequest = z2.object({
+  expectedRevision: z2.number().int().nonnegative().safe(),
+  fundingSource: VideoGenerationFundingSource,
+  enabledModelIds: z2.array(z2.string().min(1).max(256)).max(16),
+  defaultModelId: z2.string().min(1).max(256).nullable()
+}).strict();
+var VideoGenerationFundingOption = z2.object({
+  source: VideoGenerationFundingSource,
+  label: z2.string().min(1).max(128),
+  description: z2.string().min(1).max(256),
+  available: z2.boolean(),
+  unavailableReason: z2.string().min(1).max(256).nullable()
+}).strict().superRefine((value, ctx) => {
+  if (value.available !== (value.unavailableReason === null)) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["unavailableReason"],
+      message: "available funding options cannot have an unavailable reason"
+    });
+  }
+});
+var WorkspaceVideoGenerationSettings = z2.object({
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  policy: VideoGenerationPolicy,
+  fundingOptions: z2.array(VideoGenerationFundingOption).length(2),
+  availableModels: z2.array(VideoGenerationModelCapability).max(16),
+  capabilities: VideoGenerationCapabilities.nullable()
+}).strict().superRefine((value, ctx) => {
+  if (new Set(value.fundingOptions.map((option) => option.source)).size !== 2 || !value.fundingOptions.some((option) => option.source === "opengeni_credits") || !value.fundingOptions.some((option) => option.source === "workspace_gateway")) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["fundingOptions"],
+      message: "both funding sources must be described exactly once"
+    });
+  }
+  const selected = value.fundingOptions.find(
+    (option) => option.source === value.policy.fundingSource
+  );
+  if (!selected) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["fundingOptions"],
+      message: "the selected funding source must be described"
+    });
+  } else if (!selected.available && value.capabilities !== null) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["capabilities"],
+      message: "unavailable funding cannot expose executable capabilities"
+    });
+  }
+});
+var VideoGenerationAcceptedReceipt = z2.object({
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  status: z2.literal("accepted"),
+  operationId: z2.string().uuid()
+}).strict();
+var GeneratedVideoFacts = z2.object({
+  durationSeconds: z2.number().positive().max(120),
+  width: z2.number().int().positive().max(8192),
+  height: z2.number().int().positive().max(8192),
+  fps: z2.number().positive().max(120),
+  hasAudio: z2.boolean(),
+  videoCodec: z2.literal("h264"),
+  audioCodec: z2.literal("aac").nullable()
+}).strict();
+var GeneratedVideoReceipt = z2.object({
+  type: z2.literal("generated_video"),
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  operationId: z2.string().uuid(),
+  artifact: RetainedArtifactReferenceSchema,
+  video: GeneratedVideoFacts,
+  sandboxPath: z2.string().max(256).regex(
+    /^\/workspace\/generated-videos\/generated-video-[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.mp4$/
+  )
+}).strict().superRefine((value, ctx) => {
+  if (value.artifact.kind !== "generated_video" || value.artifact.contentType !== "video/mp4" || value.artifact.originalBytes <= 0 || value.artifact.originalBytes > GENERATED_VIDEO_MAX_BYTES || value.artifact.retention.policy !== "workspace_file" || value.artifact.retrieval.maxRangeBytes !== RETAINED_OUTPUT_MAX_PAGE_BYTES) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["artifact"],
+      message: "generated-video artifact metadata is invalid"
+    });
+  }
+  if (value.artifact.dimensions?.width !== value.video.width || value.artifact.dimensions?.height !== value.video.height) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["video"],
+      message: "video dimensions must match the retained artifact"
+    });
+  }
+  if (value.sandboxPath !== `/workspace/generated-videos/generated-video-${value.artifact.artifactId}.mp4`) {
+    ctx.addIssue({
+      code: "custom",
+      path: ["sandboxPath"],
+      message: "generated-video sandbox path does not match its artifact"
+    });
+  }
+});
+var VideoGenerationTerminalFailureStatus = z2.enum([
+  "provider_failed",
+  "retention_failed",
+  "cancelled_before_submit",
+  "outcome_unknown"
+]);
+var MediaGenerationResult = z2.discriminatedUnion("status", [
+  z2.object({
+    type: z2.literal("media_generation_result"),
+    schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+    status: z2.literal("ready"),
+    operationId: z2.string().uuid(),
+    receipt: GeneratedVideoReceipt
+  }).strict().refine((value) => value.receipt.operationId === value.operationId, {
+    path: ["receipt", "operationId"],
+    message: "terminal receipt must match its operation"
+  }),
+  z2.object({
+    type: z2.literal("media_generation_result"),
+    schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+    status: VideoGenerationTerminalFailureStatus,
+    operationId: z2.string().uuid(),
+    boundedPublicReason: z2.string().min(1).max(1e3)
+  }).strict()
+]);
+var VideoGenerationPublicStatus = z2.enum([
+  "preparing",
+  "prepared",
+  "accepted",
+  "provider_started",
+  "retaining",
+  "completed",
+  "provider_failed",
+  "cancelled_before_submit",
+  "outcome_unknown",
+  "retention_failed"
+]);
+var VideoGenerationOperationSummary = z2.object({
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  operationId: z2.string().uuid(),
+  modelId: z2.string().min(1).max(256),
+  status: VideoGenerationPublicStatus,
+  createdAt: z2.string().datetime({ offset: true }),
+  updatedAt: z2.string().datetime({ offset: true }),
+  terminal: MediaGenerationResult.nullable()
+}).strict();
+var VideoArtifactPlaybackSource = z2.object({
+  schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+  artifactId: z2.string().uuid(),
+  url: z2.string().url().max(8192),
+  expiresAt: z2.string().datetime({ offset: true }),
+  contentType: z2.literal("video/mp4"),
+  sizeBytes: z2.number().int().positive().max(GENERATED_VIDEO_MAX_BYTES),
+  sha256: z2.string().regex(/^[0-9a-f]{64}$/),
+  acceptRanges: z2.literal("bytes")
+}).strict();
+
+export {
+  RETAINED_OUTPUT_MAX_PAGE_BYTES,
+  RETAINED_OUTPUT_DEFAULT_PAGE_BYTES,
+  RETAINED_OUTPUT_RECEIPT_MAX_BYTES,
+  COMPUTER_SCREENSHOT_MAX_BYTES,
+  COMPUTER_SCREENSHOT_MAX_DIMENSION,
+  COMPUTER_SCREENSHOT_MAX_PIXELS,
+  COMPUTER_SCREENSHOT_RETENTION_MS,
+  COMPUTER_SCREENSHOT_WORKSPACE_QUOTA_BYTES,
+  GENERATED_IMAGE_MAX_BYTES,
+  GENERATED_VIDEO_MAX_BYTES,
+  RetainedOutputKind,
+  RetainedOutputUnavailableReason,
+  RetainedArtifactReferenceSchema,
+  RetainedOutputEvidenceSchema,
+  RetainedArtifactUnavailableSchema,
+  RetainedArtifactMetadataSchema,
+  retainedArtifactReferenceFromFile,
+  retainedScreenshotReferenceFromFile,
+  retainedGeneratedImageReferenceFromFile,
+  retainedGeneratedVideoReferenceFromFile,
+  validateRetainedOutputEvidence,
+  retainedOutputUnavailable,
+  resolveRetainedOutputRange,
+  VIDEO_GENERATION_SCHEMA_VERSION,
+  SEEDANCE_2_5_MODEL_ID,
+  VideoGenerationSourceMode,
+  VideoGenerationResolution,
+  VideoGenerationFundingSource,
+  VideoGenerationAspectRatio,
+  VideoGenerationSource,
+  GenerateVideoToolInput,
+  GetVideoGenerationCapabilitiesToolInput,
+  VideoGenerationModelCapability,
+  VideoGenerationCapabilities,
+  VideoGenerationPolicy,
+  UpdateVideoGenerationPolicyRequest,
+  VideoGenerationFundingOption,
+  WorkspaceVideoGenerationSettings,
+  VideoGenerationAcceptedReceipt,
+  GeneratedVideoFacts,
+  GeneratedVideoReceipt,
+  VideoGenerationTerminalFailureStatus,
+  MediaGenerationResult,
+  VideoGenerationPublicStatus,
+  VideoGenerationOperationSummary,
+  VideoArtifactPlaybackSource
+};
+//# sourceMappingURL=chunk-52SGB2QO.js.map