@vanillaskyai/video 0.10.2 → 0.10.4

package/dist/server.js

@@ -6,6 +6,7 @@ import {
   invokeIsolated
 } from "./chunk-5BSJLT6H.js";
 import {
+  attachGenerationLifecycleSink,
   getGenerationLifecycleSink
 } from "./chunk-E7CL7UPB.js";
 import {
@@ -55,69 +56,6 @@ import "./chunk-3O7OMMMF.js";
 import "./chunk-2E6T633S.js";
 import "./chunk-73NTSFFI.js";
 
-// src/server/opening-continuity.ts
-function continueAfterOpening(narration, earlier) {
-  const words = (value) => Array.from(value.matchAll(/[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)*/gu));
-  let remaining = narration;
-  for (const previous of [...earlier].reverse()) {
-    const known = words(previous), current = words(remaining);
-    if (known.length < 5 || known.length > current.length) continue;
-    if (!known.every((word, index) => word[0].toLowerCase() === current[index][0].toLowerCase())) continue;
-    if (known.length === current.length) return "";
-    const last = current[known.length - 1];
-    const suffix = remaining.slice(last.index + last[0].length);
-    const boundary = suffix.match(/^[”"'’\])]*[.!?…]+[\s”"'’\])]*/u);
-    if (boundary) remaining = suffix.slice(boundary[0].length).trim();
-  }
-  return remaining;
-}
-function createOpeningContinuation(initialOpening) {
-  const earlier = initialOpening ? [initialOpening] : [];
-  let bodyStarted = false;
-  const copy = (authored, narration) => {
-    if (continueAfterOpening(authored, earlier) !== "") return authored;
-    const next = continueAfterOpening(narration, earlier).trim();
-    return next && [...next].length <= 65 && /[.!?…][”"’')\]]*$/u.test(next) ? next : authored;
-  };
-  return {
-    copy,
-    remember(line) {
-      if (line.trim()) earlier.push(line);
-    },
-    narration(line) {
-      return continueAfterOpening(line, earlier);
-    },
-    line(rawLine) {
-      if (bodyStarted || earlier.length === 0) return rawLine;
-      let part;
-      try {
-        part = JSON.parse(rawLine);
-      } catch {
-        return rawLine;
-      }
-      if (!part || part.type !== "scene.add" || part.placement === "closer") return rawLine;
-      const scene = part.scene;
-      if (!scene) return rawLine;
-      if (typeof scene.narration !== "string") {
-        bodyStarted = true;
-        return rawLine;
-      }
-      const narration = continueAfterOpening(scene.narration, earlier);
-      if (!narration && scene.templateId === "cinemaMedia") return null;
-      const variables = scene.variables;
-      if (!narration && scene.templateId === "chapterTitle" && typeof variables?.title === "string" && !continueAfterOpening(variables.title, earlier)) return null;
-      bodyStarted = true;
-      if (!narration) return rawLine;
-      const field = scene.templateId === "cinemaMedia" ? "fallbackText" : scene.templateId === "chapterTitle" ? "title" : void 0;
-      const authored = field && variables?.[field];
-      const updated = typeof authored === "string" ? copy(authored, narration) : void 0;
-      const copyChanged = typeof authored === "string" && updated !== authored;
-      if (narration === scene.narration && !copyChanged) return rawLine;
-      return JSON.stringify({ ...part, scene: { ...scene, narration, ...copyChanged ? { variables: { ...variables, [field]: updated } } : {} } });
-    }
-  };
-}
-
 // src/server/request-validation.ts
 var MAX_GENERATED_LOOK_LENGTH = 1e3;
 function boundedString(value, path) {
@@ -935,23 +873,268 @@ function createVideoHandler(options) {
   });
 }
 
+// src/server/opening-continuity.ts
+function continueAfterOpening(narration, earlier) {
+  const words = (value) => Array.from(value.matchAll(/[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)*/gu));
+  let remaining = narration;
+  for (const previous of [...earlier].reverse()) {
+    const known = words(previous), current = words(remaining);
+    if (known.length < 5 || known.length > current.length) continue;
+    if (!known.every((word, index) => word[0].toLowerCase() === current[index][0].toLowerCase())) continue;
+    if (known.length === current.length) return "";
+    const last = current[known.length - 1];
+    const suffix = remaining.slice(last.index + last[0].length);
+    const boundary = suffix.match(/^[”"'’\])]*[.!?…]+[\s”"'’\])]*/u);
+    if (boundary) remaining = suffix.slice(boundary[0].length).trim();
+  }
+  return remaining;
+}
+
+// src/server/chat-shot-planner.ts
+var object = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+function text(value, maximum) {
+  return typeof value === "string" && value.trim().length <= maximum ? value.trim() : "";
+}
+function readShot(value, clipDurationSec) {
+  const item = object(value);
+  const narration = text(item?.narration, 2e3);
+  if (!narration) throw new Error("Chat shot requires bounded authored narration");
+  return {
+    narration,
+    title: text(item?.title, 65) || text(item?.subject, 65) || "The next step",
+    subject: text(item?.subject, 80),
+    action: text(item?.action, 600),
+    durationSec: typeof item?.durationSec === "number" && Number.isFinite(item.durationSec) ? Math.min(clipDurationSec, Math.max(2, item.durationSec)) : clipDurationSec,
+    continuity: item?.continuity === "continue" ? "continue" : "cut"
+  };
+}
+function replaceStream(source, textStream) {
+  if (!(typeof source === "object" && source != null && "textStream" in source)) return textStream;
+  return new Proxy({ textStream }, {
+    get(target, key, receiver) {
+      return key === "textStream" ? Reflect.get(target, key, receiver) : Reflect.get(source, key, source);
+    }
+  });
+}
+function createChatShotPlanner(options) {
+  const clipDurationSec = options.generatedClipDurationSec ?? 5;
+  const incomplete = /* @__PURE__ */ new WeakSet();
+  const planner = createTextDeltaVideoPlanner({
+    includeRawProviderData: options.includeRawProviderData,
+    streamText(context) {
+      const providerContext = { ...context, userPrompt: [
+        `Create a complete answer within ${context.request.input.maxDurationSec ?? 40} seconds. Each generated clip has at most ${clipDurationSec} seconds; give each spoken beat room to finish.`,
+        `Orientation: ${context.request.input.orientation ?? "landscape"}.`,
+        "USER REQUEST AND CONVERSATION",
+        context.request.input.input
+      ].join("\n") };
+      const sink = getGenerationLifecycleSink(context);
+      if (sink) attachGenerationLifecycleSink(providerContext, sink);
+      let source;
+      try {
+        source = options.streamText(providerContext);
+      } catch (cause) {
+        options.publishOpening(void 0);
+        throw cause;
+      }
+      const upstream = typeof source === "object" && source != null && "textStream" in source ? source.textStream : source;
+      const translated = (async function* () {
+        let brief, buffer = "", index = 0, bodyDuration = 0, lastNarration = "";
+        let firstBody = true;
+        const reject = (cause) => {
+          incomplete.add(context);
+          const error = cause instanceof Error ? cause : new Error(String(cause));
+          if (!getGenerationLifecycleSink(context)?.rejectPart?.(error)) throw error;
+        };
+        const scenePart = (shot, closer = false) => {
+          let narration = shot.narration;
+          if (firstBody && !closer) narration = continueAfterOpening(narration, [options.openingLine ?? brief?.opening ?? ""]);
+          firstBody = false;
+          lastNarration = narration;
+          return { type: "scene.add", ...closer ? { placement: "closer" } : {}, scene: {
+            id: `${context.request.requestId}-shot-${++index}`,
+            templateId: "cinemaMedia",
+            variables: { fallbackText: shot.title, mediaType: "video", mediaKeyword: shot.subject, shotDirection: [
+              brief?.visualDirection,
+              shot.action,
+              shot.continuity === "continue" ? "Continue the established subject, setting and action consistently." : "A deliberate new shot; choose framing that reveals this beat.",
+              "Silent illustration. No spoken dialogue, voiceover, written words or subtitles in the generated footage."
+            ].filter(Boolean).join("\n") },
+            narration,
+            timing: { fixedDuration: shot.durationSec }
+          } };
+        };
+        const line = (raw) => {
+          const trimmed = raw.trim();
+          if (!trimmed || /^```(?:json|ndjson)?$/i.test(trimmed)) return;
+          const part = object(JSON.parse(trimmed));
+          if (part?.type === "answer") {
+            if (brief) throw new Error("Chat answer brief was emitted more than once");
+            brief = { opening: text(part.opening, 300), subject: text(part.subject, 80), visualDirection: text(part.visualDirection, 600), development: text(part.development, 2e3) };
+            if (part.ending) {
+              try {
+                brief.ending = readShot(part.ending, clipDurationSec);
+              } catch (cause) {
+                reject(cause);
+              }
+            }
+            options.publishOpening(brief.opening ? { line: brief.opening, keyword: brief.subject } : void 0);
+            return;
+          }
+          if (part?.type !== "shot") throw new Error("Chat plan requires an answer brief followed by shots");
+          if (!brief) throw new Error("Chat shot arrived before its answer brief");
+          const shot = readShot(part, clipDurationSec);
+          if (shot.narration === brief.ending?.narration) return;
+          if (firstBody && !continueAfterOpening(shot.narration, [options.openingLine ?? brief.opening])) return;
+          const budget = (context.request.input.maxDurationSec ?? 40) - (brief.ending?.durationSec ?? clipDurationSec);
+          if (bodyDuration + shot.durationSec > budget) throw new Error("Chat shot exceeds the answer duration budget");
+          bodyDuration += shot.durationSec;
+          return scenePart(shot);
+        };
+        try {
+          for await (const delta of upstream) {
+            context.signal.throwIfAborted();
+            if (typeof delta !== "string") throw new Error("The LLM adapter returned a non-text delta");
+            buffer += delta;
+            if (buffer.length > 32768) throw new Error("Chat plan line exceeds the bounded stream limit");
+            let newline = buffer.indexOf("\n");
+            while (newline >= 0) {
+              const raw = buffer.slice(0, newline);
+              buffer = buffer.slice(newline + 1);
+              try {
+                const part = line(raw);
+                if (part) yield JSON.stringify(part) + "\n";
+              } catch (cause) {
+                reject(cause);
+              }
+              newline = buffer.indexOf("\n");
+            }
+          }
+          if (buffer.trim()) {
+            try {
+              const part = line(buffer);
+              if (part) yield JSON.stringify(part) + "\n";
+            } catch (cause) {
+              reject(cause);
+            }
+          }
+          if (brief?.development && bodyDuration === 0) incomplete.add(context);
+          if (brief?.ending && brief.ending.narration !== lastNarration) yield JSON.stringify(scenePart(brief.ending, true)) + "\n";
+          else if (!brief?.ending) incomplete.add(context);
+        } catch (cause) {
+          if (!context.signal.aborted && brief?.ending && brief.ending.narration !== lastNarration) {
+            yield JSON.stringify(scenePart(brief.ending, true)) + "\n";
+          }
+          throw cause;
+        } finally {
+          options.publishOpening(void 0);
+        }
+      })();
+      return replaceStream(source, translated);
+    }
+  });
+  return async function* (context) {
+    let completed = false;
+    for await (const part of resolveShots(planner(context), context, options)) {
+      if (part.type === "plan.complete") completed = true;
+      yield part;
+    }
+    if (!completed) {
+      if (incomplete.has(context)) getGenerationLifecycleSink(context)?.reportWarning?.({ code: "plan_incomplete", category: "provider", message: "Some authored answer content could not be completed.", recoverable: true });
+      yield { type: "plan.complete", ...incomplete.has(context) ? { finishReason: "other" } : {} };
+    }
+  };
+}
+async function* resolveShots(parts, context, options) {
+  const queue = [];
+  const iterator = parts[Symbol.asyncIterator]();
+  const limit = Number.isFinite(options.mediaConcurrency) ? Math.min(5, Math.max(1, Math.floor(options.mediaConcurrency))) : 1;
+  let done = false, closed = false, producerError;
+  let notify, space;
+  const resolve = async (part) => {
+    if (part.type !== "scene.add") return part;
+    options.prepareScene?.({ sceneId: part.scene.id, narration: part.scene.narration ?? "" });
+    const { mediaKeyword } = part.scene.variables;
+    let media;
+    if (typeof mediaKeyword === "string" && mediaKeyword && options.resolveMedia) media = await options.resolveMedia(mediaKeyword, {
+      input: context.request.input,
+      requestId: context.request.requestId,
+      scene: part.scene,
+      templateId: "cinemaMedia",
+      preferredType: "video",
+      generatedLook: context.request.input.style?.generatedLook,
+      signal: context.signal
+    });
+    context.signal.throwIfAborted();
+    if (!media) getGenerationLifecycleSink(context)?.reportWarning?.({ code: "provider_warning", category: "provider", message: MEDIA_RECOVERY_NOTICE, recoverable: true });
+    const title = part.scene.variables.fallbackText;
+    const scene = media ? { ...part.scene, variables: { fallbackText: title, mediaType: media.type === "image" ? "photo" : "video", mediaUrl: media.url, ...media.posterUrl ? { mediaPoster: media.posterUrl } : {} } } : { ...part.scene, templateId: "chapterTitle", variables: { title } };
+    return { ...part, scene };
+  };
+  const producer = (async () => {
+    try {
+      while (!closed) {
+        if (queue.length >= limit) await new Promise((r) => {
+          space = r;
+        });
+        if (closed) break;
+        const next = await iterator.next();
+        if (next.done) break;
+        queue.push(resolve(next.value).then((part) => ({ part }), (error) => ({ error })));
+        notify?.();
+        notify = void 0;
+      }
+    } catch (error) {
+      producerError = error;
+    } finally {
+      done = true;
+      notify?.();
+      notify = void 0;
+    }
+  })();
+  try {
+    while (!done || queue.length) {
+      if (!queue.length) await new Promise((r) => {
+        notify = r;
+      });
+      const item = queue[0];
+      if (!item) continue;
+      const result = await item;
+      queue.shift();
+      space?.();
+      space = void 0;
+      if ("error" in result) throw result.error;
+      yield result.part;
+    }
+    if (producerError) throw producerError;
+  } finally {
+    closed = true;
+    space?.();
+    void iterator.return?.().catch(() => void 0);
+    void producer;
+  }
+}
+
 // src/server/video-chat-prompts.ts
-function createVideoChatResponseInstructions(generatedVideoAvailable, openingAlreadyProvided = false, maxGeneratedVideos = 5) {
+function createVideoChatResponseInstructions(generatedVideoAvailable, openingAlreadyProvided = false, maxGeneratedVideos = 5, clipDurationSec = 5, mode = "cinematic") {
   return [
-    "Respond as a coherent short film: establish, develop, then land a useful or emotional payoff. Match the user's requested form.",
-    generatedVideoAvailable ? 'First emit one host-consumed opening JSON object: {"type":"video-chat.opening","spokenHook":"6-9 words","mediaKeyword":"literal subject","firstShot":{"text":"short grounded fallback","narration":"a natural spoken beat advancing the hook","mediaKeyword":"2-8 concrete words","shotDirection":"optional framing and action"}}. Include firstShot only when a distinctive illustrative shot serves the story; omit it for an abstract explanation best opened with graphics. When present, the host inserts it once and begins generation immediately; do not emit it again.' : openingAlreadyProvided ? "Start directly with scene.add; the opening has already been supplied." : 'First emit {"type":"video-chat.opening","spokenHook":"6-9 words","mediaKeyword":"literal subject"}. This is host-consumed, not a scene.',
-    openingAlreadyProvided ? "Preserve the supplied opening exactly; continue it without repeating its words or claim." : void 0,
-    "The spokenHook is already heard before the first scene. Start firstShot.narration with the next fact, cause, action or consequence; never restate the hook. The first ordinary scene must then advance beyond firstShot rather than repeat its narration or opening claim. If firstShot is omitted, that first scene must advance the hook directly. firstShot.text, fallbackText and chapter titles must also express that new beat, not reuse the hook or prior shot copy; write a concise visual anchor of roughly 2\u20136 words within the schema budget, never a full narration sentence, clipped statistic or qualifying clause.",
-    "The optional firstShot has five seconds of footage: give its narration one brief sentence of roughly 8\u201310 spoken words that fits that budget. Carry further explanation, actions or dialogue in later scenes instead of squeezing the answer into the first shot. This limit applies only to firstShot; pace later narration to its own scene.",
-    "Continue with only as many scenes as the story and duration need. Never pad to a fixed count. Every emitted scene carries narration beside variables and timing; no additional narration request should be needed.",
-    "Make most of the film relevant footage: use full-bleed media for action, subjects and atmosphere, with graphics only to clarify a specific relationship or piece of evidence. Maintain consistent setting, lighting and subject while varying shot scale. Avoid unrelated cinematic montages.",
-    "Use the installed catalog: ordered events, comparison, exact quote, one key figure, chapter or a message only when its narrative job fits. For an ordinary explanation, roughly one graphic-led explanatory beat per 30 seconds is a starting point, plus a brief chapter opening when needed. Let other intents use the visual form they need. Do not place graphic beats consecutively unless no honest relevant media is available. Give media-capable graphics a relevant background when it supports the meaning; keep black when no matching media exists. Do not force every template into a video or use lists of bullets.",
-    `At most ${generatedVideoAvailable ? maxGeneratedVideos : 0} generated-video attempts are available. Media scenes choose mediaSource=generate for distinctive illustrative shots or mediaSource=stock for generic verified imagery. A stock miss is not permission to broaden essential details. Do not spend generation on every scene.`,
-    "Each mediaKeyword is a literal filmable subject/action, 2\u20138 words, maximum 80 characters. Use optional shotDirection for action, camera framing and continuity; it does not change the literal stock subject. Supply a short grounded fallbackText when the schema declares it: one useful visual anchor, not a second explanation competing with narration or a promise of footage. It must still make sense when the media is absent. Do not put visible headline text over full-bleed footage.",
-    "No invented quotations, attribution, statistics, personal evidence or URLs. Creative stories may be invented when requested; do not present generated illustration as historical evidence.",
-    'Emit exactly one final placement:"closer" scene using a catalog template with a suitable payoff or ask job. It should land the meaning, not recap the whole answer. Prefer the final relevant action or visual reveal with narration; a closer does not require a black chapter card.',
-    "Every scene needs timing, even an empty object. Narration preserves the requested form and tone, uses natural sentence lengths, and does not read every on-screen word back. Finish with plan.complete."
-  ].filter((line) => line != null).join("\n");
+    "Write a complete, intentful video answer as newline-delimited JSON. Match the user's form and tone; mixed intents can combine directions.",
+    `First write one brief: {"type":"answer","intent":"explanation|story|comedy|imagination|practical","opening":"a short inviting spoken introduction of 6\u20139 words","subject":"literal visual subject","development":"the essential development of this answer","visualDirection":"consistent subjects, appearance and visual approach","ending":{"title":"short meaningful chapter title, at most 65 characters","narration":"the authored payoff","subject":"literal subject","action":"visible action or change","durationSec":${clipDurationSec},"continuity":"cut|continue"}}.`,
+    `Then stream each developing shot on its own line: {"type":"shot","title":"short meaningful chapter title, at most 65 characters","narration":"the exact spoken beat","subject":"2\u20138 literal filmable words, at most 80 characters","action":"concrete subject, action or visible change and useful framing","durationSec":${clipDurationSec},"continuity":"cut|continue"}.`,
+    `The selected footage mode is ${mode === "pexels" ? "Pexels stock search: use literal filmable subjects; never imply stock proves a mechanism or depicts fictional events exactly" : `AI video, with at most ${generatedVideoAvailable ? maxGeneratedVideos : 0} generation attempts`}. Missing footage becomes the authored chapter title, with complete narration. Preserve the full answer rather than shortening it to fit credits. The host selects providers; do not make source choices.`,
+    "For a very short answer whose ending alone fulfills the request, development may be empty and no developing shots are needed. Otherwise, develop the essential content before the ending.",
+    "The brief's ending is saved and played after your developing shots. Do not repeat it as a shot. Stop writing after the last developing shot. No technical events, identifiers, template choices, media providers, URLs or extra fields.",
+    "Every shot uses moving footage with separate narration and subtitles. Generated footage is silent: do not ask its subjects to speak or render words. No headline cards or on-screen explanatory text.",
+    `Each clip has at most ${clipDurationSec} seconds. Write spoken beats that fit naturally, usually ${Math.floor(clipDurationSec * 1.6)}\u2013${Math.floor(clipDurationSec * 2)} words per shot. Split longer ideas across purposeful shots, preserving facts and qualifiers. Never truncate a claim to meet a word target. Use only the shots needed within the total duration, including the ending; do not pad to a fixed count.`,
+    "Identify the full answer and its ending before developing shots. Each action must support what is said: camera movement alone is not progression. Vary scale, viewpoint and meaningful details while keeping subjects consistent.",
+    "Explanations: clarify the actual causal mechanism, separating physical cause from a metaphor. Generated cutaways and animation illustrate ideas; they are not factual evidence. Preserve uncertainty, quantities and conditions; never invent evidence or quotations.",
+    "Stories: portray characters making choices and experiencing consequences; use consistent character descriptions and an earned resolution, not a promised next scene.",
+    "Comedy: establish the premise, time the visual or spoken reveal, allow a reaction beat, and stop on the payoff without explaining the joke.",
+    "Imagination: make the impossible action concrete, establish the world's internal rules and keep its imagery consistent. Do not replace imagination with an explanation of it.",
+    "Practical answers: show usable actions in their necessary order, with framing that makes the method and result visible. Preserve essential steps and relevant safety conditions.",
+    openingAlreadyProvided ? "The supplied opening has already been spoken. Preserve it and begin the body with new content." : "The brief opening is spoken during preparation. The first body shot must develop it rather than repeat its words or claim.",
+    "Use continuity=continue when the same subject/action should remain coherent; choose cut for a purposeful new view. Describe recurring subjects consistently. Never assume a different angle or generated depiction proves a factual claim."
+  ].join("\n");
 }
 var VIDEO_CHAT_NARRATION_PROMPT = [
   "You narrate a short video response, one scene at a time.",
@@ -995,9 +1178,7 @@ 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?",
@@ -1044,8 +1225,8 @@ function parseResponseRequest(value) {
   const body = record2(value, "request");
   allowedKeys2(body, ["prompt", "opening", "mode", "orientation", "conversation", "style"], "request");
   const mode = body.mode ?? "cinematic";
-  if (mode !== "cinematic") {
-    throw new Error("request.mode must be cinematic");
+  if (mode !== "cinematic" && mode !== "pexels") {
+    throw new Error("request.mode must be cinematic or pexels");
   }
   const orientation = body.orientation ?? "landscape";
   if (orientation !== "portrait" && orientation !== "landscape") {
@@ -1108,64 +1289,6 @@ async function readJson(request, maximum) {
 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, 65);
-  const narration = bounded(shot.narration, 300);
-  const mediaKeyword = bounded(shot.mediaKeyword, 80).match(/\S+/gu)?.slice(0, 8).join(" ") ?? "";
-  const shotDirection = bounded(shot.shotDirection, 220);
-  return text && narration && mediaKeyword ? { text, narration, mediaKeyword, ...shotDirection ? { shotDirection } : {} } : 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),
-      ...boundedWords(parsed.fallbackKeyword, 4, 80) ? { fallbackKeyword: boundedWords(parsed.fallbackKeyword, 4, 80) } : {},
-      ...firstShot ? { firstShot } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function reservedFirstScene(requestId, firstShot) {
-  return {
-    type: "scene.add",
-    scene: {
-      id: `${requestId}-first-shot`,
-      templateId: "cinemaMedia",
-      variables: {
-        fallbackText: firstShot.text,
-        mediaSource: "generate",
-        ...firstShot.shotDirection ? { shotDirection: firstShot.shotDirection } : {},
-        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;
@@ -1182,77 +1305,6 @@ function createOpeningChannel(initial) {
     }
   };
 }
-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;
-    const continuation = createOpeningContinuation(options.openingLine);
-    const acceptOpening = (opening) => {
-      if (!options.openingProvided) {
-        options.publish(opening.line ? opening : void 0);
-        continuation.remember(opening.line);
-      }
-      if (!options.generatedVideoAvailable || !opening.firstShot) return void 0;
-      const narration = continuation.narration(opening.firstShot.narration);
-      if (!narration) return void 0;
-      const text = continuation.copy(opening.firstShot.text, narration);
-      continuation.remember(narration);
-      return JSON.stringify(reservedFirstScene(options.requestId, { ...opening.firstShot, text, narration }));
-    };
-    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) {
-              const firstScene = acceptOpening(opening);
-              if (firstScene) yield `${firstScene}
-`;
-              newline = buffer.indexOf("\n");
-              continue;
-            }
-            options.publish(void 0);
-          }
-          const continued = continuation.line(rawLine);
-          if (continued != null) yield `${continued}
-`;
-          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) {
-            const firstScene = acceptOpening(opening);
-            if (firstScene) yield `${firstScene}
-`;
-          } else {
-            options.publish(void 0);
-            const continued = continuation.line(buffer);
-            if (continued != null) yield continued;
-          }
-        } else {
-          const continued = continuation.line(buffer);
-          if (continued != null) yield continued;
-        }
-      }
-    } finally {
-      options.publish(void 0);
-    }
-  })();
-  return replaceTextStream(source, textStream);
-}
 function resequenceEvent(event, sequence) {
   return {
     ...event,
@@ -1260,7 +1312,25 @@ function resequenceEvent(event, sequence) {
     eventId: `${event.runId}:${sequence}`
   };
 }
-function streamVideoChatOpening(response, openingReady) {
+var VIDEO_CHAT_PREPARATION_EVENT_TYPE = "data.video-chat-preparation";
+function createPreparationChannel() {
+  let wake;
+  const channel = {
+    queue: [],
+    changed: new Promise((resolve) => {
+      wake = resolve;
+    }),
+    publish(value) {
+      channel.queue.push(value);
+      wake();
+      channel.changed = new Promise((resolve) => {
+        wake = resolve;
+      });
+    }
+  };
+  return channel;
+}
+function streamVideoChatOpening(response, openingReady, preparations, cancel) {
   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* () {
@@ -1276,7 +1346,8 @@ function streamVideoChatOpening(response, openingReady) {
             ...first.value.data.capabilities,
             extensions: Array.from(/* @__PURE__ */ new Set([
               ...first.value.data.capabilities?.extensions ?? [],
-              VIDEO_CHAT_OPENING_EVENT_TYPE
+              VIDEO_CHAT_OPENING_EVENT_TYPE,
+              VIDEO_CHAT_PREPARATION_EVENT_TYPE
             ]))
           }
         }
@@ -1299,10 +1370,28 @@ function streamVideoChatOpening(response, openingReady) {
         });
         sequence += 1;
       }
-      let next = await nextEvent;
-      while (!next.done) {
-        yield encodeVideoSseEvent(resequenceEvent(next.value, sequence++));
-        next = await events.next();
+      let pending = nextEvent;
+      while (true) {
+        while (preparations.queue.length) {
+          const data = preparations.queue.shift();
+          yield encodeVideoSseEvent({
+            protocolVersion: first.value.protocolVersion,
+            runId: first.value.runId,
+            sequence,
+            eventId: `${first.value.runId}:${sequence}`,
+            type: VIDEO_CHAT_PREPARATION_EVENT_TYPE,
+            data
+          });
+          sequence += 1;
+        }
+        const next = await Promise.race([
+          pending.then((value) => ({ value })),
+          preparations.changed.then(() => void 0)
+        ]);
+        if (!next || preparations.queue.length) continue;
+        if (next.value.done) break;
+        yield encodeVideoSseEvent(resequenceEvent(next.value.value, sequence++));
+        pending = events.next();
       }
     } finally {
       await events.return?.(void 0);
@@ -1328,6 +1417,7 @@ function streamVideoChatOpening(response, openingReady) {
       }
     },
     async cancel() {
+      cancel();
       completed = true;
       await iterator.return?.();
     }
@@ -1338,11 +1428,11 @@ function streamVideoChatOpening(response, openingReady) {
     headers: response.headers
   });
 }
-function readSuggestionSubjects(text) {
-  const opening = text.indexOf("{");
-  const closing = text.lastIndexOf("}");
+function readSuggestionSubjects(text2) {
+  const opening = text2.indexOf("{");
+  const closing = text2.lastIndexOf("}");
   if (opening < 0 || closing <= opening) return [];
-  const parsed = JSON.parse(text.slice(opening, closing + 1));
+  const parsed = JSON.parse(text2.slice(opening, closing + 1));
   return (Array.isArray(parsed.suggestions) ? parsed.suggestions : []).flatMap((entry) => {
     if (!entry || typeof entry !== "object") return [];
     const item = entry;
@@ -1392,7 +1482,8 @@ function createVideoChatHandler(options) {
     allowCredentials,
     mediaConcurrency = 5,
     maxGeneratedVideos = 5,
-    generateVideoTimeoutMs = 15e3
+    generateVideoTimeoutMs = 15e3,
+    generatedClipDurationSec = 5
   } = options;
   const videoOptions = {
     templates: options.templates,
@@ -1408,6 +1499,7 @@ function createVideoChatHandler(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");
   if (!Number.isSafeInteger(generateVideoTimeoutMs) || generateVideoTimeoutMs < 1 || generateVideoTimeoutMs > 12e4) throw new Error("generateVideoTimeoutMs must be an integer from 1 to 120000");
+  if (!Number.isFinite(generatedClipDurationSec) || generatedClipDurationSec < 2 || generatedClipDurationSec > 20) throw new Error("generatedClipDurationSec must be from 2 to 20");
   if (!Number.isSafeInteger(maxGeneratedVideos) || maxGeneratedVideos < 0) throw new Error("maxGeneratedVideos must be a nonnegative safe integer");
   const capabilities2 = {
     templates: true,
@@ -1415,24 +1507,41 @@ function createVideoChatHandler(options) {
     generatedVideo: generateVideo != null,
     stockMedia: searchMedia != null,
     transcription: transcribe != null,
-    modes: ["cinematic"]
+    modes: searchMedia ? ["cinematic", "pexels"] : ["cinematic"]
   };
   const welcomePrompts = (welcomeOptions?.prompts ?? DEFAULT_WELCOME_PROMPTS).slice(0, 4);
   const heroQuery = welcomeOptions?.heroQuery;
   let welcomeResponse;
   let requestSequence = 0;
-  const responseHandler = (requestId, openingProvided, openingChannel, openingLine) => {
-    const generatedVideoAvailable = generateVideo != null && maxGeneratedVideos > 0;
+  const responseHandler = (requestId, openingProvided, openingChannel, openingLine, mode, preparations) => {
+    const startedAt = Date.now();
+    const diagnose = (event) => {
+      try {
+        void Promise.resolve(options.onDiagnostic?.({ requestId, mode, elapsedMs: Math.max(0, Date.now() - startedAt), ...event })).catch(() => void 0);
+      } catch {
+      }
+    };
+    diagnose({ phase: "request-accepted" });
+    const generatedVideoAvailable = mode === "cinematic" && generateVideo != null && maxGeneratedVideos > 0;
     let lifecycle;
     let generatedAttempts = 0;
-    const completedVideos = /* @__PURE__ */ new Map();
-    const reusedUrls = /* @__PURE__ */ new Set();
+    let mediaStartedAt;
+    let mediaIndex = 0;
     const resolveSelected = generateVideo || searchMedia ? async (query, context) => {
-      const reuseKey = JSON.stringify([query, context.generatedLook ?? "", context.scene.variables.shotDirection ?? "", context.input.orientation ?? "landscape"]);
-      const remember = (media) => {
-        if (media?.type === "video") completedVideos.set(reuseKey, media);
-        return media;
-      };
+      mediaStartedAt ??= Date.now();
+      const remainingMs = mediaStartedAt + generateVideoTimeoutMs + mediaIndex++ * generatedClipDurationSec * 1e3 - Date.now();
+      if (remainingMs <= 0) {
+        diagnose({ phase: "media-skipped", sceneId: context.scene.id, reason: "deadline" });
+        return null;
+      }
+      if (mode === "cinematic" && (!generateVideo || generatedAttempts >= maxGeneratedVideos)) {
+        diagnose({ phase: "media-skipped", sceneId: context.scene.id, reason: !generateVideo ? "not-configured" : "allowance" });
+        return null;
+      }
+      if (mode === "pexels" && !searchMedia) {
+        diagnose({ phase: "media-skipped", sceneId: context.scene.id, reason: "not-configured" });
+        return null;
+      }
       const mediaContext = {
         purpose: "response",
         orientation: context.input.orientation ?? "landscape",
@@ -1446,6 +1555,8 @@ function createVideoChatHandler(options) {
       const attempt = async (resolver, timeoutMs) => {
         context.signal.throwIfAborted();
         if (!resolver) return null;
+        const mediaStart = Date.now();
+        diagnose({ phase: "media-start", sceneId: context.scene.id });
         try {
           const result = sanitizeVideoChatMedia(await withDeadline(
             (signal) => resolver(query, { ...mediaContext, signal }),
@@ -1453,16 +1564,28 @@ function createVideoChatHandler(options) {
             context.signal
           ));
           context.signal.throwIfAborted();
+          diagnose({
+            phase: "media-end",
+            sceneId: context.scene.id,
+            durationMs: Math.max(0, Date.now() - mediaStart),
+            reason: result && (result.type === "video" || options.templates && resolver === searchMedia) ? "ready" : "empty"
+          });
           return result;
         } catch (cause) {
+          diagnose({
+            phase: "media-end",
+            sceneId: context.scene.id,
+            durationMs: Math.max(0, Date.now() - mediaStart),
+            reason: context.signal.aborted ? "cancelled" : cause instanceof DOMException && cause.name === "TimeoutError" ? "timeout" : "provider-error"
+          });
           context.signal.throwIfAborted();
           reportError(cause);
           return null;
         }
       };
-      if (generatedVideoAvailable && context.scene.variables.mediaSource === "generate") {
-        const generated = generatedAttempts < maxGeneratedVideos ? (generatedAttempts++, await attempt(generateVideo, generateVideoTimeoutMs)) : null;
-        if (generated) return remember(generated);
+      if (generatedVideoAvailable && (!options.templates || context.scene.variables.mediaSource === "generate")) {
+        const generated = generatedAttempts < maxGeneratedVideos ? (generatedAttempts++, await attempt(generateVideo, remainingMs)) : null;
+        if (generated?.type === "video") return generated;
         lifecycle?.reportWarning?.({
           code: "provider_warning",
           category: "provider",
@@ -1470,43 +1593,57 @@ function createVideoChatHandler(options) {
           recoverable: true
         });
       }
-      const stock = await attempt(searchMedia, 3e3);
-      if (stock) return remember(stock);
-      if (generatedVideoAvailable) {
-        const previous = completedVideos.get(reuseKey);
-        if (previous && !reusedUrls.has(previous.url)) {
-          reusedUrls.add(previous.url);
-          return previous;
-        }
-      }
+      if (mode !== "pexels") return null;
+      const stock = await attempt(searchMedia, Math.min(3e3, remainingMs));
+      if (stock && (options.templates || stock.type === "video")) return stock;
       return null;
     } : void 0;
-    const handler = createVideoHandler({
-      ...videoOptions,
-      streamText: (context) => {
-        lifecycle = getGenerationLifecycleSink(context);
-        try {
-          return interceptOpeningPlan(videoOptions.streamText(context), {
-            expectOpening: generatedVideoAvailable || !openingProvided,
-            openingProvided,
-            openingLine,
-            requestId,
-            generatedVideoAvailable,
-            publish: openingChannel.publish
-          });
-        } catch (cause) {
-          openingChannel.publish(void 0);
-          throw cause;
-        }
-      },
+    if (options.templates) {
+      openingChannel.publish(void 0);
+      return createVideoHandler({
+        ...videoOptions,
+        authorize: "none",
+        allowedOrigins,
+        allowCredentials,
+        maxBodyBytes,
+        mediaConcurrency,
+        resolveMedia: resolveSelected,
+        narrate: true,
+        basePrompt: instructions
+      });
+    }
+    const handler = createVideoStreamHandler({
+      heartbeatMs: videoOptions.heartbeatMs,
+      onError: videoOptions.onError,
+      onWarning: videoOptions.onWarning,
+      onComplete: videoOptions.onComplete,
+      invalidPartBehavior: videoOptions.invalidPartBehavior,
+      requireCloser: options.requireCloser ?? true,
+      generate: createChatShotPlanner({
+        streamText: (context) => {
+          lifecycle = getGenerationLifecycleSink(context);
+          return videoOptions.streamText(context);
+        },
+        includeRawProviderData: videoOptions.includeRawProviderData,
+        openingLine,
+        publishOpening: (opening) => {
+          if (opening) diagnose({ phase: "opening-authored" });
+          openingChannel.publish(opening);
+        },
+        prepareScene: (scene) => {
+          diagnose({ phase: "shot-authored", sceneId: scene.sceneId });
+          if (!resolveSelected) diagnose({ phase: "media-skipped", sceneId: scene.sceneId, reason: "not-configured" });
+          preparations.publish(scene);
+        },
+        generatedClipDurationSec,
+        resolveMedia: resolveSelected,
+        mediaConcurrency
+      }),
       authorize: "none",
       allowedOrigins,
       allowCredentials,
       maxBodyBytes,
-      mediaConcurrency,
-      basePrompt: [createVideoChatResponseInstructions(generatedVideoAvailable, openingProvided, maxGeneratedVideos), instructions?.trim()].filter(Boolean).join("\n\nAPPLICATION GUIDANCE\n"),
-      narrate: true,
-      resolveMedia: resolveSelected
+      systemPrompt: [createVideoChatResponseInstructions(generatedVideoAvailable, openingProvided, maxGeneratedVideos, generatedClipDurationSec, mode), instructions?.trim()].filter(Boolean).join("\n\nAPPLICATION GUIDANCE\n")
     });
     return handler;
   };
@@ -1601,12 +1738,12 @@ function createVideoChatHandler(options) {
       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({
+        const text2 = await transcribe({
           audio,
           mediaType: request.headers.get("content-type") || "audio/webm",
           signal: request.signal
         });
-        return Response.json({ text: text.trim() }, { headers });
+        return Response.json({ text: text2.trim() }, { headers });
       } catch (cause) {
         reportError(cause);
         return jsonError2(502, "transcription_failed", "The recording could not be transcribed", headers);
@@ -1632,12 +1769,14 @@ function createVideoChatHandler(options) {
       }
       const requestId = `video-chat-${Date.now()}-${requestSequence += 1}`;
       const openingChannel = createOpeningChannel(input.opening ? { line: input.opening, keyword: "" } : void 0);
+      const preparations = createPreparationChannel();
+      const cancellation = new AbortController();
       const forwardedHeaders = new Headers(request.headers);
       forwardedHeaders.delete("content-length");
       const videoRequest = new Request(request.url, {
         method: "POST",
         headers: forwardedHeaders,
-        signal: request.signal,
+        signal: AbortSignal.any([request.signal, cancellation.signal]),
         body: JSON.stringify({
           protocolVersion: VIDEO_PROTOCOL_VERSION,
           requestId,
@@ -1660,9 +1799,11 @@ function createVideoChatHandler(options) {
         requestId,
         input.opening != null,
         openingChannel,
-        input.opening
+        input.opening,
+        input.mode,
+        preparations
       )(videoRequest);
-      return streamVideoChatOpening(response, openingChannel.ready);
+      return streamVideoChatOpening(response, openingChannel.ready, preparations, () => cancellation.abort());
     }
     try {
       if (action === "opening-media") {
@@ -1712,7 +1853,7 @@ function createVideoChatHandler(options) {
         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 withDeadline((signal) => callText(
+          const text2 = await withDeadline((signal) => callText(
             "suggestions",
             VIDEO_CHAT_SUGGESTIONS_PROMPT,
             `USER PROMPT: ${prompt}
@@ -1722,7 +1863,7 @@ ${lines.join("\n")}`,
             512,
             signal
           ), 3e3, request.signal);
-          const subjects = readSuggestionSubjects(text);
+          const subjects = readSuggestionSubjects(text2);
           const mediaResolver = searchMedia;
           const media = await Promise.all(subjects.map(async (subject) => {
             if (!mediaResolver || !subject.keyword) return null;
@@ -1753,9 +1894,9 @@ ${lines.join("\n")}`,
         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);
+        const text2 = boundedString2(value.text, "request.text", 4e3);
         try {
-          const result = await withDeadline((signal) => generateSpeech({ text, signal }), 3e3, request.signal);
+          const result = await withDeadline((signal) => generateSpeech({ text: text2, signal }), 3e3, request.signal);
           return new Response(audioBody(result.audio), {
             headers: {
               ...Object.fromEntries(headers),