@vanillaskyai/video 0.5.8 → 0.7.0

package/dist/server.js

@@ -1,46 +1,50 @@
 import {
   createTextDeltaVideoPlanner
-} from "./chunk-34O5BY6X.js";
+} from "./chunk-RXHW4EP4.js";
 import {
   createVideo
-} from "./chunk-3OU7HIEB.js";
+} from "./chunk-RE4IMWJR.js";
 import "./chunk-E7CL7UPB.js";
 import {
   BUILTIN_SERVER_TEMPLATE_KIT,
   createServerTemplateRegistry,
   overlayServerTemplateRegistry
-} from "./chunk-FVTMYS6U.js";
+} from "./chunk-RGF452LL.js";
 import {
   createTemplateSceneValidator
 } from "./chunk-LMG3GHLL.js";
 import {
+  decodeVideoSse,
   encodeVideoSseEvent,
+  sanitizeVideoChatMedia,
   videoSseHeaders
-} from "./chunk-ZQQQAAKP.js";
-import "./chunk-FZHMQFG3.js";
+} from "./chunk-2XT4MZ76.js";
+import "./chunk-GAIOHGNR.js";
 import {
   allowedKeys,
+  createClippedVariableWarning,
+  createMediaBudgetWarning,
   jsonValue,
   nonNegativeInteger,
   parseVideoEvent,
   record,
   safePublicDiagnostic,
   string
-} from "./chunk-G66Z5CWR.js";
+} from "./chunk-MMUXVA47.js";
 import {
   MAX_RETAINED_MEDIA_URL_LENGTH
-} from "./chunk-66MNRUCR.js";
+} from "./chunk-2PYO6VAC.js";
 import {
   VIDEO_PROTOCOL_VERSION
 } from "./chunk-AOWSXU2K.js";
 import {
   createTemplateSystemPrompt,
   getStandardMediaResolverContract
-} from "./chunk-EFL34TXF.js";
-import "./chunk-PNS52FL4.js";
-import "./chunk-3O7OMMMF.js";
-import "./chunk-3RV4YKB3.js";
+} from "./chunk-AITKH6QT.js";
+import "./chunk-5SLENAJW.js";
 import "./chunk-352ZZCET.js";
