@vanillaskyai/video 0.10.22 → 0.11.0

package/starters/video-chat/providers/video-custom.ts

@@ -0,0 +1,45 @@
+import type { VideoChatHandlerOptions } from "@vanillaskyai/video/server";
+import type { DeliverVideo } from "./video-delivery";
+import { runVideoJob } from "./video-job";
+
+// Your model, duration, resolution and account throughput live in application code.
+const CLIP_DURATION_SEC = 5;
+const CONCURRENCY = 2;
+const TIMEOUT_MS = 120_000;
+type Context = Parameters<NonNullable<VideoChatHandlerOptions["generateVideo"]>>[1];
+
+/** Any vendor SDK or native API can implement these callbacks. Submission is
+ * called ONCE; null means still pending. Supply your model/resolution in submit,
+ * persist its ID with onSubmitted, and deliver a browser-safe copy of the bytes.
+ */
+export function createCustomVideo<Job extends { id: string }>(adapter: {
+  submit: (query: string, context: Context) => Promise<Job>;
+  poll: (job: Job, signal: AbortSignal) => Promise<Response | null>;
+  cancel?: (job: Job, signal: AbortSignal) => Promise<void>;
+  onSubmitted?: (job: Job) => void | Promise<void>;
+  deliver: DeliverVideo;
+}): NonNullable<VideoChatHandlerOptions["generateVideo"]> {
+  return async (query, context) => {
+    if (context.requestedDurationSec !== CLIP_DURATION_SEC) throw new Error("Clip duration does not match the app-owned model policy");
+    let pending = true;
+    const { value } = await runVideoJob({
+      ...adapter, ...context, deadlineAt: Math.min(context.deadlineAt, Date.now() + TIMEOUT_MS), pollIntervalMs: 5000,
+      submit: (signal) => adapter.submit(query, { ...context, signal }),
+      poll: async (job, signal) => {
+        const response = await adapter.poll(job, signal);
+        if (!response) return null;
+        pending = false;
+        return { url: await adapter.deliver({ response, jobId: job.id, durationSec: context.requestedDurationSec, signal }),
+          type: "video" as const, durationSec: context.requestedDurationSec };
+      },
+      cancel: async (job, signal) => { if (pending) await adapter.cancel?.(job, signal); },
+    });
+    return value;
+  };
+}
+
+export const videoProvider = {
+  generatedClipDurationSec: CLIP_DURATION_SEC, mediaConcurrency: CONCURRENCY, generateVideoTimeoutMs: TIMEOUT_MS,
+  // Wire createCustomVideo(...) here. No vendor or storage is imposed by the SDK.
+  generateVideo: undefined,
+} satisfies Pick<VideoChatHandlerOptions, "generateVideo" | "generatedClipDurationSec" | "mediaConcurrency" | "generateVideoTimeoutMs">;

package/starters/video-chat/providers/video-delivery.ts

