@vanillaskyai/video 0.1.0

package/dist/server.js

@@ -0,0 +1,498 @@
+import {
+  createTextDeltaVideoPlanner
+} from "./chunk-GRMUV7QY.js";
+import {
+  createVideo
+} from "./chunk-IXCUY3B3.js";
+import "./chunk-E7CL7UPB.js";
+import {
+  BUILTIN_SERVER_TEMPLATE_KIT,
+  createServerTemplateRegistry,
+  overlayServerTemplateRegistry
+} from "./chunk-A2X45FET.js";
+import {
+  createTemplateSceneValidator
+} from "./chunk-LMG3GHLL.js";
+import {
+  encodeVideoSseEvent,
+  videoSseHeaders
+} from "./chunk-OOPIETLW.js";
+import "./chunk-ABPKM4GK.js";
+import {
+  parseVideoEvent,
+  safePublicDiagnostic
+} from "./chunk-ERY4S6QV.js";
+import {
+  MAX_RETAINED_MEDIA_URL_LENGTH
+} from "./chunk-GHJEAP4O.js";
+import {
+  VIDEO_PROTOCOL_VERSION
+} from "./chunk-EE6PK6XC.js";
+import {
+  createTemplateSystemPrompt
+} from "./chunk-YC5MFXA5.js";
+import {
+  DEFAULT_VIDEO_SYSTEM_PROMPT
+} from "./chunk-FQ47WXAJ.js";
+import "./chunk-EVG2ZYIY.js";
+import "./chunk-352ZZCET.js";
+import "./chunk-CHLGW22F.js";
+import "./chunk-2E6T633S.js";
+import {
+  validateBrandInput
+} from "./chunk-XGRA2MUV.js";
+import "./chunk-73NTSFFI.js";
+
+// src/server/request-validation.ts
+var DANGEROUS_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function record(value, path) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${path} must be an object`);
+  }
+  return value;
+}
+function allowedKeys(value, allowed, path) {
+  const permitted = new Set(allowed);
+  for (const key of Object.keys(value)) {
+    if (!permitted.has(key)) throw new Error(`${path} contains unsupported field ${key}`);
+  }
+}
+function string(value, path) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${path} must be a non-empty string`);
+  return value;
+}
+function boundedString(value, path) {
+  const result = string(value, path);
+  if (result.length > MAX_RETAINED_MEDIA_URL_LENGTH) {
+    throw new Error(`${path} must be at most ${MAX_RETAINED_MEDIA_URL_LENGTH} characters`);
+  }
+  return result;
+}
+function nonNegativeInteger(value, path) {
+  if (!Number.isInteger(value) || Number(value) < 0) {
+    throw new Error(`${path} must be a non-negative integer`);
+  }
+  return Number(value);
+}
+function numberBetween(value, minimum, maximum, path) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < minimum || value > maximum) {
+    throw new Error(`${path} must be a number between ${minimum} and ${maximum}`);
+  }
+  return value;
+}
+function enumValue(value, allowed, description, path) {
+  if (typeof value !== "string" || !allowed.includes(value)) {
+    throw new Error(`${path} must be ${description}`);
+  }
+  return value;
+}
+function jsonValue(value, path, seen = /* @__PURE__ */ new Set()) {
+  if (value == null || typeof value === "string" || typeof value === "boolean") return;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new Error(`${path} must be finite`);
+    return;
+  }
+  if (typeof value !== "object" || seen.has(value)) throw new Error(`${path} must be JSON-serializable`);
+  seen.add(value);
+  if (Array.isArray(value)) {
+    value.forEach((item, index) => jsonValue(item, `${path}[${index}]`, seen));
+  } else {
+    for (const [key, child] of Object.entries(value)) {
+      if (DANGEROUS_KEYS.has(key)) throw new Error(`${path} contains unsupported field ${key}`);
+      jsonValue(child, `${path}.${key}`, seen);
+    }
+  }
+  seen.delete(value);
+}
+function capabilities(value, path) {
+  const result = record(value, path);
+  allowedKeys(result, ["templates", "extensions"], path);
+  for (const key of ["templates", "extensions"]) {
+    const entries = result[key];
+    if (entries == null) continue;
+    if (!Array.isArray(entries)) throw new Error(`${path}.${key} must be an array`);
+    entries.forEach((entry, index) => {
+      const item = string(entry, `${path}.${key}[${index}]`);
+      if (key === "extensions" && (!item.startsWith("data.") || item === "data.")) {
+        throw new Error(`${path}.${key}[${index}] must use the data.* namespace`);
+      }
+    });
+  }
+  return result;
+}
+function parseVideoRequest(value) {
+  const request = record(value, "request");
+  allowedKeys(request, ["protocolVersion", "requestId", "input", "capabilities", "resume"], "request");
+  if (request.protocolVersion !== VIDEO_PROTOCOL_VERSION) {
+    throw new Error(`request.protocolVersion must be ${VIDEO_PROTOCOL_VERSION}`);
+  }
+  string(request.requestId, "request.requestId");
+  const input = record(request.input, "request.input");
+  allowedKeys(input, [
+    "input",
+    "instructions",
+    "maxDurationSec",
+    "orientation",
+    "style",
+    "opening",
+    "brand",
+    "personalization",
+    "suppliedMedia",
+    "audio"
+  ], "request.input");
+  string(input.input, "request.input.input");
+  if (input.instructions != null) string(input.instructions, "request.input.instructions");
+  if (input.maxDurationSec != null) {
+    numberBetween(input.maxDurationSec, 5, 120, "request.input.maxDurationSec");
+  }
+  if (input.orientation != null) {
+    enumValue(
+      input.orientation,
+      ["portrait", "landscape"],
+      "portrait or landscape",
+      "request.input.orientation"
+    );
+  }
+  if (input.opening != null) string(input.opening, "request.input.opening");
+  if (input.audio != null && input.audio !== false) {
+    const soundtrack = record(input.audio, "request.input.audio");
+    allowedKeys(soundtrack, ["src"], "request.input.audio");
+    boundedString(soundtrack.src, "request.input.audio.src");
+  }
+  if (input.suppliedMedia != null) {
+    if (!Array.isArray(input.suppliedMedia)) throw new Error("request.input.suppliedMedia must be an array");
+    input.suppliedMedia.forEach((entry, index) => {
+      const path = `request.input.suppliedMedia[${index}]`;
+      const media = record(entry, path);
+      allowedKeys(media, [
+        "id",
+        "url",
+        "type",
+        "description",
+        "mimeType",
+        "posterUrl",
+        "focalPoint",
+        "treatment",
+        "role"
+      ], path);
+      string(media.id, `${path}.id`);
+      boundedString(media.url, `${path}.url`);
+      if (media.posterUrl != null) boundedString(media.posterUrl, `${path}.posterUrl`);
+      if (media.type !== "image" && media.type !== "video") {
+        throw new Error(`${path}.type must be image or video`);
+      }
+      for (const field of ["description", "mimeType"]) {
+        if (media[field] != null) string(media[field], `${path}.${field}`);
+      }
+      if (media.focalPoint != null) {
+        enumValue(
+          media.focalPoint,
+          ["center", "top", "bottom", "left", "right"],
+          "center, top, bottom, left, or right",
+          `${path}.focalPoint`
+        );
+      }
+      if (media.treatment != null) {
+        enumValue(
+          media.treatment,
+          ["subtle", "cinematic", "text-safe"],
+          "subtle, cinematic, or text-safe",
+          `${path}.treatment`
+        );
+      }
+      if (media.role != null) {
+        enumValue(
+          media.role,
+          ["product", "proof", "background", "logo"],
+          "product, proof, background, or logo",
+          `${path}.role`
+        );
+      }
+    });
+  }
+  if (input.style != null) {
+    const visual = record(input.style, "request.input.style");
+    allowedKeys(visual, ["density", "motion", "textArchetype", "backgroundEffect"], "request.input.style");
+    if (visual.density != null) {
+      enumValue(visual.density, ["airy", "normal", "packed"], "airy, normal, or packed", "request.input.style.density");
+    }
+    if (visual.motion != null) {
+      enumValue(visual.motion, ["calm", "normal", "punchy"], "calm, normal, or punchy", "request.input.style.motion");
+    }
+    if (visual.textArchetype != null) {
+      enumValue(
+        visual.textArchetype,
+        ["subtle", "typewriter", "wordStagger", "slam", "cinematic", "heroWord"],
+        "subtle, typewriter, wordStagger, slam, cinematic, or heroWord",
+        "request.input.style.textArchetype"
+      );
+    }
+    if (visual.backgroundEffect != null) {
+      enumValue(
+        visual.backgroundEffect,
+        ["static", "slow-zoom-in", "slow-zoom-out", "ken-burns", "drift", "pulse", "breathe", "slow-tilt", "camera-shake"],
+        "static, slow-zoom-in, slow-zoom-out, ken-burns, drift, pulse, breathe, slow-tilt, or camera-shake",
+        "request.input.style.backgroundEffect"
+      );
+    }
+  }
+  if (input.brand != null) validateBrandInput(input.brand, "request.input.brand");
+  jsonValue(input, "request.input");
+  if (request.capabilities != null) capabilities(request.capabilities, "request.capabilities");
+  if (request.resume != null) {
+    const resume = record(request.resume, "request.resume");
+    allowedKeys(resume, ["runId", "afterSequence"], "request.resume");
+    string(resume.runId, "request.resume.runId");
+    nonNegativeInteger(resume.afterSequence, "request.resume.afterSequence");
+  }
+  return request;
+}
+
+// src/server/video-stream-handler.ts
+var DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+var DEFAULT_HEARTBEAT_MS = 15e3;
+var SECRET_FIELD = /(?:api[_-]?key|authorization|admin[_-]?session|secret(?:[_-]?key)?)$/i;
+function jsonError(status, code, message, headers) {
+  return Response.json({ error: { code, message } }, { status, headers });
+}
+function corsHeaders(origin, allowedOrigins, allowCredentials = false) {
+  const headers = new Headers({ "Cache-Control": "no-store", Vary: "Origin" });
+  if (origin && allowedOrigins?.includes(origin)) {
+    headers.set("Access-Control-Allow-Origin", origin);
+    if (allowCredentials) headers.set("Access-Control-Allow-Credentials", "true");
+  }
+  return headers;
+}
+function containsSecretField(value, seen = /* @__PURE__ */ new Set()) {
+  if (!value || typeof value !== "object" || seen.has(value)) return false;
+  seen.add(value);
+  if (Array.isArray(value)) return value.some((item) => containsSecretField(item, seen));
+  return Object.entries(value).some(([key, child]) => SECRET_FIELD.test(key) || containsSecretField(child, seen));
+}
+function errorFrom(cause) {
+  return cause instanceof Error ? cause : new Error(String(cause));
+}
+function defaultRunId(request) {
+  return `run-${request.requestId}`;
+}
+function negotiateCapabilities(requested, supported) {
+  if (!supported) return requested;
+  if (!requested) return supported;
+  const intersect = (left, right) => {
+    if (right == null) return left;
+    if (left == null) return right;
+    const permitted = new Set(right);
+    return left.filter((value) => permitted.has(value));
+  };
+  return {
+    ...requested.templates != null || supported.templates != null ? { templates: intersect(requested.templates, supported.templates) } : {},
+    ...requested.extensions != null || supported.extensions != null ? { extensions: intersect(requested.extensions, supported.extensions) } : {}
+  };
+}
+function createVideoStreamHandler(options) {
+  if (!options || typeof options.generate !== "function") {
+    throw new Error("createVideoStreamHandler requires a planner");
+  }
+  if (options.authorize !== "none" && typeof options.authorize !== "function") {
+    throw new Error('createVideoStreamHandler requires authorize or authorize: "none"');
+  }
+  const maxBodyBytes = options.maxBodyBytes ?? DEFAULT_MAX_BODY_BYTES;
+  if (!Number.isFinite(maxBodyBytes) || maxBodyBytes <= 0) throw new Error("maxBodyBytes must be positive");
+  const heartbeatMs = options.heartbeatMs === false ? false : options.heartbeatMs ?? DEFAULT_HEARTBEAT_MS;
+  if (heartbeatMs !== false && (!Number.isFinite(heartbeatMs) || heartbeatMs <= 0)) {
+    throw new Error("heartbeatMs must be positive or false");
+  }
+  const reportError = (error) => {
+    try {
+      void Promise.resolve(options.onError?.(error)).catch(() => void 0);
+    } catch {
+    }
+  };
+  return async function handle(request) {
+    const origin = request.headers.get("origin");
+    const baseHeaders = corsHeaders(origin, options.allowedOrigins, options.allowCredentials);
+    if (request.method === "OPTIONS") {
+      if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) {
+        return jsonError(403, "origin_forbidden", "Origin is not allowed", baseHeaders);
+      }
+      baseHeaders.set("Access-Control-Allow-Methods", "POST, OPTIONS");
+      baseHeaders.set("Access-Control-Allow-Headers", "Authorization, Content-Type, Last-Event-ID");
+      return new Response(null, { status: 204, headers: baseHeaders });
+    }
+    if (request.method !== "POST") {
+      baseHeaders.set("Allow", "POST, OPTIONS");
+      return jsonError(405, "method_not_allowed", "Use POST", baseHeaders);
+    }
+    if (origin && options.allowedOrigins && !options.allowedOrigins.includes(origin)) {
+      return jsonError(403, "origin_forbidden", "Origin is not allowed", baseHeaders);
+    }
+    if (options.authorize !== "none") {
+      let authorized = false;
+      try {
+        authorized = await options.authorize(request);
+      } catch (cause) {
+        reportError(errorFrom(cause));
+      }
+      if (!authorized) return jsonError(401, "unauthorized", "Authentication required", baseHeaders);
+    }
+    const declaredLength = Number(request.headers.get("content-length"));
+    if (Number.isFinite(declaredLength) && declaredLength > maxBodyBytes) {
+      return jsonError(413, "body_too_large", "Request body is too large", baseHeaders);
+    }
+    let rawBody;
+    try {
+      rawBody = await request.text();
+    } catch {
+      return jsonError(400, "invalid_body", "Request body could not be read", baseHeaders);
+    }
+    if (new TextEncoder().encode(rawBody).byteLength > maxBodyBytes) {
+      return jsonError(413, "body_too_large", "Request body is too large", baseHeaders);
+    }
+    let body;
+    try {
+      body = JSON.parse(rawBody);
+    } catch {
+      return jsonError(400, "invalid_json", "Request body must be valid JSON", baseHeaders);
+    }
+    if (containsSecretField(body)) {
+      return jsonError(
+        400,
+        "secret_field",
+        "Provider credentials belong in server environment variables, not the request body",
+        baseHeaders
+      );
+    }
+    let motionRequest;
+    try {
+      motionRequest = parseVideoRequest(body);
+    } catch (cause) {
+      return jsonError(
+        400,
+        "invalid_request",
+        safePublicDiagnostic(errorFrom(cause).message, "Video request is invalid"),
+        baseHeaders
+      );
+    }
+    if (motionRequest.resume) {
+      const expectedLastEventId = `${motionRequest.resume.runId}:${motionRequest.resume.afterSequence}`;
+      if (request.headers.get("last-event-id") !== expectedLastEventId) {
+        return jsonError(400, "invalid_cursor", "Last-Event-ID does not match the resume cursor", baseHeaders);
+      }
+      if (!options.replay) {
+        return jsonError(409, "resume_unavailable", "This endpoint does not have replay storage configured", baseHeaders);
+      }
+    }
+    const negotiatedCapabilities = negotiateCapabilities(
+      motionRequest.capabilities,
+      options.supportedCapabilities
+    );
+    const systemPrompt = typeof options.systemPrompt === "function" ? options.systemPrompt({ request: motionRequest, capabilities: negotiatedCapabilities }) : options.systemPrompt;
+    let run;
+    if (!motionRequest.resume) {
+      try {
+        run = createVideo(motionRequest.input, {
+          requestId: motionRequest.requestId,
+          runId: (options.createRunId ?? defaultRunId)(motionRequest),
+          capabilities: negotiatedCapabilities,
+          validateScene: options.validateScene,
+          getTemplatePacing: options.getTemplatePacing,
+          invalidPartBehavior: options.invalidPartBehavior ?? "drop",
+          onError: options.onError,
+          onWarning: options.onWarning,
+          onComplete: options.onComplete,
+          systemPrompt: systemPrompt ?? DEFAULT_VIDEO_SYSTEM_PROMPT,
+          selectAudio: options.selectAudio,
+          snapshotRetention: options.snapshotRetention,
+          signal: request.signal,
+          generate: options.generate
+        });
+      } catch (cause) {
+        reportError(errorFrom(cause));
+        return jsonError(400, "invalid_input", "Video input is invalid", baseHeaders);
+      }
+    }
+    const source = motionRequest.resume ? options.replay(motionRequest.resume, { request: motionRequest, signal: request.signal }) : run.stream;
+    const iterator = source[Symbol.asyncIterator]();
+    let replaySequence = motionRequest.resume?.afterSequence;
+    const encoder = new TextEncoder();
+    let heartbeat;
+    let closed = false;
+    const stream = new ReadableStream({
+      start(controller) {
+        if (heartbeatMs !== false) {
+          heartbeat = setInterval(() => {
+            if (!closed && (controller.desiredSize ?? 0) > 0) {
+              controller.enqueue(encoder.encode(": ping\n\n"));
+            }
+          }, heartbeatMs);
+        }
+      },
+      async pull(controller) {
+        const next = await iterator.next();
+        if (next.done) {
+          closed = true;
+          if (heartbeat) clearInterval(heartbeat);
+          controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          controller.close();
+          return;
+        }
+        const event = parseVideoEvent(next.value);
+        if (motionRequest.resume) {
+          if (event.runId !== motionRequest.resume.runId || event.sequence !== replaySequence + 1) {
+            throw new Error("Replay storage returned an event outside the requested cursor");
+          }
+          replaySequence = event.sequence;
+        }
+        controller.enqueue(encoder.encode(encodeVideoSseEvent(event)));
+      },
+      async cancel(reason) {
+        closed = true;
+        if (heartbeat) clearInterval(heartbeat);
+        run?.abort(typeof reason === "string" ? reason : "client disconnected");
+        await iterator.return?.();
+      }
+    });
+    return new Response(stream, {
+      status: 200,
+      headers: videoSseHeaders(baseHeaders)
+    });
+  };
+}
+
+// src/server/create-video-handler.ts
+function createVideoHandler(options) {
+  if (options?.authorize !== "none" && typeof options?.authorize !== "function") {
+    throw new Error('createVideoHandler requires authorize or authorize: "none"');
+  }
+  if (options && "mediaPolicy" in options) {
+    throw new Error("mediaPolicy is not supported; resolve media before generation and pass it through VideoInput.suppliedMedia");
+  }
+  const {
+    templates: configuredTemplates,
+    streamText,
+    includeRawProviderData,
+    basePrompt,
+    allowMediaUrl,
+    ...handlerOptions
+  } = options;
+  const templates = configuredTemplates ? overlayServerTemplateRegistry(BUILTIN_SERVER_TEMPLATE_KIT, configuredTemplates) : BUILTIN_SERVER_TEMPLATE_KIT;
+  return createVideoStreamHandler({
+    ...handlerOptions,
+    generate: createTextDeltaVideoPlanner({ streamText, includeRawProviderData }),
+    systemPrompt: ({ capabilities: capabilities2 }) => {
+      const selectedIds = capabilities2?.templates == null ? void 0 : new Set(capabilities2.templates);
+      const selectedTemplates = selectedIds == null ? templates.listTemplateMetadata() : templates.listTemplateMetadata().filter(({ id }) => selectedIds.has(id));
+      return createTemplateSystemPrompt({
+        kit: { listTemplateMetadata: () => selectedTemplates },
+        basePrompt
+      });
+    },
+    supportedCapabilities: templates.capabilities,
+    validateScene: createTemplateSceneValidator({ kit: templates, allowMediaUrl }),
+    getTemplatePacing: (templateId) => templates.getTemplateMetadata(templateId)
+  });
+}
+export {
+  createServerTemplateRegistry,
+  createVideoHandler
+};