@opengeni/contracts 3.1.0-canary.2 → 3.1.2

package/dist/chunk-EFZYKUE2.js

@@ -0,0 +1,767 @@
+import {
+  defineSchema
+} from "./chunk-56SNIMDO.js";
+
+// 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 = /* @__PURE__ */ defineSchema(
+  () => z.enum([
+    "tool_result",
+    "assistant_completion",
+    "internal_update",
+    "event_media",
+    "computer_screenshot",
+    "browser_screenshot",
+    "generated_image",
+    "generated_video",
+    "file"
+  ])
+);
+var RetainedOutputUnavailableReason = /* @__PURE__ */ defineSchema(
+  () => z.enum([
+    "not_retained",
+    "pending",
+    "failed",
+    "expired",
+    "deleted",
+    "missing_storage",
+    "storage_write_failed",
+    "quota_exceeded",
+    "invalid_content",
+    "oversized",
+    "unsupported"
+  ])
+);
+var RetainedOutputUnavailableEvidenceSchema = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    available: z.literal(false),
+    reason: RetainedOutputUnavailableReason
+  }).strict()
+);
+var RetainedArtifactReferenceSchema = /* @__PURE__ */ defineSchema(
+  () => 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 === "browser_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" || value.kind === "browser_screenshot") {
+      if (value.retention.policy !== "session_screenshot" || !sessionMatch) {
+        ctx.addIssue({
+          code: "custom",
+          path: ["retention"],
+          message: "session 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 = /* @__PURE__ */ defineSchema(
+  () => z.discriminatedUnion("available", [
+    RetainedOutputUnavailableEvidenceSchema,
+    RetainedArtifactReferenceSchema
+  ])
+);
+var RetainedArtifactUnavailableSchema = /* @__PURE__ */ defineSchema(
+  () => z.object({
+    available: z.literal(false),
+    artifactId: z.string().regex(LOWERCASE_UUID),
+    reason: RetainedOutputUnavailableReason
+  }).strict()
+);
+var RetainedArtifactMetadataSchema = /* @__PURE__ */ defineSchema(
+  () => z.union([RetainedArtifactReferenceSchema, RetainedArtifactUnavailableSchema])
+);
+function retainedSessionScreenshotKindFromObjectKey(objectKey) {
+  const match = /^workspaces\/[0-9a-f-]+\/files\/[0-9a-f-]+\/retained\/(session-image|computer-screenshot|screenshot|browser-screenshot)\.(png|jpg|webp)$/.exec(
+    objectKey
+  );
+  if (!match) return null;
+  return match[1] === "browser-screenshot" ? "browser_screenshot" : "computer_screenshot";
+}
+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: file.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 GROK_IMAGINE_VIDEO_1_5_MODEL_ID = "xai/grok-imagine-video-1.5";
+var VideoGenerationSourceMode = /* @__PURE__ */ defineSchema(
+  () => z2.enum(["text", "first_frame", "first_and_last_frames", "image_reference", "video_reference"])
+);
+var VideoGenerationResolution = /* @__PURE__ */ defineSchema(
+  () => z2.enum(["480p", "720p"])
+);
+var VideoGenerationFundingSource = /* @__PURE__ */ defineSchema(
+  () => z2.enum(["opengeni_credits", "workspace_gateway", "supergrok_subscription"])
+);
+var VideoGenerationAspectRatio = /* @__PURE__ */ defineSchema(
+  () => z2.enum(["16:9", "4:3", "1:1", "3:4", "9:16", "21:9", "adaptive"])
+);
+var SandboxVideoReferencePath = /* @__PURE__ */ defineSchema(
+  () => z2.string().min(1).max(1024).refine((value) => value.startsWith("/workspace/"), {
+    message: "video references must use an absolute /workspace path"
+  })
+);
+var VideoGenerationSource = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => z2.object({}).strict()
+);
+var VideoGenerationModelCapability = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => z2.object({
+    schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+    policy: VideoGenerationPolicy,
+    fundingOptions: z2.array(VideoGenerationFundingOption).length(3),
+    availableModels: z2.array(VideoGenerationModelCapability).max(16),
+    capabilities: VideoGenerationCapabilities.nullable()
+  }).strict().superRefine((value, ctx) => {
+    if (new Set(value.fundingOptions.map((option) => option.source)).size !== 3 || !value.fundingOptions.some((option) => option.source === "opengeni_credits") || !value.fundingOptions.some((option) => option.source === "workspace_gateway") || !value.fundingOptions.some((option) => option.source === "supergrok_subscription")) {
+      ctx.addIssue({
+        code: "custom",
+        path: ["fundingOptions"],
+        message: "all 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 = /* @__PURE__ */ defineSchema(
+  () => z2.object({
+    schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+    status: z2.literal("accepted"),
+    operationId: z2.string().uuid()
+  }).strict()
+);
+var VideoGenerationRejectedCode = /* @__PURE__ */ defineSchema(
+  () => z2.enum([
+    "invalid_reference_path",
+    "reference_not_stable",
+    "reference_too_large",
+    "reference_media_type_mismatch",
+    "unsupported_reference_media"
+  ])
+);
+var VideoGenerationRejectedResult = /* @__PURE__ */ defineSchema(
+  () => z2.object({
+    schemaVersion: z2.literal(VIDEO_GENERATION_SCHEMA_VERSION),
+    status: z2.literal("rejected"),
+    code: VideoGenerationRejectedCode,
+    message: z2.string().min(1).max(512),
+    operationCreated: z2.literal(false)
+  }).strict()
+);
+var VideoGenerationToolResult = /* @__PURE__ */ defineSchema(
+  () => z2.discriminatedUnion("status", [VideoGenerationAcceptedReceipt, VideoGenerationRejectedResult])
+);
+var GeneratedVideoFacts = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => z2.enum(["provider_failed", "retention_failed", "cancelled_before_submit", "outcome_unknown"])
+);
+var MediaGenerationResult = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => z2.enum([
+    "preparing",
+    "prepared",
+    "accepted",
+    "provider_started",
+    "retaining",
+    "completed",
+    "provider_failed",
+    "cancelled_before_submit",
+    "outcome_unknown",
+    "retention_failed"
+  ])
+);
+var VideoGenerationOperationSummary = /* @__PURE__ */ defineSchema(
+  () => 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 = /* @__PURE__ */ defineSchema(
+  () => 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,
+  retainedSessionScreenshotKindFromObjectKey,
+  retainedArtifactReferenceFromFile,
+  retainedScreenshotReferenceFromFile,
+  retainedGeneratedImageReferenceFromFile,
+  retainedGeneratedVideoReferenceFromFile,
+  validateRetainedOutputEvidence,
+  retainedOutputUnavailable,
+  resolveRetainedOutputRange,
+  VIDEO_GENERATION_SCHEMA_VERSION,
+  SEEDANCE_2_5_MODEL_ID,
+  GROK_IMAGINE_VIDEO_1_5_MODEL_ID,
+  VideoGenerationSourceMode,
+  VideoGenerationResolution,
+  VideoGenerationFundingSource,
+  VideoGenerationAspectRatio,
+  VideoGenerationSource,
+  GenerateVideoToolInput,
+  GetVideoGenerationCapabilitiesToolInput,
+  VideoGenerationModelCapability,
+  VideoGenerationCapabilities,
+  VideoGenerationPolicy,
+  UpdateVideoGenerationPolicyRequest,
+  VideoGenerationFundingOption,
+  WorkspaceVideoGenerationSettings,
+  VideoGenerationAcceptedReceipt,
+  VideoGenerationRejectedCode,
+  VideoGenerationRejectedResult,
+  VideoGenerationToolResult,
+  GeneratedVideoFacts,
+  GeneratedVideoReceipt,
+  VideoGenerationTerminalFailureStatus,
+  MediaGenerationResult,
+  VideoGenerationPublicStatus,
+  VideoGenerationOperationSummary,
+  VideoArtifactPlaybackSource
+};
+//# sourceMappingURL=chunk-EFZYKUE2.js.map