@@ -0,0 +1,57 @@
+/** Replace this callback with your own storage integration. It receives server
+ * bytes; provider credentials and private URLs never reach a browser. Serve
+ * H.264 MP4 with Content-Type, Content-Length, byte ranges, CORS and replay-safe
+ * retention. Put the MP4 moov atom first for progressive playback.
+ */
+export type DeliverVideo = (input: {
+  response: Response; jobId: string; durationSec: number; signal: AbortSignal;
+}) => Promise<string>;
+
+function configured(): boolean {
+  try {
+    const url = new URL(process.env.VIDEO_UPLOAD_URL ?? "");
+    return url.protocol === "https:" && !url.username && !url.password && Boolean(process.env.VIDEO_STORAGE_TOKEN);
+  }
+  catch { return false; }
+}
+export const videoDeliveryConfigured = configured();
+
+/** YOUR endpoint contract, not an SDK service: PUT MP4 bytes, return { url }.
+ * Or replace this whole callback with your S3/R2/local storage code.
+ */
+export const deliverVideo: DeliverVideo = async ({ response, jobId, signal }) => {
+  if (!videoDeliveryConfigured) throw new Error("Configure app-owned video delivery before generation");
+  if (!response.ok || !response.body) throw new Error("Provider video download failed");
+  const upload = new URL(process.env.VIDEO_UPLOAD_URL!);
+  if (upload.protocol !== "https:") throw new Error("Video upload endpoint must use HTTPS");
+  upload.searchParams.set("jobId", jobId);
+  const result = await fetch(upload, {
+    method: "PUT", signal,
+    headers: { authorization: `Bearer ${process.env.VIDEO_STORAGE_TOKEN}`, "content-type": "video/mp4" },
+    body: response.body, duplex: "half",
+  } as RequestInit);
+  if (!result.ok) throw new Error("App-owned video upload failed");
+  const { url } = await result.json() as { url: string };
+  const publicUrl = new URL(url);
+  if (publicUrl.protocol !== "https:" || publicUrl.username || publicUrl.password) throw new Error("Delivery must return a browser-safe HTTPS URL");
+  return publicUrl.href;
+};
+
+/** Follow provider/CDN redirects without forwarding Google's key off its origin. */
+export async function downloadVideo(url: string, signal: AbortSignal, googleKey?: string): Promise<Response> {
+  for (let redirects = 0; redirects <= 5; redirects++) {
+    const target = new URL(url);
+    if (target.protocol !== "https:" || target.username || target.password) throw new Error("Unexpected video download URL");
+    const response = await fetch(target.href, { signal, redirect: "manual",
+      headers: googleKey && target.origin === "https://generativelanguage.googleapis.com" ? { "x-goog-api-key": googleKey } : undefined });
+    if (![301, 302, 303, 307, 308].includes(response.status)) {
+      if (!response.ok) throw new Error("Provider video download failed");
+      return response;
+    }
+    const location = response.headers.get("location");
+    await response.body?.cancel();
+    if (!location) throw new Error("Video download redirect has no location");
+    url = new URL(location, target).href;
+  }
+  throw new Error("Too many video download redirects");
+}

package/starters/video-chat/providers/video-google.ts

@@ -0,0 +1,48 @@
+import type { VideoChatHandlerOptions } from "@vanillaskyai/video/server";
+import { deliverVideo, downloadVideo, videoDeliveryConfigured, type DeliverVideo } from "./video-delivery";
+import { jsonResponse, providerUrl, runVideoJob, videoPrompt } from "./video-job";
+
+// https://ai.google.dev/gemini-api/docs/video — Veo 3.1: 4/6/8s at 720p.
+const VIDEO_MODEL = process.env.GOOGLE_VIDEO_MODEL ?? "veo-3.1-fast-generate-preview";
+const CLIP_DURATION_SEC = 6;
+const RESOLUTION = "720p";
+const CONCURRENCY = 2;
+const TIMEOUT_MS = 360_000;
+const BASE = "https://generativelanguage.googleapis.com/v1beta";
+
+export function createGoogleVideo(apiKey: string, delivery: DeliverVideo): NonNullable<VideoChatHandlerOptions["generateVideo"]> {
+  const headers = { "x-goog-api-key": apiKey, "content-type": "application/json" };
+  return async (query, context) => {
+    if (context.requestedDurationSec !== CLIP_DURATION_SEC) throw new Error("Clip duration does not match the app-owned model policy");
+    const { value } = await runVideoJob({
+      ...context, deadlineAt: Math.min(context.deadlineAt, Date.now() + TIMEOUT_MS), pollIntervalMs: 10_000,
+      submit: async (signal) => {
+        const result = await jsonResponse<{ name: string }>(await fetch(`${BASE}/models/${VIDEO_MODEL}:predictLongRunning`, {
+          method: "POST", headers, signal,
+          body: JSON.stringify({ instances: [{ prompt: videoPrompt(query, context) }], parameters: {
+            durationSeconds: CLIP_DURATION_SEC, resolution: RESOLUTION, aspectRatio: context.orientation === "portrait" ? "9:16" : "16:9",
+          } }),
+        }));
+        return { id: result.name };
+      },
+      poll: async (job, signal) => {
+        if (!/^models\/[\w.-]+\/operations\/[\w.-]+$/.test(job.id)) throw new Error("Unexpected video operation name");
+        const status = await jsonResponse<{ done?: boolean; error?: unknown; response?: { generateVideoResponse?: { generatedSamples?: { video: { uri: string } }[] } } }>(await fetch(`${BASE}/${job.id}`, { headers, signal }));
+        if (status.error) throw new Error("Video generation failed");
+        if (!status.done) return null;
+        const uri = status.response?.generateVideoResponse?.generatedSamples?.[0]?.video.uri;
+        if (!uri) throw new Error("Video generation returned no output");
+        // Download is private; keep it and storage delivery inside the deadline.
+        const response = await downloadVideo(providerUrl(uri, "https://generativelanguage.googleapis.com"), signal, apiKey);
+        return { url: await delivery({ response, jobId: job.id, durationSec: CLIP_DURATION_SEC, signal }), type: "video" as const, durationSec: CLIP_DURATION_SEC };
+      },
+      // No documented Gemini Veo cancellation. Abort stops polling, not billing.
+    });
+    return value;
+  };
+}
+
+export const videoProvider = {
+  generatedClipDurationSec: CLIP_DURATION_SEC, mediaConcurrency: CONCURRENCY, generateVideoTimeoutMs: TIMEOUT_MS,
+  generateVideo: process.env.GEMINI_API_KEY && videoDeliveryConfigured ? createGoogleVideo(process.env.GEMINI_API_KEY, deliverVideo) : undefined,
+} satisfies Pick<VideoChatHandlerOptions, "generateVideo" | "generatedClipDurationSec" | "mediaConcurrency" | "generateVideoTimeoutMs">;