+import "./chunk-JNN3EYVP.js";
+import "./chunk-3O7OMMMF.js";
 import "./chunk-2E6T633S.js";
 import {
   validateBrandInput
@@ -48,6 +52,7 @@ import {
 import "./chunk-73NTSFFI.js";
 
 // src/server/request-validation.ts
+var MAX_GENERATED_LOOK_LENGTH = 1e3;
 function boundedString(value, path) {
   const result = string(value, path);
   if (result.length > MAX_RETAINED_MEDIA_URL_LENGTH) {
@@ -184,7 +189,13 @@ function parseVideoRequest(value) {
   }
   if (input.style != null) {
     const visual = record(input.style, "request.input.style");
-    allowedKeys(visual, ["density", "motion", "textArchetype", "backgroundEffect"], "request.input.style");
+    allowedKeys(visual, ["density", "motion", "textArchetype", "backgroundEffect", "generatedLook"], "request.input.style");
+    if (visual.generatedLook != null) {
+      const look = string(visual.generatedLook, "request.input.style.generatedLook");
+      if (look.length > MAX_GENERATED_LOOK_LENGTH) {
+        throw new Error(`request.input.style.generatedLook must be at most ${MAX_GENERATED_LOOK_LENGTH} characters`);
+      }
+    }
     if (visual.density != null) {
       enumValue(visual.density, ["airy", "normal", "packed"], "airy, normal, or packed", "request.input.style.density");
     }
@@ -472,12 +483,16 @@ async function resolveVariables(options) {
   if (!options.openingReady || !options.resolveMedia || !queryIsBounded(rawQuery)) {
     return fallbackVariables(variables);
   }
+  if (options.claimBudget && !options.claimBudget()) return fallbackVariables(variables);
   let resolved;
   try {
     resolved = await options.resolveMedia(rawQuery, {
       input: options.input,
+      requestId: options.requestId,
+      scene: { ...options.scene, variables },
       templateId: options.templateId,
       preferredType: preferredType(variables.mediaType),
+      generatedLook: options.input.style?.generatedLook,
       signal: options.signal
     });
   } catch (error) {
@@ -528,11 +543,14 @@ async function resolvePartVariables(options) {
     signal: options.signal,
     resolveMedia: options.resolveMedia,
     approveUrl: options.approveUrl,
-    openingReady: options.openingReady
+    openingReady: options.openingReady,
+    claimBudget: options.claimBudget
   };
   if (options.part.type === "scene.add") {
     const variables = await resolveVariables({
       ...shared,
+      requestId: options.requestId,
+      scene: options.part.scene,
       variables: options.part.scene.variables
     });
     return { ...options.part, scene: { ...options.part.scene, variables } };
@@ -540,18 +558,152 @@ async function resolvePartVariables(options) {
   return options.part;
 }
 function createMediaResolvingPlanner(options) {
+  const limit = Math.max(1, Math.floor(options.mediaConcurrency ?? 1));
   return async function* resolveMediaPlan(context) {
+    let remaining = options.maxResolvedMedia;
+    let announced = false;
+    const claimBudget = remaining === void 0 ? void 0 : () => {
+      if (remaining > 0) {
+        remaining = remaining - 1;
+        return true;
+      }
+      if (!announced) {
+        announced = true;
+        options.onBudgetReached?.();
+      }
+      return false;
+    };
+    const resolveOne = (part, openingReady2) => resolvePartVariables({
+      part,
+      requestId: context.request.requestId,
+      templateId: part.type === "scene.add" ? part.scene.templateId : void 0,
+      input: context.request.input,
+      signal: context.signal,
+      templates: options.templates,
+      resolveMedia: options.resolveMedia,
+      approveUrl: options.approveUrl,
+      openingReady: openingReady2 ?? options.isOpeningReady(context.request.input),
+      claimBudget
+    });
+    if (limit === 1) {
+      for await (const part of options.planner(context)) yield await resolveOne(part);
+      return;
+    }
+    let openingReady = options.isOpeningReady(context.request.input);
+    const pending = [];
+    const iterator = options.planner(context)[Symbol.asyncIterator]();
+    let producerDone = false;
+    let producerError;
+    let consumerClosed = false;
+    let wakeConsumer;
+    let wakeProducer;
+    const notifyConsumer = () => {
+      wakeConsumer?.();
+      wakeConsumer = void 0;
+    };
+    const notifyProducer = () => {
+      wakeProducer?.();
+      wakeProducer = void 0;
+    };
+    const waitForItem = () => pending.length > 0 || producerDone ? Promise.resolve() : new Promise((resolve) => {
+      wakeConsumer = resolve;
+    });
+    const waitForSpace = () => pending.length < limit || consumerClosed ? Promise.resolve() : new Promise((resolve) => {
+      wakeProducer = resolve;
+    });
+    const producer = (async () => {
+      try {
+        while (!consumerClosed) {
+          await waitForSpace();
+          if (consumerClosed) break;
+          const next = await iterator.next();
+          if (next.done || consumerClosed) break;
+          const part = next.value;
+          pending.push(resolveOne(part, openingReady).then(
+            (resolved) => ({ part: resolved }),
+            (cause) => ({ cause })
+          ));
+          if (!openingReady && options.marksOpeningReady?.(part) === true) openingReady = true;
+          notifyConsumer();
+        }
+      } catch (cause) {
+        producerError = cause;
+      } finally {
+        producerDone = true;
+        notifyConsumer();
+      }
+    })();
+    try {
+      while (!producerDone || pending.length > 0) {
+        await waitForItem();
+        const task = pending[0];
+        if (!task) continue;
+        const result = await task;
+        pending.shift();
+        notifyProducer();
+        if ("cause" in result) throw result.cause;
+        yield result.part;
+      }
+      await producer;
+      if (producerError !== void 0) throw producerError;
+    } finally {
+      consumerClosed = true;
+      notifyProducer();
+      if (!producerDone) {
+        void Promise.resolve(iterator.return?.()).catch(() => void 0);
+      }
+    }
+  };
+}
+
+// src/server/bound-variables.ts
+var ELLIPSIS = "\u2026";
+function clipText(value, maxLength) {
+  if (value.length <= maxLength) return value;
+  const room = Math.max(1, maxLength - ELLIPSIS.length);
+  const clipped = value.slice(0, room);
+  const lastSpace = clipped.lastIndexOf(" ");
+  const body = lastSpace > room * 0.6 ? clipped.slice(0, lastSpace) : clipped;
+  return `${body.trimEnd()}${ELLIPSIS}`;
+}
+function boundValue(value, schema) {
+  if (!schema) return value;
+  if (typeof value === "string") {
+    return typeof schema.maxLength === "number" ? clipText(value, schema.maxLength) : value;
+  }
+  if (!Array.isArray(value)) return value;
+  const items = typeof schema.maxItems === "number" ? value.slice(0, schema.maxItems) : value;
+  return schema.items ? items.map((item) => boundValue(item, schema.items)) : items;
+}
+function boundSceneVariables(templates, templateId, variables) {
+  const properties = templates.getTemplateMetadata(templateId)?.schema?.properties;
+  if (!properties) return { variables, clipped: [] };
+  const clipped = [];
+  const bounded = Object.fromEntries(Object.entries(variables).map(([name, value]) => {
+    const next = boundValue(value, properties[name]);
+    if (next !== value && JSON.stringify(next) !== JSON.stringify(value)) clipped.push(name);
+    return [name, next];
+  }));
+  return clipped.length > 0 ? { variables: bounded, clipped } : { variables, clipped };
+}
+function createBoundedVariablePlanner(options) {
+  return async function* boundPlan(context) {
     for await (const part of options.planner(context)) {
-      yield await resolvePartVariables({
-        part,
-        templateId: part.type === "scene.add" ? part.scene.templateId : void 0,
-        input: context.request.input,
-        signal: context.signal,
-        templates: options.templates,
-        resolveMedia: options.resolveMedia,
-        approveUrl: options.approveUrl,
-        openingReady: options.isOpeningReady(context.request.input)
-      });
+      if (part.type !== "scene.add") {
+        yield part;
+        continue;
+      }
+      const { variables, clipped } = boundSceneVariables(
+        options.templates,
+        part.scene.templateId,
+        part.scene.variables
+      );
+      if (clipped.length === 0) {
+        yield part;
+        continue;
+      }
+      options.onClipped?.(part.scene.templateId, clipped);
+      yield { ...part, scene: { ...part.scene, variables } };
     }
   };
 }
@@ -571,6 +723,9 @@ function createVideoHandler(options) {
     basePrompt,
     allowMediaUrl,
     resolveMedia,
+    mediaConcurrency,
+    maxResolvedMedia,
+    narrate,
     requireCloser = true,
     ...handlerOptions
   } = options;
@@ -582,7 +737,13 @@ function createVideoHandler(options) {
     approved.add(url);
     approvedMediaUrls.set(input, approved);
   };
-  const planner = createTextDeltaVideoPlanner({ streamText, includeRawProviderData });
+  const planner = createBoundedVariablePlanner({
+    planner: createTextDeltaVideoPlanner({ streamText, includeRawProviderData }),
+    templates,
+    onClipped: (templateId, fields) => void handlerOptions.onWarning?.(
+      createClippedVariableWarning(templateId, fields)
+    )
+  });
   const validateTemplateScene = createTemplateSceneValidator({
     kit: templates,
     allowMediaUrl: (url, context) => approvedMediaUrls.get(context.input)?.has(url) === true || allowMediaUrl?.(url, context) === true
@@ -595,7 +756,23 @@ function createVideoHandler(options) {
       templates,
       resolveMedia,
       approveUrl,
-      isOpeningReady: (input) => openingReadyInputs.has(input)
+      // An opening that was never asked for is ready from the start. The gate
+      // exists so the runtime's opening card is on screen before anything waits
+      // on a provider; `opening: false` says there is no card, the host owns
+      // the wait, and the first scene is then an ordinary scene - which is what
+      // a filmed answer needs, since otherwise its first beat can never be
+      // filmed however much the host is willing to spend.
+      isOpeningReady: (input) => input.opening === false || openingReadyInputs.has(input),
+      mediaConcurrency,
+      maxResolvedMedia,
+      // The ceiling is a spend policy, so it is reported to the application
+      // that set it rather than to the browser, which cannot act on it.
+      onBudgetReached: maxResolvedMedia === void 0 ? void 0 : () => {
+        void handlerOptions.onWarning?.(createMediaBudgetWarning(maxResolvedMedia));
+      },
+      // The same rule the scene validator applies, answered from the part
+      // rather than from what the validator has already seen.
+      marksOpeningReady: (part) => part.type === "scene.add" && templates.getTemplateMetadata(part.scene.templateId)?.jobs?.includes("ask") !== true
     }),
     systemPrompt: ({ request, capabilities: capabilities2 }) => {
       const selectedIds = capabilities2?.templates == null ? void 0 : new Set(capabilities2.templates);
@@ -604,7 +781,13 @@ function createVideoHandler(options) {
         kit: { listTemplateMetadata: () => selectedTemplates },
         basePrompt,
         knowledgeMode: request.input.knowledgeMode,
-        mediaResolverAvailable: resolveMedia != null
+        mediaResolverAvailable: resolveMedia != null,
+        suppliedMediaAvailable: (request.input.suppliedMedia?.length ?? 0) > 0,
+        // The same condition the resolver gate uses. The two have to agree:
+        // letting the first scene resolve media while still telling the
+        // planner not to put any there films nothing.
+        mediaOnFirstScene: request.input.opening === false && resolveMedia != null,
+        narrate
       });
     },
     supportedCapabilities: templates.capabilities,
@@ -618,7 +801,774 @@ function createVideoHandler(options) {
     getTemplatePacing: (templateId) => templates.getTemplateMetadata(templateId)
   });
 }
+
+// src/server/video-chat-prompts.ts
+var RESPONSE_SCENES = 5;
+function createVideoChatResponseInstructions(fullAiVideo, openingAlreadyProvided = false) {
+  return [
+    "The input is a prompt from a user. Respond as a short, coherent video.",
+    "Honor the requested purpose and tone. A story should feel like a story, a recommendation should be useful, an explanation should be clear, and a creative request should not be turned into a lecture.",
+    fullAiVideo ? 'Your first output line must be exactly one host-consumed JSON object: {"type":"video-chat.opening","spokenHook":"6-9 words","mediaKeyword":"2-4 concrete words","firstShot":{"text":"2-7 words","narration":"10-16 spoken words","mediaKeyword":"2-8 concrete words"}}. This leading object is the one explicit exception to the standard plan-part list and is consumed before plan validation.' : openingAlreadyProvided ? "The host has already started the supplied OPENING ALREADY SPOKEN. Start directly with scene.add plan parts; do not emit a video-chat.opening object." : 'Your first output line must be exactly one host-consumed JSON object: {"type":"video-chat.opening","spokenHook":"6-9 words","mediaKeyword":"2-4 concrete words"}. This leading object is the one explicit exception to the standard plan-part list and is consumed before plan validation.',
+    fullAiVideo && openingAlreadyProvided ? "Copy the supplied OPENING ALREADY SPOKEN exactly into spokenHook; do not replace or paraphrase it." : void 0,
+    fullAiVideo ? "The host inserts firstShot as the first body scene and begins generating it immediately. After the opening object, emit exactly four additional scenes that continue it. Never emit, repeat, paraphrase, or replace firstShot as a scene." : `After the opening instruction above, use exactly ${RESPONSE_SCENES} scenes and build a progression that fits the request:`,
+    fullAiVideo ? void 0 : "1. Open directly on the strongest image, action, claim, or idea.",
+    "2. Develop it with new information or movement.",
+    "3. Deepen, complicate, or advance the response.",
+    "4. Deliver the turn, consequence, recommendation, or emotional peak.",
+    "5. Close on the payoff or the one thing worth carrying forward, never a recap.",
+    "No scene may repeat another scene's job. If a scene could be deleted without weakening the response, replace it.",
+    "The prompt is already on screen, so never spend the opening scene restating it.",
+    "If the input includes an OPENING ALREADY SPOKEN transcript, continue directly from that exact hook. Never repeat, paraphrase, contradict, or render it as the first scene's copy.",
+    "For factual requests, distinguish supplied facts from stable general knowledge and never invent statistics, quotations, sources, or personal experience.",
+    "For creative requests, create the requested material directly rather than explaining how one might create it.",
+    fullAiVideo ? "Use the media template for every scene you emit. Every scene must set mediaType to video and carry a mediaKeyword: a concrete, filmable subject, a real object doing a real thing, never a diagram or an abstraction. Never use mediaType gradient and never omit mediaKeyword - a scene without one has nothing to film. If a beat seems too abstract to film, film the closest real thing that shows it." : "Choose the template that fits each beat honestly - a figure belongs in a number scene, an ordered process in steps, a comparison in a chart - rather than repeating one shape. Give any scene that would be stronger over real footage a mediaKeyword: a concrete, filmable subject, a real object doing a real thing, never a diagram or an abstraction. Use the media template for the one or two beats most worth watching happen.",
+    fullAiVideo ? 'Mark the final scene placement:"closer". Use the media template for it, as for every other beat.' : 'Mark the final scene placement:"closer" and use either the milestone or the media template for it. Those are the only two here that may close, so the response must end on one.',
+    "Every scene must carry a timing object, even an empty one. A scene without it fails the whole response.",
+    "Never mention the video, the scenes, or yourself."
+  ].filter((line) => line != null).join("\n");
+}
+var VIDEO_CHAT_NARRATION_PROMPT = [
+  "You narrate a short video response, one scene at a time.",
+  "You are given the scene about to be shown, and the lines already said before it.",
+  "",
+  "Return only the line to say over this scene. No JSON, no quotes, no preamble.",
+  "One sentence, 10-16 words, plain spoken English.",
+  "Say only what this scene contributes. Preserve the requested form: narrate a story as a story, give recommendations directly, and explain only when the user asked for an explanation.",
+  "Never jump ahead to a later scene or repeat a line already said.",
+  "Never read the on-screen text back word for word - the viewer can already see it.",
+  "Continue naturally from the lines before it. Never mention scenes, videos or slides."
+].join("\n");
+var VIDEO_CHAT_SUGGESTIONS_PROMPT = [
+  "You suggest what a user might prompt next after receiving a video response.",
+  'Return JSON only: {"suggestions": [{"prompt": string, "keyword": string}]} with exactly four entries.',
+  "prompt: short and specific to what was created or discussed. Suggestions may continue, remix, deepen, compare, or apply it.",
+  "keyword: two to four words naming something filmable that stands for the prompt, for stock footage search. Concrete subjects only - no abstractions, no text on screen."
+].join("\n");
+function createNarrationUserPrompt(prompt, scene, earlier) {
+  return [
+    `USER PROMPT: ${prompt}`,
+    earlier.length > 0 ? `
+SAID SO FAR:
+${earlier.map((line) => `- ${line}`).join("\n")}` : "",
+    `
+THIS SCENE: [${scene.templateId}] ${JSON.stringify(scene.variables).slice(0, 4e3)}`
+  ].join("\n");
+}
+
+// src/server/create-video-chat-handler.ts
+var DEFAULT_MAX_BODY_BYTES2 = 1024 * 1024;
+var DEFAULT_MAX_AUDIO_BYTES = 8 * 1024 * 1024;
+var MAX_PROMPT_CHARACTERS = 8e3;
+var MAX_CONVERSATION_TURNS = 12;
+var MAX_CONVERSATION_RESPONSE_CHARACTERS = 8e3;
+var VIDEO_CHAT_OPENING_PLAN_TYPE = "video-chat.opening";
+var VIDEO_CHAT_OPENING_EVENT_TYPE = "data.video-chat-opening";
+var PROVIDER_CODE_FENCE = /^```(?:json|ndjson)?$/i;
+var DEFAULT_WELCOME_PROMPTS = [
+  {
+    prompt: "Why does the Moon always show one face?",
+    opening: "The Moon turns, perfectly matching its orbit.",
+    mediaQuery: "full moon night sky"
+  },
+  {
+    prompt: "Tell me a tiny story about a robot growing a garden on Mars",
+    opening: "One patient robot is about to make Mars bloom.",
+    mediaQuery: "robot garden mars"
+  },
+  {
+    prompt: "Recommend a perfect rainy afternoon in Amsterdam",
+    opening: "Rain makes Amsterdam's best afternoons feel even warmer.",
+    mediaQuery: "Amsterdam rain cafe"
+  },
+  {
+    prompt: "Pitch a playful ad for a coffee mug that never spills",
+    opening: "This mug makes gravity look completely optional.",
+    mediaQuery: "coffee mug desk"
+  }
+];
+function jsonError2(status, code, message, headers) {
+  return Response.json({ error: { code, message } }, { status, headers });
+}
+function allowedKeys2(value, allowed, label) {
+  const permitted = new Set(allowed);
+  const unexpected = Object.keys(value).find((key) => !permitted.has(key));
+  if (unexpected) throw new Error(`${label}.${unexpected} is not supported`);
+}
+function record2(value, label) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object`);
+  }
+  return value;
+}
+function boundedString2(value, label, maximum = MAX_PROMPT_CHARACTERS) {
+  if (typeof value !== "string" || !value.trim()) throw new Error(`${label} must be a non-empty string`);
+  const trimmed = value.trim();
+  if ([...trimmed].length > maximum) throw new Error(`${label} is too long`);
+  return trimmed;
+}
+function parseResponseRequest(value) {
+  const body = record2(value, "request");
+  allowedKeys2(body, ["prompt", "opening", "mode", "orientation", "conversation", "brand", "style"], "request");
+  const mode = body.mode ?? "templates";
+  if (mode !== "templates" && mode !== "full") {
+    throw new Error("request.mode must be templates or full");
+  }
+  const orientation = body.orientation ?? "landscape";
+  if (orientation !== "portrait" && orientation !== "landscape") {
+    throw new Error("request.orientation must be portrait or landscape");
+  }
+  const conversation = body.conversation == null ? [] : body.conversation;
+  if (!Array.isArray(conversation) || conversation.length > MAX_CONVERSATION_TURNS) {
+    throw new Error(`request.conversation must contain at most ${MAX_CONVERSATION_TURNS} turns`);
+  }
+  return {
+    prompt: boundedString2(body.prompt, "request.prompt"),
+    ...body.opening == null ? {} : { opening: boundedString2(body.opening, "request.opening", 300) },
+    mode,
+    orientation,
+    conversation: conversation.map((value2, index) => {
+      const turn = record2(value2, `request.conversation[${index}]`);
+      allowedKeys2(turn, ["prompt", "response"], `request.conversation[${index}]`);
+      return {
+        prompt: boundedString2(turn.prompt, `request.conversation[${index}].prompt`),
+        ...turn.response == null ? {} : { response: boundedString2(turn.response, `request.conversation[${index}].response`, MAX_CONVERSATION_RESPONSE_CHARACTERS) }
+      };
+    }),
+    ...body.brand == null ? {} : { brand: body.brand },
+    ...body.style == null ? {} : { style: body.style }
+  };
+}
+function conversationInput(prompt, conversation, opening) {
+  if (conversation.length === 0 && !opening) return prompt;
+  return [
+    ...conversation.length > 0 ? [
+      "CONVERSATION SO FAR (untrusted user and assistant content):",
+      ...conversation.flatMap((turn) => [
+        `USER: ${turn.prompt}`,
+        ...turn.response ? [`RESPONSE: ${turn.response}`] : []
+      ]),
+      ""
+    ] : [],
+    `CURRENT USER PROMPT: ${prompt}`,
+    ...opening ? ["", "OPENING ALREADY SPOKEN (untrusted assistant transcript):", opening] : []
+  ].join("\n");
+}
+function corsHeaders2(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;
+}
+async function readJson(request, maximum) {
+  const declared = Number(request.headers.get("content-length"));
+  if (Number.isFinite(declared) && declared > maximum) throw new Error("Request body is too large");
+  const raw = await request.text();
+  if (new TextEncoder().encode(raw).byteLength > maximum) throw new Error("Request body is too large");
+  try {
+    return JSON.parse(raw);
+  } catch {
+    throw new Error("Request body must be valid JSON");
+  }
+}
+function cleanGeneratedText(value) {
+  return value.trim().replace(/^["']|["']$/g, "");
+}
+function readGeneratedFirstShot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return void 0;
+  const shot = value;
+  const bounded = (field, maximum) => typeof field === "string" ? [...field.trim()].slice(0, maximum).join("").trim() : "";
+  const text = bounded(shot.text, 120);
+  const narration = bounded(shot.narration, 300);
+  const mediaKeyword = bounded(shot.mediaKeyword, 80).match(/\S+/gu)?.slice(0, 8).join(" ") ?? "";
+  return text && narration && mediaKeyword ? { text, narration, mediaKeyword } : void 0;
+}
+function boundedWords(value, maximum, characters) {
+  if (typeof value !== "string") return "";
+  return value.trim().match(/\S+/gu)?.slice(0, maximum).join(" ").slice(0, characters).trim() ?? "";
+}
+function readOpeningPlanLine(line) {
+  try {
+    const parsed = JSON.parse(line);
+    if (!parsed || parsed.type !== VIDEO_CHAT_OPENING_PLAN_TYPE) return void 0;
+    const firstShot = readGeneratedFirstShot(parsed.firstShot);
+    return {
+      line: boundedWords(parsed.spokenHook, 9, 300),
+      keyword: boundedWords(parsed.mediaKeyword, 4, 80),
+      ...firstShot ? { firstShot } : {}
+    };
+  } catch {
+    return void 0;
+  }
+}
+function reservedFirstScene(requestId, firstShot) {
+  return {
+    type: "scene.add",
+    scene: {
+      id: `${requestId}-first-shot`,
+      templateId: "media",
+      variables: {
+        texts: firstShot.text,
+        mediaType: "video",
+        mediaKeyword: firstShot.mediaKeyword
+      },
+      timing: { fixedDuration: 5 },
+      narration: firstShot.narration
+    }
+  };
+}
+function replaceTextStream(source, textStream) {
+  const enriched = typeof source === "object" && source != null && "textStream" in source ? source : void 0;
+  if (!enriched) return textStream;
+  const wrapper = { textStream };
+  return new Proxy(wrapper, {
+    get(target, property, receiver) {
+      if (property === "textStream") return Reflect.get(target, property, receiver);
+      return Reflect.get(enriched, property, enriched);
+    }
+  });
+}
+function createOpeningChannel(initial) {
+  if (initial) return { ready: Promise.resolve(initial), publish: () => void 0 };
+  let published = false;
+  let resolve;
+  const ready = new Promise((settle) => {
+    resolve = settle;
+  });
+  return {
+    ready,
+    publish(value) {
+      if (published) return;
+      published = true;
+      resolve(value);
+    }
+  };
+}
+function interceptOpeningPlan(source, options) {
+  const enriched = typeof source === "object" && source != null && "textStream" in source ? source : void 0;
+  const upstream = enriched?.textStream ?? source;
+  const textStream = (async function* () {
+    let buffer = "";
+    let decided = !options.expectOpening;
+    try {
+      for await (const delta of upstream) {
+        if (typeof delta !== "string") throw new Error("The LLM adapter returned a non-text delta");
+        buffer += delta;
+        let newline = buffer.indexOf("\n");
+        while (newline >= 0) {
+          const rawLine = buffer.slice(0, newline);
+          buffer = buffer.slice(newline + 1);
+          const line = rawLine.trim();
+          if (!decided && line && !PROVIDER_CODE_FENCE.test(line)) {
+            const opening = readOpeningPlanLine(line);
+            decided = true;
+            if (opening) {
+              if (!options.openingProvided) options.publish(opening.line ? opening : void 0);
+              if (options.fullAiVideo && opening.firstShot) {
+                yield `${JSON.stringify(reservedFirstScene(options.requestId, opening.firstShot))}
+`;
+              }
+              newline = buffer.indexOf("\n");
+              continue;
+            }
+            options.publish(void 0);
+          }
+          yield `${rawLine}
+`;
+          newline = buffer.indexOf("\n");
+        }
+      }
+      if (buffer) {
+        const line = buffer.trim();
+        if (!decided && line && !PROVIDER_CODE_FENCE.test(line)) {
+          const opening = readOpeningPlanLine(line);
+          decided = true;
+          if (opening) {
+            if (!options.openingProvided) options.publish(opening.line ? opening : void 0);
+            if (options.fullAiVideo && opening.firstShot) {
+              yield `${JSON.stringify(reservedFirstScene(options.requestId, opening.firstShot))}
+`;
+            }
+          } else {
+            options.publish(void 0);
+            yield buffer;
+          }
+        } else {
+          yield buffer;
+        }
+      }
+    } finally {
+      options.publish(void 0);
+    }
+  })();
+  return replaceTextStream(source, textStream);
+}
+function resequenceEvent(event, sequence) {
+  return {
+    ...event,
+    sequence,
+    eventId: `${event.runId}:${sequence}`
+  };
+}
+function streamVideoChatOpening(response, openingReady) {
+  if (!response.body || !response.headers.get("content-type")?.includes("text/event-stream")) return response;
+  const events = decodeVideoSse(response.body)[Symbol.asyncIterator]();
+  const encoded = (async function* () {
+    try {
+      const first = await events.next();
+      if (first.done) return;
+      let sequence = 0;
+      const started = first.value.type === "response.start" ? {
+        ...first.value,
+        data: {
+          ...first.value.data,
+          capabilities: {
+            ...first.value.data.capabilities,
+            extensions: Array.from(/* @__PURE__ */ new Set([
+              ...first.value.data.capabilities?.extensions ?? [],
+              VIDEO_CHAT_OPENING_EVENT_TYPE
+            ]))
+          }
+        }
+      } : first.value;
+      yield encodeVideoSseEvent(resequenceEvent(started, sequence++));
+      const nextEvent = events.next();
+      const opening = await openingReady;
+      if (opening?.line) {
+        yield encodeVideoSseEvent({
+          protocolVersion: first.value.protocolVersion,
+          runId: first.value.runId,
+          sequence,
+          eventId: `${first.value.runId}:${sequence}`,
+          type: VIDEO_CHAT_OPENING_EVENT_TYPE,
+          data: {
+            line: opening.line,
+            ...opening.keyword ? { keyword: opening.keyword } : {}
+          }
+        });
+        sequence += 1;
+      }
+      let next = await nextEvent;
+      while (!next.done) {
+        yield encodeVideoSseEvent(resequenceEvent(next.value, sequence++));
+        next = await events.next();
+      }
+    } finally {
+      await events.return?.(void 0);
+    }
+  })();
+  const encoder = new TextEncoder();
+  const iterator = encoded[Symbol.asyncIterator]();
+  let completed = false;
+  const body = new ReadableStream({
+    async pull(controller) {
+      try {
+        const next = await iterator.next();
+        if (next.done) {
+          if (!completed) controller.enqueue(encoder.encode("data: [DONE]\n\n"));
+          completed = true;
+          controller.close();
+          return;
+        }
+        controller.enqueue(encoder.encode(next.value));
+      } catch (cause) {
+        completed = true;
+        controller.error(cause);
+      }
+    },
+    async cancel() {
+      completed = true;
+      await iterator.return?.();
+    }
+  });
+  return new Response(body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers: response.headers
+  });
+}
+function readSuggestionSubjects(text) {
+  const opening = text.indexOf("{");
+  const closing = text.lastIndexOf("}");
+  if (opening < 0 || closing <= opening) return [];
+  const parsed = JSON.parse(text.slice(opening, closing + 1));
+  return (Array.isArray(parsed.suggestions) ? parsed.suggestions : []).flatMap((entry) => {
+    const item = entry;
+    const prompt = typeof item.prompt === "string" ? item.prompt.trim() : "";
+    const keyword = typeof item.keyword === "string" ? item.keyword.trim() : "";
+    return prompt ? [{ prompt: prompt.slice(0, 300), keyword: keyword.slice(0, 80) }] : [];
+  }).slice(0, 4);
+}
+function audioBody(value) {
+  const source = value instanceof Uint8Array ? value : new Uint8Array(value);
+  return Uint8Array.from(source).buffer;
+}
+var VideoChatProviderError = class extends Error {
+  constructor(task) {
+    super(`Video chat ${task} provider failed`);
+    this.task = task;
+  }
+  task;
+};
+function createVideoChatHandler(options) {
+  if (!options || typeof options.streamText !== "function" || typeof options.generateText !== "function") {
+    throw new Error("createVideoChatHandler requires streamText and generateText");
+  }
+  if (options.authorize !== "none" && typeof options.authorize !== "function") {
+    throw new Error('createVideoChatHandler requires authorize or authorize: "none"');
+  }
+  const reportError = (cause) => {
+    const error = cause instanceof Error ? cause : new Error(String(cause));
+    try {
+      void Promise.resolve(options.onError?.(error)).catch(() => void 0);
+    } catch {
+    }
+  };
+  const {
+    authorize,
+    generateText,
+    generateSpeech,
+    transcribe,
+    searchMedia,
+    generateVideo,
+    instructions,
+    welcome: welcomeOptions,
+    maxAudioBytes = DEFAULT_MAX_AUDIO_BYTES,
+    maxBodyBytes = DEFAULT_MAX_BODY_BYTES2,
+    allowedOrigins,
+    allowCredentials,
+    mediaConcurrency = 5,
+    ...videoOptions
+  } = options;
+  if (!Number.isFinite(maxAudioBytes) || maxAudioBytes <= 0) throw new Error("maxAudioBytes must be positive");
+  if (!Number.isFinite(maxBodyBytes) || maxBodyBytes <= 0) throw new Error("maxBodyBytes must be positive");
+  const capabilities2 = {
+    templates: true,
+    generatedSpeech: generateSpeech != null,
+    generatedVideo: generateVideo != null,
+    stockMedia: searchMedia != null,
+    transcription: transcribe != null,
+    modes: generateVideo ? ["templates", "full"] : ["templates"]
+  };
+  const welcomePrompts = (welcomeOptions?.prompts ?? DEFAULT_WELCOME_PROMPTS).slice(0, 4);
+  const heroQuery = welcomeOptions?.heroQuery ?? "underwater ocean sunlight";
+  let welcomeResponse;
+  let requestSequence = 0;
+  const responseHandler = (requestedMode, requestId, openingProvided, openingChannel) => {
+    const mode = requestedMode !== "templates" && !generateVideo ? "templates" : requestedMode;
+    const fullAiVideo = mode === "full";
+    const selectedResolver = fullAiVideo ? generateVideo : searchMedia;
+    const resolveSelected = selectedResolver ? (query, context) => selectedResolver(query, {
+      purpose: "response",
+      orientation: context.input.orientation ?? "landscape",
+      generatedLook: context.generatedLook,
+      signal: context.signal,
+      requestId: context.requestId,
+      scene: context.scene,
+      templateId: context.templateId,
+      preferredType: context.preferredType
+    }) : void 0;
+    const handler = createVideoHandler({
+      ...videoOptions,
+      streamText: (context) => {
+        try {
+          return interceptOpeningPlan(videoOptions.streamText(context), {
+            expectOpening: fullAiVideo || !openingProvided,
+            openingProvided,
+            requestId,
+            fullAiVideo,
+            publish: openingChannel.publish
+          });
+        } catch (cause) {
+          openingChannel.publish(void 0);
+          throw cause;
+        }
+      },
+      authorize: "none",
+      allowedOrigins,
+      allowCredentials,
+      maxBodyBytes,
+      mediaConcurrency,
+      basePrompt: [createVideoChatResponseInstructions(fullAiVideo, openingProvided), instructions?.trim()].filter(Boolean).join("\n\nAPPLICATION GUIDANCE\n"),
+      narrate: true,
+      ...fullAiVideo ? { maxResolvedMedia: 5 } : {},
+      resolveMedia: resolveSelected
+    });
+    return handler;
+  };
+  const callText = async (task, systemPrompt, userPrompt, maxOutputTokens, signal) => {
+    try {
+      return cleanGeneratedText(await generateText({ task, systemPrompt, userPrompt, maxOutputTokens, signal }));
+    } catch (cause) {
+      reportError(cause);
+      throw new VideoChatProviderError(task);
+    }
+  };
+  return async function handleVideoChat(request) {
+    const url = new URL(request.url);
+    const action = url.searchParams.get("action");
+    const origin = request.headers.get("origin");
+    const headers = corsHeaders2(origin, allowedOrigins, allowCredentials);
+    if (request.method === "OPTIONS") {
+      if (origin && allowedOrigins && !allowedOrigins.includes(origin)) {
+        return jsonError2(403, "origin_forbidden", "Origin is not allowed", headers);
+      }
+      headers.set("access-control-allow-methods", "GET, POST, OPTIONS");
+      headers.set("access-control-allow-headers", "Authorization, Content-Type");
+      return new Response(null, { status: 204, headers });
+    }
+    if (origin && allowedOrigins && !allowedOrigins.includes(origin)) {
+      return jsonError2(403, "origin_forbidden", "Origin is not allowed", headers);
+    }
+    if (authorize !== "none") {
+      let authorized = false;
+      try {
+        authorized = await authorize(request);
+      } catch (cause) {
+        reportError(cause);
+        authorized = false;
+      }
+      if (!authorized) return jsonError2(401, "unauthorized", "Authentication required", headers);
+    }
+    if (action === "capabilities") {
+      if (request.method !== "GET") return jsonError2(405, "method_not_allowed", "Use GET", headers);
+      return Response.json(capabilities2, { headers });
+    }
+    if (action === "welcome") {
+      if (request.method !== "GET") return jsonError2(405, "method_not_allowed", "Use GET", headers);
+      if (welcomeResponse) return Response.json(welcomeResponse, { headers });
+      const resolvedWelcome = await (async () => {
+        let failed = false;
+        const mediaResolver = searchMedia;
+        const resolve = async (query) => {
+          if (!mediaResolver || !query) return null;
+          const signal = AbortSignal.any([request.signal, AbortSignal.timeout(1e4)]);
+          try {
+            const raw = await Promise.resolve().then(() => mediaResolver(query, {
+              purpose: "welcome",
+              orientation: "landscape",
+              signal
+            }));
+            const media = sanitizeVideoChatMedia(raw);
+            if (signal.aborted || raw != null && !media) failed = true;
+            return media;
+          } catch (cause) {
+            failed = true;
+            if (!request.signal.aborted) reportError(cause);
+            return null;
+          }
+        };
+        const [hero, ...cards] = await Promise.all([
+          resolve(heroQuery),
+          ...welcomePrompts.map((entry) => resolve(entry.mediaQuery))
+        ]);
+        return {
+          cacheable: !failed,
+          body: {
+            hero,
+            cards: welcomePrompts.map((entry, index) => ({
+              prompt: entry.prompt,
+              ...entry.opening ? { opening: entry.opening } : {},
+              media: cards[index] ?? null
+            }))
+          }
+        };
+      })();
+      if (!request.signal.aborted && resolvedWelcome.cacheable) welcomeResponse = resolvedWelcome.body;
+      return Response.json(resolvedWelcome.body, { headers });
+    }
+    if (request.method !== "POST") return jsonError2(405, "method_not_allowed", "Use POST", headers);
+    if (action === "transcription") {
+      if (!transcribe) return jsonError2(404, "capability_unavailable", "Transcription is not configured", headers);
+      const declared = Number(request.headers.get("content-length"));
+      if (Number.isFinite(declared) && declared > maxAudioBytes) {
+        return jsonError2(413, "body_too_large", "The recording is too large", headers);
+      }
+      const audio = new Uint8Array(await request.arrayBuffer());
+      if (audio.byteLength === 0) return jsonError2(400, "empty_audio", "No audio was provided", headers);
+      if (audio.byteLength > maxAudioBytes) return jsonError2(413, "body_too_large", "The recording is too large", headers);
+      try {
+        const text = await transcribe({
+          audio,
+          mediaType: request.headers.get("content-type") || "audio/webm",
+          signal: request.signal
+        });
+        return Response.json({ text: text.trim() }, { headers });
+      } catch (cause) {
+        reportError(cause);
+        return jsonError2(502, "transcription_failed", "The recording could not be transcribed", headers);
+      }
+    }
+    let body;
+    try {
+      body = await readJson(request, maxBodyBytes);
+    } catch (cause) {
+      return jsonError2(
+        cause instanceof Error && cause.message.includes("too large") ? 413 : 400,
+        "invalid_body",
+        cause instanceof Error ? cause.message : "Request body is invalid",
+        headers
+      );
+    }
+    if (action === "response") {
+      let input;
+      try {
+        input = parseResponseRequest(body);
+      } catch (cause) {
+        return jsonError2(400, "invalid_request", cause instanceof Error ? cause.message : "Request is invalid", headers);
+      }
+      const mode = input.mode !== "templates" && !generateVideo ? "templates" : input.mode;
+      const fullAiVideo = mode === "full";
+      const requestId = `video-chat-${Date.now()}-${requestSequence += 1}`;
+      const openingChannel = createOpeningChannel(input.opening ? { line: input.opening, keyword: "" } : void 0);
+      const forwardedHeaders = new Headers(request.headers);
+      forwardedHeaders.delete("content-length");
+      const videoRequest = new Request(request.url, {
+        method: "POST",
+        headers: forwardedHeaders,
+        signal: request.signal,
+        body: JSON.stringify({
+          protocolVersion: "0.5",
+          requestId,
+          ...fullAiVideo ? { capabilities: { templates: ["media"] } } : {},
+          input: {
+            input: conversationInput(input.prompt, input.conversation, input.opening),
+            knowledgeMode: "general",
+            opening: false,
+            orientation: input.orientation,
+            maxDurationSec: 40,
+            ...input.brand ? { brand: input.brand } : {},
+            style: {
+              density: "airy",
+              motion: "calm",
+              textArchetype: "cinematic",
+              ...input.style
+            }
+          }
+        })
+      });
+      const response = await responseHandler(
+        mode,
+        requestId,
+        input.opening != null,
+        openingChannel
+      )(videoRequest);
+      return streamVideoChatOpening(response, openingChannel.ready);
+    }
+    try {
+      if (action === "opening-media") {
+        const value = record2(body, "request");
+        allowedKeys2(value, ["keyword", "orientation"], "request");
+        const keyword = boundedString2(value.keyword, "request.keyword", 80);
+        const orientation = value.orientation ?? "landscape";
+        if (orientation !== "portrait" && orientation !== "landscape") {
+          throw new Error("request.orientation must be portrait or landscape");
+        }
+        if (!searchMedia) return Response.json({ media: null }, { headers });
+        try {
+          const raw = await Promise.resolve().then(() => searchMedia(keyword, {
+            purpose: "response",
+            orientation,
+            signal: request.signal
+          }));
+          return Response.json({ media: sanitizeVideoChatMedia(raw) }, { headers });
+        } catch (cause) {
+          if (!request.signal.aborted) reportError(cause);
+          return Response.json({ media: null }, { headers });
+        }
+      }
+      if (action === "narration") {
+        const value = record2(body, "request");
+        allowedKeys2(value, ["prompt", "scene", "earlier"], "request");
+        const prompt = boundedString2(value.prompt, "request.prompt");
+        const scene = record2(value.scene, "request.scene");
+        if (typeof scene.templateId !== "string" || !scene.variables || typeof scene.variables !== "object") {
+          throw new Error("request.scene is invalid");
+        }
+        const earlier = Array.isArray(value.earlier) ? value.earlier.slice(-4).map((line2, index) => boundedString2(line2, `request.earlier[${index}]`, 2e3)) : [];
+        const line = await callText(
+          "narration",
+          VIDEO_CHAT_NARRATION_PROMPT,
+          createNarrationUserPrompt(prompt, scene, earlier),
+          256,
+          request.signal
+        );
+        return Response.json({ line }, { headers });
+      }
+      if (action === "suggestions") {
+        const value = record2(body, "request");
+        allowedKeys2(value, ["prompt", "lines"], "request");
+        const prompt = boundedString2(value.prompt, "request.prompt");
+        const lines = Array.isArray(value.lines) ? value.lines.slice(-8).map((line, index) => boundedString2(line, `request.lines[${index}]`, 2e3)) : [];
+        try {
+          const text = await callText(
+            "suggestions",
+            VIDEO_CHAT_SUGGESTIONS_PROMPT,
+            `USER PROMPT: ${prompt}
+
+VIDEO RESPONSE:
+${lines.join("\n")}`,
+            512,
+            request.signal
+          );
+          const subjects = readSuggestionSubjects(text);
+          const mediaResolver = searchMedia;
+          const media = await Promise.all(subjects.map(async (subject) => {
+            if (!mediaResolver || !subject.keyword) return null;
+            try {
+              const raw = await Promise.resolve().then(() => mediaResolver(subject.keyword, {
+                purpose: "suggestion",
+                orientation: "landscape",
+                signal: request.signal
+              }));
+              return sanitizeVideoChatMedia(raw);
+            } catch (cause) {
+              if (!request.signal.aborted) reportError(cause);
+              return null;
+            }
+          }));
+          return Response.json({
+            suggestions: subjects.map((subject, index) => ({
+              prompt: subject.prompt,
+              media: media[index] ?? null
+            }))
+          }, { headers });
+        } catch (cause) {
+          if (!(cause instanceof VideoChatProviderError)) reportError(cause);
+          return Response.json({ suggestions: [] }, { headers });
+        }
+      }
+      if (action === "speech") {
+        if (!generateSpeech) return new Response(null, { status: 204, headers });
+        const value = record2(body, "request");
+        allowedKeys2(value, ["text"], "request");
+        const text = boundedString2(value.text, "request.text", 4e3);
+        try {
+          const result = await generateSpeech({ text, signal: request.signal });
+          return new Response(audioBody(result.audio), {
+            headers: {
+              ...Object.fromEntries(headers),
+              "content-type": result.mediaType || "audio/mpeg",
+              "cache-control": "no-store"
+            }
+          });
+        } catch (cause) {
+          reportError(cause);
+          return jsonError2(502, "speech_failed", "Speech could not be generated", headers);
+        }
+      }
+    } catch (cause) {
+      if (cause instanceof VideoChatProviderError) {
+        return jsonError2(502, "text_generation_failed", "Text could not be generated", headers);
+      }
+      return jsonError2(400, "invalid_request", cause instanceof Error ? cause.message : "Request is invalid", headers);
+    }
+    return jsonError2(404, "unknown_action", "Video chat action was not found", headers);
+  };
+}
 export {
   createServerTemplateRegistry,
+  createVideoChatHandler,
   createVideoHandler
 };