package/starters/video-chat/providers/video-job.ts

@@ -0,0 +1,103 @@
+/** App-owned queue lifecycle. No automatic resubmission of paid work. */
+export async function runVideoJob<Job extends { id: string }, Value>(options: {
+  signal: AbortSignal;
+  deadlineAt: number;
+  pollIntervalMs: number;
+  submit: (signal: AbortSignal) => Promise<Job>;
+  poll: (job: Job, signal: AbortSignal) => Promise<Value | null>;
+  cancel?: (job: Job, signal: AbortSignal) => Promise<void>;
+  /** Persist this ID in your job ledger if work must survive a server restart. */
+  onSubmitted?: (job: Job, signal: AbortSignal) => void | Promise<void>;
+}): Promise<{ job: Job; value: Value }> {
+  options.signal.throwIfAborted();
+  const remaining = options.deadlineAt - Date.now();
+  if (!Number.isFinite(remaining) || remaining <= 0) throw new Error("Video deadline expired before submission");
+  const timer = new AbortController();
+  const timeout = setTimeout(() => timer.abort(new Error("Video deadline expired")), remaining);
+  const signal = AbortSignal.any([options.signal, timer.signal]);
+  let job: Job | undefined;
+  let stopped = false;
+  let cancellation: Promise<void> | undefined;
+  const cancelJob = (): Promise<void> => {
+    if (!job || !options.cancel) return Promise.resolve();
+    const accepted = job;
+    return cancellation ??= (async () => {
+      // A fresh signal permits cleanup after the request's signal has stopped.
+      const cleanup = new AbortController();
+      const cleanupTimer = setTimeout(() => cleanup.abort(new Error("Video cancellation timed out")), 3000);
+      try { await withSignal(() => options.cancel!(accepted, cleanup.signal), cleanup.signal); }
+      catch { /* Best effort: cancellation promises no refund. */ }
+      finally { clearTimeout(cleanupTimer); }
+    })();
+  };
+  try {
+    // A transport error here can mean the provider accepted the job. NEVER retry.
+    job = await withSignal(async () => {
+      const accepted = await options.submit(signal);
+      if (typeof accepted?.id !== "string" || !accepted.id) throw new Error("Missing provider job ID");
+      job = accepted;
+      // An uncooperative submit may reveal its ID after our bounded wait ends.
+      if (stopped) void cancelJob();
+      return accepted;
+    }, signal);
+    if (options.onSubmitted) await withSignal(() => options.onSubmitted!(job!, signal), signal);
+    while (true) {
+      signal.throwIfAborted();
+      const value = await withSignal(() => options.poll(job!, signal), signal);
+      signal.throwIfAborted();
+      if (value !== null) return { job, value };
+      await pause(options.pollIntervalMs, signal);
+    }
+  } catch {
+    stopped = true;
+    // A failed callback abandons this job, too. Stop sibling work and attempt
+    // cleanup; adapters decide whether an already-completed job is cancellable.
+    timer.abort(new Error("Video job stopped"));
+    await cancelJob();
+    throw Object.assign(new Error(job
+      ? "Video job did not complete; inspect the retained job ID before retrying"
+      : "Video submission outcome unknown; inspect the provider dashboard before retrying"), { jobId: job?.id });
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/** Bound application promises even when they ignore the cancellation signal. */
+async function withSignal<T>(operation: () => T | PromiseLike<T>, signal: AbortSignal): Promise<T> {
+  signal.throwIfAborted();
+  return new Promise<T>((resolve, reject) => {
+    const cleanup = () => signal.removeEventListener("abort", abort);
+    const abort = () => { cleanup(); reject(signal.reason); };
+    signal.addEventListener("abort", abort, { once: true });
+    Promise.resolve().then(() => { signal.throwIfAborted(); return operation(); }).then(
+      (value) => { cleanup(); resolve(value); },
+      (error) => { cleanup(); reject(error); },
+    );
+  });
+}
+
+async function pause(ms: number, signal: AbortSignal): Promise<void> {
+  signal.throwIfAborted();
+  await new Promise<void>((resolve, reject) => {
+    const abort = () => { clearTimeout(timer); reject(signal.reason); };
+    const timer = setTimeout(() => { signal.removeEventListener("abort", abort); resolve(); }, ms);
+    signal.addEventListener("abort", abort, { once: true });
+  });
+}
+
+/** Keep provider response bodies, URLs and credentials out of errors. */
+export async function jsonResponse<T>(response: Response): Promise<T> {
+  if (!response.ok) throw new Error(`Provider HTTP ${response.status}`);
+  return await response.json() as T;
+}
+
+export function providerUrl(value: string, origin: string): string {
+  const url = new URL(value);
+  if (url.origin !== origin || url.username || url.password) throw new Error("Unexpected provider URL");
+  return url.href;
+}
+
+export function videoPrompt(query: string, context: { shotDirection: string; generatedLook?: string }): string {
+  return [query, context.shotDirection, context.generatedLook,
+    "One continuous moving shot. No text, logos, captions, dialogue, music or narration."].filter(Boolean).join("\n");
+}

package/starters/video-chat/providers/video-runway.ts

@@ -0,0 +1,45 @@
+import type { VideoChatHandlerOptions } from "@vanillaskyai/video/server";
+import { deliverVideo, downloadVideo, videoDeliveryConfigured, type DeliverVideo } from "./video-delivery";
+import { jsonResponse, runVideoJob, videoPrompt } from "./video-job";
+
+// https://docs.dev.runwayml.com/api/ — Gen-4.5: integer durations 2–10s.
+const VIDEO_MODEL = process.env.RUNWAY_VIDEO_MODEL ?? "gen4.5";
+const CLIP_DURATION_SEC = 5;
+const RESOLUTION = { portrait: "720:1280", landscape: "1280:720" };
+const CONCURRENCY = 2;
+const TIMEOUT_MS = 180_000;
+const BASE = "https://api.dev.runwayml.com/v1";
+
+export function createRunwayVideo(apiKey: string, delivery: DeliverVideo): NonNullable<VideoChatHandlerOptions["generateVideo"]> {
+  const headers = { Authorization: `Bearer ${apiKey}`, "X-Runway-Version": "2024-11-06", "content-type": "application/json" };
+  return async (query, context) => {
+    if (context.requestedDurationSec !== CLIP_DURATION_SEC) throw new Error("Clip duration does not match the app-owned model policy");
+    const promptText = videoPrompt(query, context);
+    if (promptText.length > 1000) throw new Error("Runway video prompt exceeds 1000 characters");
+    let pending = true;
+    const { value } = await runVideoJob({
+      ...context, deadlineAt: Math.min(context.deadlineAt, Date.now() + TIMEOUT_MS), pollIntervalMs: 5000,
+      submit: async (signal) => jsonResponse<{ id: string }>(await fetch(`${BASE}/text_to_video`, {
+        method: "POST", headers, signal,
+        body: JSON.stringify({ model: VIDEO_MODEL, promptText, duration: CLIP_DURATION_SEC, ratio: RESOLUTION[context.orientation] }),
+      })),
+      poll: async (job, signal) => {
+        const status = await jsonResponse<{ status: string; output?: string[] }>(await fetch(`${BASE}/tasks/${encodeURIComponent(job.id)}`, { headers, signal }));
+        if (["PENDING", "THROTTLED", "RUNNING"].includes(status.status)) return null;
+        // DELETE removes terminal tasks too; preserve their status and cost.
+        if (["SUCCEEDED", "FAILED", "CANCELLED"].includes(status.status)) pending = false;
+        if (status.status !== "SUCCEEDED" || !status.output?.[0]) throw new Error("Video generation failed");
+        const response = await downloadVideo(status.output[0], signal);
+        return { url: await delivery({ response, jobId: job.id, durationSec: CLIP_DURATION_SEC, signal }), type: "video" as const, durationSec: CLIP_DURATION_SEC };
+      },
+      // DELETE cancels pending/running jobs; completion racing it may delete the task.
+      cancel: async (job, signal) => { if (pending) await fetch(`${BASE}/tasks/${encodeURIComponent(job.id)}`, { method: "DELETE", headers, signal }); },
+    });
+    return value;
+  };
+}
+
+export const videoProvider = {
+  generatedClipDurationSec: CLIP_DURATION_SEC, mediaConcurrency: CONCURRENCY, generateVideoTimeoutMs: TIMEOUT_MS,
+  generateVideo: process.env.RUNWAY_API_KEY && videoDeliveryConfigured ? createRunwayVideo(process.env.RUNWAY_API_KEY, deliverVideo) : undefined,
+} satisfies Pick<VideoChatHandlerOptions, "generateVideo" | "generatedClipDurationSec" | "mediaConcurrency" | "generateVideoTimeoutMs">;

package/starters/video-chat/providers/video.ts

@@ -1,71 +1,47 @@
-import { fal } from "@fal-ai/client";
 import type { VideoChatHandlerOptions } from "@vanillaskyai/video/server";
+import { deliverVideo, downloadVideo, videoDeliveryConfigured, type DeliverVideo } from "./video-delivery";
+import { jsonResponse, providerUrl, runVideoJob, videoPrompt } from "./video-job";
 
-// Change only to a duration supported by the selected model and your allowance.
-const CLIP_DURATION_SEC = 5;
+// App-owned model policy: change these together after checking the model schema.
+// https://fal.ai/models/minimax/h3-max-turbo/text-to-video/api
 const VIDEO_MODEL = process.env.FAL_VIDEO_MODEL ?? "minimax/h3-max-turbo/text-to-video";
+const CLIP_DURATION_SEC = 5;
+const RESOLUTION = "480P";
+const CONCURRENCY = 3;
+const TIMEOUT_MS = 120_000;
 
-async function filmScene(
-  subject: string,
-  generatedLook: string | undefined,
-  orientation: "portrait" | "landscape",
-  signal: AbortSignal,
-  shotDirection?: string,
-) {
-  fal.config({ credentials: process.env.FAL_KEY });
-  const started = Date.now();
-  try {
-    const result = await fal.subscribe(VIDEO_MODEL, {
-      input: {
-        prompt: [
-          `One continuous moving shot, ${orientation === "portrait" ? "9:16 vertical" : "16:9"}. ${subject}.`,
-          "Depict the requested action clearly throughout the clip. Follow its stated visual style and world rules.",
-          shotDirection,
-          "No on-screen text, captions, subtitles, watermarks or logos.",
-          "Natural scene sound only when appropriate. No speech, dialogue, singing, music or voiceover; narration is added separately.",
-          generatedLook,
-        ].filter(Boolean).join("\n\n"),
-        duration: CLIP_DURATION_SEC,
-        resolution: "480P",
-        aspect_ratio: orientation === "portrait" ? "9:16" : "16:9",
-        prompt_expansion_mode: "balanced",
+export function createFalVideo(apiKey: string, delivery: DeliverVideo): NonNullable<VideoChatHandlerOptions["generateVideo"]> {
+  const headers = { Authorization: `Key ${apiKey}`, "content-type": "application/json" };
+  return async (query, context) => {
+    if (context.requestedDurationSec !== CLIP_DURATION_SEC) throw new Error("Clip duration does not match the app-owned model policy");
+    let pending = true;
+    const { value } = await runVideoJob({
+      ...context, deadlineAt: Math.min(context.deadlineAt, Date.now() + TIMEOUT_MS), pollIntervalMs: 1000,
+      submit: async (signal) => {
+        const result = await jsonResponse<{ request_id: string; status_url: string; response_url: string; cancel_url: string }>(await fetch(`https://queue.fal.run/${VIDEO_MODEL}`, {
+          method: "POST", headers, signal,
+          body: JSON.stringify({ prompt: videoPrompt(query, context), duration: CLIP_DURATION_SEC, resolution: RESOLUTION,
+            aspect_ratio: context.orientation === "portrait" ? "9:16" : "16:9", prompt_expansion_mode: "balanced" }),
+        }));
+        return { id: result.request_id, statusUrl: result.status_url, resultUrl: result.response_url, cancelUrl: result.cancel_url };
+      },
+      poll: async (job, signal) => {
+        const status = await jsonResponse<{ status: string; error?: unknown }>(await fetch(providerUrl(job.statusUrl, "https://queue.fal.run"), { headers, signal }));
+        if (status.error) throw new Error("Video generation failed");
+        if (["IN_QUEUE", "IN_PROGRESS"].includes(status.status)) return null;
+        if (status.status !== "COMPLETED") throw new Error("Unexpected video job status");
+        pending = false;
+        const result = await jsonResponse<{ video: { url: string } }>(await fetch(providerUrl(job.resultUrl, "https://queue.fal.run"), { headers, signal }));
+        const response = await downloadVideo(result.video.url, signal);
+        return { url: await delivery({ response, jobId: job.id, durationSec: CLIP_DURATION_SEC, signal }), type: "video" as const, durationSec: CLIP_DURATION_SEC };
       },
-      abortSignal: signal,
+      cancel: async (job, signal) => { if (pending) await fetch(providerUrl(job.cancelUrl, "https://queue.fal.run"), { method: "PUT", headers, signal }); },
     });
-    const url = result?.data?.video?.url;
-    if (typeof url !== "string") throw new Error("the video provider returned no url");
-    console.log(`[video-chat] filmed in ${Date.now() - started}ms`);
-    return url;
-  } catch (cause) {
-    const status = (cause as { status?: unknown })?.status;
-    console.error(
-      `[video-chat] filming failed after ${Date.now() - started}ms${typeof status === "number" ? ` (status ${status})` : ""}`,
-    );
-    throw cause;
-  }
+    return value;
+  };
 }
 
-/** Optional generated video and transcription; credentials remain server-only. */
-export const videoProvider: Pick<VideoChatHandlerOptions, "generateVideo" | "transcribe" | "generatedClipDurationSec"> = {
-  generatedClipDurationSec: CLIP_DURATION_SEC,
-  generateVideo: process.env.FAL_KEY
-    ? async (query, { generatedLook, orientation, signal, scene }) => ({
-        url: await filmScene(query, generatedLook, orientation, signal, typeof scene?.variables.shotDirection === "string" ? scene.variables.shotDirection : undefined),
-        type: "video" as const,
-      })
-    : undefined,
-  transcribe: process.env.FAL_KEY
-    ? async ({ audio, mediaType, signal }) => {
-        signal.throwIfAborted();
-        fal.config({ credentials: process.env.FAL_KEY });
-        const bytes = Uint8Array.from(audio);
-        const url = await fal.storage.upload(new Blob([bytes.buffer], { type: mediaType }));
-        signal.throwIfAborted();
-        const result = await fal.subscribe(process.env.FAL_TRANSCRIBE_MODEL ?? "fal-ai/whisper", {
-          input: { audio_url: url, task: "transcribe" },
-          abortSignal: AbortSignal.any([signal, AbortSignal.timeout(60_000)]),
-        });
-        return String((result?.data as { text?: unknown })?.text ?? "");
-      }
-    : undefined,
-};
+export const videoProvider = {
+  generatedClipDurationSec: CLIP_DURATION_SEC, mediaConcurrency: CONCURRENCY, generateVideoTimeoutMs: TIMEOUT_MS,
+  generateVideo: process.env.FAL_KEY && videoDeliveryConfigured ? createFalVideo(process.env.FAL_KEY, deliverVideo) : undefined,
+} satisfies Pick<VideoChatHandlerOptions, "generateVideo" | "generatedClipDurationSec" | "mediaConcurrency" | "generateVideoTimeoutMs">;

package/starters/video-chat/server.ts

@@ -1,11 +1,8 @@
-import { anthropic } from "@ai-sdk/anthropic";
-import { generateText, streamText } from "ai";
 import { createVideoChatHandler } from "@vanillaskyai/video/server";
 import { findStockFootage } from "./stock";
 import { providers } from "./providers";
+import { textProvider } from "./providers/text";
 
-const PLANNER_MODEL = process.env.ANTHROPIC_PLANNER_MODEL ?? "claude-sonnet-5";
-const NARRATION_MODEL = process.env.ANTHROPIC_NARRATION_MODEL ?? "claude-haiku-4-5";
 /**
  * The application chooses providers and keeps their credentials here. The SDK
  * owns the video-chat protocol, prompts, capability negotiation, spend limits,
@@ -13,29 +10,7 @@ const NARRATION_MODEL = process.env.ANTHROPIC_NARRATION_MODEL ?? "claude-haiku-4
  */
 export const handleVideoChat = createVideoChatHandler({
   authorize: (request) => new URL(request.url).hostname === "localhost",
-  streamText: ({ systemPrompt, userPrompt, signal }) => streamText({
-    model: anthropic(PLANNER_MODEL),
-    system: systemPrompt,
-    prompt: userPrompt,
-    abortSignal: signal,
-    maxOutputTokens: 8_192,
-    providerOptions: {
-      anthropic: {
-        thinking: { type: "disabled" },
-        output_config: { effort: "medium" },
-      },
-    },
-  }),
-  generateText: async ({ systemPrompt, userPrompt, maxOutputTokens, signal }) => {
-    const { text } = await generateText({
-      model: anthropic(NARRATION_MODEL),
-      system: systemPrompt,
-      prompt: userPrompt,
-      maxOutputTokens,
-      abortSignal: signal,
-    });
-    return text;
-  },
+  ...textProvider,
   searchMedia: process.env.PEXELS_API_KEY
     ? (query, { orientation, signal, scene }) => findStockFootage(query, orientation, signal, scene?.variables.stockSelection)
     : undefined,
@@ -66,7 +41,6 @@ export const handleVideoChat = createVideoChatHandler({
       },
     ],
   },
-  onError: (error) => console.error("[video-chat] planning failed:", error.message),
+  onError: () => console.error("[video-chat] planning failed"),
   onWarning: (warning) => console.warn(`[video-chat] ${warning.code}: ${warning.message}`),
-  mediaConcurrency: 5,
 });

package/starters/video-chat/vite.config.ts

@@ -12,11 +12,6 @@ function videoChatRoutes(): Plugin {
         const path = url.pathname;
         if (path !== "/api/video-chat") return next();
         const action = url.searchParams.get("action");
-        if (!process.env.ANTHROPIC_API_KEY && action !== "welcome" && action !== "capabilities") {
-          response.statusCode = 503;
-          response.end("Set ANTHROPIC_API_KEY and restart. Video responses require a text provider.");
-          return;
-        }
 
         const startedAt = Date.now();
         const since = () => `${String(Date.now() - startedAt).padStart(6)}ms`;
@@ -63,9 +58,8 @@ function videoChatRoutes(): Plugin {
           }
           server.config.logger.info(`[video-chat] ${since()}  ${action ?? "unknown"} complete`);
           response.end();
-        } catch (cause) {
-          const message = cause instanceof Error ? cause.message : String(cause);
-          server.config.logger.error(`[video-chat] ${action ?? "unknown"} failed: ${message}`);
+        } catch {
+          server.config.logger.error(`[video-chat] ${action ?? "unknown"} failed`);
           if (!response.headersSent) response.statusCode = 500;
           response.end("Video chat request failed");
         }