@vanillaskyai/video 0.5.8 → 0.7.0

package/CHANGELOG.md

@@ -4,6 +4,184 @@ VanillaSky follows semantic versioning. This changelog begins with the 0.1 beta.
 
 ## Unreleased
 
+## 0.7.0
+
+- Makes blank-folder onboarding one safe scoped command:
+  `npx @vanillaskyai/video init`. Init now pins registry installs to the exact
+  SDK version that ran it and preserves an exact local tarball during candidate
+  verification instead of silently replacing it with an older npm artifact.
+
+- Keeps video-chat responses running when a text provider labels an ordinary
+  scene with an unsupported placement hint. The provider adapter drops that
+  harmless hint while preserving `placement: "closer"` and strict protocol
+  validation.
+
+- Keeps `VideoChat` hydration stable when voice input exists only in the
+  browser, and preserves provider warnings, usage, finish reasons, and model
+  IDs while the chat opening is intercepted from the planner stream.
+
+- Removes the duplicate one-shot React, Next.js, and provider examples plus
+  their obsolete product guides. The generated video-chat app is now the one
+  public setup path, while the internal Next.js provider matrix exercises the
+  same chat handler and interface.
+
+- Streams each video-chat opening and scene plan from one model call. The first
+  NDJSON object carries a bounded 6-9 word hook and stock keyword; Full AI also
+  carries its exact first shot so generation starts while the remaining scenes
+  arrive. Welcome suggestions can include a prewritten hook that speaks
+  immediately with their loaded media, and `onFirstFrame` reports the measured
+  handoff to the first real scene.
+
+- Speeds up both video-chat paths. Concurrent media resolution now releases the
+  first finished scene immediately instead of waiting for its queue to fill,
+  and the main planner writes narration on each scene instead of paying for a
+  second text-model round trip. Breaking (pre-1.0): removes the mixed `some` mode;
+  use `templates` for rendered responses or `full` for generated footage.
+
+- Starts each video-chat answer with a short spoken hook over relevant stock
+  footage, then holds that opening until the first planned scene is ready.
+  Welcome and follow-up cards reuse their already-loaded media immediately;
+  typed prompts resolve footage from the hook's bounded media keyword. The
+  planner receives the exact spoken hook so the response continues without
+  repeating or contradicting it.
+
+- Keeps key-only video chat clean in real browsers: planner catalogs now hide
+  templates whose required media cannot be supplied, and unavailable generated
+  speech switches to browser voice without repeated 404 responses.
+
+- Removes the obsolete source-owned template copy and transcript probes from
+  the video-chat starter. The package, lower-level examples, and remaining
+  documentation now consistently present voice-and-video chat as the primary
+  path, with packed onboarding as its single clean-room browser gate.
+
+- Makes the complete voice-and-video chat the primary README, getting-started,
+  agent, provider, concepts, and architecture path. The one-shot composition
+  APIs remain documented as an advanced non-chat integration.
+
+- Adds `vanillasky init` and `vanillasky doctor`. Init creates the canonical
+  thin video-chat app, installs its app-owned provider packages, starts with
+  packaged templates and browser voice, and requests one server-only text key.
+  Doctor checks the generated shell and reports optional speech, media,
+  transcription, and generated-video capabilities without calling providers or
+  printing secrets. Template ownership commands now live under the breaking
+  pre-1.0 `vanillasky templates` namespace.
+
+- Adds the complete default `VideoChat` interface and its explicitly imported,
+  fully scoped `video-chat.css`. Applications can now mount the same polished
+  voice-and-video chat in one component while retaining `useVideoChat` for
+  custom interfaces. The canonical starter no longer duplicates the UI,
+  interaction, accessibility, appearance, or voice-input code.
+
+- Adds `useVideoChat` and `createVideoChatVoice` to the React entry. The SDK
+  now owns video-chat turns, conversation context, cancellation, retry,
+  opening speech, narration pacing, suggestions, replay, history selection,
+  and the browser-voice fallback behind one provider-neutral endpoint.
+
+- Adds `VideoPlayer.onPlaybackEnd`, which fires when the visible playhead
+  actually reaches the end without changing the existing stream-composition
+  meaning of `onComplete`.
+
+- Adds `createVideoChatHandler`, one provider-neutral server endpoint for the
+  general-purpose video-chat experience. The SDK now owns the response,
+  opening, narration, suggestion, speech, transcription, welcome, capability,
+  and server-held generated-video budget contracts; applications supply model
+  and media callbacks without exposing providers or keys to the browser.
+
+- Reframes the canonical interactive demo as a general-purpose video chat
+  starter for explanations, stories, recommendations, and creative prompts.
+  It now runs with one text-model key, falls back to browser speech, and unlocks
+  generated speech, stock media, transcription, and generated video only when
+  their application-owned provider keys are configured.
+
+- Adds `paused` to `VideoPlayer`: hold the playhead where it is, and release it
+  from the same frame. It completes `controls={false}`. Turning the player's own
+  controls off hands playback to the application, and until now there was no
+  lever to drive it with - a narrated answer could silence its voice but not
+  stop its picture, and the two came apart. Leaving the prop undefined keeps the
+  player's own behaviour untouched, and a video already at its end is not
+  resumed by it, since starting again is a replay rather than a continuation.
+
+- Adds `maxResolvedMedia` to `createVideoHandler`: how many scenes in one
+  request may resolve media at all. Unbounded by default, which is right when
+  media is searched for and wrong when it is generated - the planner decides the
+  scene count and every scene is then a paid clip. Past the ceiling a scene keeps
+  its copy on the brand gradient, and a `media_budget_reached` warning reaches
+  `onWarning` once, since a spend policy is the application's business rather
+  than the browser's.
+
+- Adds `useNarration` to the React entry: say a video's narration as it plays.
+  The line belongs to the scene, so it begins when that scene does, stops when
+  the picture moves on, and can be interrupted. The provider stays with the
+  application - it supplies anything that can `speak(text, { signal })`, whether
+  a realtime session, a speech model, or the browser's own synthesiser - so the
+  package gains no dependency and the choice of voice sits where the choice of
+  model already does.
+
+- Adds `getSceneDuration`, `getSceneDurationBounds` and `getSpokenDuration`.
+  Templates already declare `minDuration`, `preferredDuration` and which fields
+  hold their content, and the runtime already computed a content-aware readable
+  duration from them - but internally, so applications reached for `minDuration`
+  instead. That is a compression bound, the least a template survives being
+  squeezed to when a video must fit a fixed length: 1 second for `media`, 1.5
+  for `bigNumber`. A narrated response built on it flashes past. `getSceneDuration`
+  answers the real question, taking a scene's `narration` into account, since
+  speech is slower than reading.
+
+- Adds `generatedLook` to the video style and to `VideoInput.style`: the visual
+  language generated media is produced in. A style has two halves once media can
+  be generated - the brand decides how captions are drawn, this decides what the
+  footage behind them looks like - and they have to travel together, or a pale
+  illustrated ground ends up under dark documentary footage. It reaches
+  `resolveMedia` on the resolver context, so a provider prompt no longer has to
+  be threaded with it by hand, and it is stored with the video so a replay keeps
+  its look. Nothing is rendered from it.
+
+- Adds `mediaConcurrency` to `createVideoHandler`: how many scenes may resolve
+  media at once, defaulting to one. Media resolution ran strictly in turn, which
+  is invisible for a stock search and costly for generated video - five clips at
+  a few seconds each is half a minute of nothing, and the only way around it was
+  to plan the shots and generate them outside the plan stream. Scenes are still
+  emitted in the order they were planned; only the waiting overlaps.
+
+- Adds `createSceneTimeline`: compose a playable video from scenes the
+  application builds itself, appended through the player's `stream` prop.
+  `VideoInput.opening` holds a single line of copy, and replacing the `video`
+  prop restarts playback, so an application with its own opening scenes
+  previously had to emit protocol envelopes by hand - where the sequence, event
+  id, scene position and completion snapshot must all be exact and any mistake
+  rejects the whole stream silently. `awaitAudio` covers the related trap that
+  `audio.set` is only valid before the first scene, by holding openings until
+  the soundtrack is known.
+
+- Adds optional `narration` to `VideoScene`: the line spoken aloud while that
+  scene is showing. A narrated video previously had to be carried as scenes plus
+  a separate script kept in step by index, which drifts; holding the line on the
+  scene keeps the two together through planning, playback, storage and replay,
+  so a stored video can be spoken again without the model that wrote it. The
+  renderer never draws it. Additive and optional, so existing videos parse
+  unchanged.
+
+## 0.6.0
+
+- Adds opt-in native scene-video audio to `VideoPlayer`, mixed with the existing
+  continuous soundtrack layer under one master mute control. Applications set
+  the embedded clip level with `nativeMediaAudio.volume`; the serialized
+  soundtrack retains its independent `audio.volume`.
+- Passes `requestId` and the resolving `scene` to the server `resolveMedia`
+  callback, so applications can generate, attribute, and cache media per scene.
+- Documents a provider-neutral app-owned media generation adapter in
+  `examples/server-integrations/src/ai-sdk-media.ts`. Generation stays outside
+  the SDK install: the application supplies the AI SDK model and storage.
+- Extends the isolated rich-media consumer POC with an adaptive `/channel`
+  route: structured scene intent, deterministic stock/image/H3 Max routing,
+  manual overrides, explicit character/keyframe continuity, factual-safe
+  fallbacks, cancellation, deadline-aware generation, and a bounded
+  current-plus-next segment queue without changing the SDK API.
+- Adds an isolated AI scene-director proof of concept where VanillaSky's trusted
+  planner chooses and explains app-owned generated imagery, varied delay-aware
+  GIF stickers, and varied progress-driven Lottie motion without changing the
+  stable SDK contract.
+
 ## 0.5.8
 
 - Moved the public source to a fresh repository at

package/PUBLIC-API.md

@@ -92,11 +92,18 @@ provider-neutral text-delta escape hatch.
 
 ### Values
 
+- `createVideoChatHandler(options)`
 - `createVideoHandler(options)`
 - `createServerTemplateRegistry(options)`
 
 ### Types
 
+- `VideoChatCapabilities`
+- `VideoChatConversationTurn`
+- `VideoChatHandlerOptions`
+- `VideoChatMode`
+- `VideoChatWelcomeOptions`
+- `VideoChatWelcomePrompt`
 - `VideoHandlerOptions`
 - `MediaResolver`
 - `MediaResolverContext`
@@ -111,6 +118,38 @@ provider-neutral text-delta escape hatch.
 
 ### Handler contract
 
+`createVideoChatHandler` is the opinionated general-purpose video-chat route.
+Mount it once and use its bounded `action` query parameter for capabilities,
+responses, opening media, narration, suggestions, speech,
+transcription, and the welcome screen. It owns the general response prompts,
+fixed visual-mode spend limits, capability fallbacks, and auxiliary response
+shapes. The application supplies provider-neutral `streamText`, `generateText`,
+`generateSpeech`, `transcribe`, `searchMedia`, and `generateVideo` callbacks.
+Only the two text callbacks are required. Missing optional callbacks remove
+their capability; templates and browser speech remain available.
+
+- A response accepts `prompt`, `mode`, `orientation`, optional bounded
+  `conversation`, `opening`, `brand`, and `style`. `opening` is an optional
+  prewritten hook from a selected suggestion. The response returns protocol
+  `0.5` SSE and negotiates `data.video-chat-opening`, which carries the bounded
+  6-9 word hook and optional stock-search keyword before the first scene.
+- The planner produces that opening as the first line of the same model stream
+  that produces the scenes. The separate opening-media action resolves its
+  keyword through the application-owned `searchMedia` callback, so stock lookup
+  never delays speech or planning. In `full` mode the first line also directs
+  the exact first generated scene; the handler consumes that private direction
+  and starts the clip while the model continues with scenes two through five.
+- `templates` and `full` map to server-owned generated-media budgets of zero
+  and five. Without `generateVideo`, only `templates` is exposed
+  and forged generated-mode requests degrade to it.
+- The response planner writes narration on each scene. The narration action is
+  retained as a compatibility fallback for missing lines, not used in the
+  normal path.
+- Every action applies the same authorization, origin, request-size,
+  cancellation, safe-error, and server-only-provider boundaries.
+
+`createVideoHandler` remains the lower-level video composition route:
+
 - `authorize` is required for HTTP handlers. Use `authorize: "none"` only for
   an intentionally non-public in-process/test handler.
 - `streamText` receives the generated system prompt, grounded user prompt, and
@@ -145,18 +184,84 @@ provider-neutral text-delta escape hatch.
 
 ### Values
 
+- `VideoChat(props)`
+- `useVideoChat(options?)`
+- `createVideoChatVoice(options?)`
 - `useVideo(options?)`
 - `VideoPlayer`
 - `VideoError`
 
 ### Types
 
+- `VideoChatProps`
+- `UseVideoChatOptions`
+- `UseVideoChatResult`
+- `VideoChatAskOptions`
+- `VideoChatFirstFrameMetric`
+- `VideoChatTurn`
+- `VideoChatStatus`
+- `VideoChatMode`
+- `VideoChatCapabilities`
+- `VideoChatWelcome`
+- `VideoChatSuggestion`
+- `VideoChatMedia`
+- `VideoChatVoice`
+- `VideoChatPreparedSpeech`
+- `CreateVideoChatVoiceOptions`
 - `UseVideoOptions`
 - `UseVideoResult`
 - `VideoPlaybackMode`
 - `VideoPlayerProps`
 - `VideoErrorOptions`
 
+`VideoChat` is the complete default interface. Import its scoped stylesheet
+explicitly so the host application keeps control over CSS loading:
+
+```tsx
+import { VideoChat } from "@vanillaskyai/video/react";
+import "@vanillaskyai/video/video-chat.css";
+
+export function App() {
+  return <VideoChat />;
+}
+```
+
+Pass the same session configuration through `options`, for example
+`<VideoChat options={{ endpoint, headers, templates, brand }} />`. `className`
+and `welcomeTitle` are the only shell-level customizations. The stylesheet is
+scoped under `.vanillasky-video-chat` and does not style the host document.
+
+`useVideoChat` is the headless client for `createVideoChatHandler`. It owns
+the conversation lifecycle and returns UI-neutral state plus a spread-ready
+player binding:
+
+```tsx
+const chat = useVideoChat();
+
+await chat.ask("Tell me a tiny mystery set on a night train");
+
+return chat.playerProps
+  ? <VideoPlayer key={chat.playerKey} {...chat.playerProps} />
+  : null;
+```
+
+The hook loads capabilities and welcome suggestions, sends completed turns as
+bounded context, cancels replaced prompts, retries once only before playback,
+paces each scene to its prepared speech, and keeps pause, mute, replay, history,
+captions, and actual playback completion synchronized. The default voice tries
+the handler's generated-speech action and falls back to browser speech. Pass a
+`VideoChatVoice` to replace it without rebuilding session orchestration.
+`ask(prompt, { opening, openingMedia })` lets a custom interface start a
+prewritten suggestion hook immediately and reuse its image or video without
+another model or media lookup. The hook otherwise reads the opening from the
+response stream, resolves its media keyword, holds that media while it is
+spoken, and starts the planned timeline only when both speech and the first
+scene are ready. `UseVideoChatOptions.onFirstFrame` receives a
+`VideoChatFirstFrameMetric` once when a fresh response displays its first real
+scene. Each `VideoChatTurn` exposes `openingMedia` and `completed`, so
+custom interfaces can render the same handoff while partial or cancelled
+responses remain visible without being mistaken for conversation context.
+
 `UseVideoResult` has this conceptual shape:
 
 ```ts
@@ -191,6 +296,12 @@ mounted player autoplay with sound after the first successful viewer start.
 `manual`, `muted-autoplay`, and `autoplay-with-sound` cover the other browser
 startup policies.
 
+Set `nativeMediaAudio={{ volume: 0.85 }}` when scene video files contain an
+embedded audio track. The active clip's audio becomes a second layer alongside
+the video's continuous `audio` soundtrack. Both follow the player's master
+mute control; `nativeMediaAudio.volume` and serialized `audio.volume` set their
+independent mix levels. Incoming preroll videos remain muted until active.
+
 `VideoInput.opening` accepts custom copy, uses the deterministic fallback when
 omitted, and accepts `false` when the application owns transient loading UI and
 wants the completed video to begin with the first generated scene.
@@ -202,7 +313,9 @@ the internal reducer state are not public types.
 completed video from the beginning instead of showing the replay affordance;
 `onSceneChange(scene, index)` fires whenever the scene under the playhead
 changes, including when a loop wraps back to the first scene. Streaming
-playback is unaffected by either.
+playback is unaffected by either. `onComplete(video)` reports that a streamed
+response finished composing; `onPlaybackEnd(video)` reports that the visible
+playhead actually reached the end for either a stream or saved replay.
 
 `resolveVideoBrand` fills a partial brand with the documented defaults and
 preset backgrounds, producing the fully resolved `VideoBrand` that `parseVideo`
@@ -279,14 +392,21 @@ invalid scenes, provider failure, content filtering, abort, and timeout.
 
 The `vanillasky` binary supports:
 
-- `list`
-- `describe`
-- `create`
-- `add`
-- `sync`
-- `check`
-- `add --dry-run`
-- `add --diff`
+- `init`
+- `doctor`
+- `templates list`
+- `templates describe`
+- `templates create`
+- `templates add`
+- `templates sync`
+- `templates check`
+- `templates add --dry-run`
+- `templates add --diff`
+
+`init` writes the canonical app-owned provider and configuration shell while
+using the SDK's packaged interface, session, handler, and built-in templates.
+`doctor` is read-only and offline. The old top-level template commands are not
+aliases; this is an intentional pre-1.0 namespace change.
 
 Generated customer files import only the public entry points in this document.
 Browser registries import `createTemplateRegistry` from `/templates`. Server

package/README.md

@@ -1,156 +1,118 @@
-# Give your AI a video output
+# Give your AI a voice and a face
 
-**VanillaSky is the open-source video response layer.** Turn text, structured
-data, and live application context into personalized video responses that start
-playing while your LLM composes them.
+**VanillaSky is the open-source voice-and-video chat layer.** Add a polished,
+general-purpose AI conversation that speaks and starts playing visual answers
+while they are still being composed.
 
 > **Status: Beta.** VanillaSky is pre-1.0 and its public API may change as we
 > test it in real applications. Pin an exact version before production use.
 
-Your application owns the model, data, authentication, and UI. VanillaSky owns
-the planning prompt, trusted templates, validation, streaming, and player.
+Your application owns the providers, keys, authentication, persistence,
+branding, and product copy. VanillaSky owns the chat flow, planning prompts,
+trusted templates, validation, streaming, voice timing, and player.
 
-## Start
+## Start on localhost
 
-For humans:
+```bash
+npx @vanillaskyai/video init
+```
+
+Add `ANTHROPIC_API_KEY` to the generated, ignored `.env.local`, then run:
 
 ```bash
-npm install @vanillaskyai/video
+npx vanillasky doctor
+npm run dev
 ```
 
+Open the reported localhost URL. One text key gives you the complete chat with
+packaged templates and browser voice. No template setup is required.
+
+Optional server-only keys progressively add capabilities without changing the
+client:
+
+| Key | Adds |
+| --- | --- |
+| `XAI_API_KEY` | Generated speech |
+| `FAL_KEY` | Generated video and voice transcription |
+| `PEXELS_API_KEY` | Stock media, including opening backgrounds |
+
+`npx vanillasky doctor` reports readiness by key name and never prints values.
+Provider SDKs remain dependencies of the generated application, not the core
+package.
+
 For coding agents:
 
 ```bash
 npx skills add VanillaSkyAi/video@vanillasky
 ```
 
-Then prompt: `Use $vanillasky to turn this application's data into a personalized video response.`
-
-## Connect your LLM
-
-VanillaSky never chooses a provider or model. Configure that separately on the
-server, then connect the model your application already owns. The route below
-assumes an AI SDK `LanguageModel` exported as `videoModel`; if you do not have
-one yet, choose a provider and current model in [Provider integration](docs/provider-integration.md).
-
-Create one authenticated server route:
-
-```ts
-// app/api/video/route.ts
-import { streamText } from "ai";
-import { createVideoHandler } from "@vanillaskyai/video/server";
-import { videoModel } from "@/lib/video-model";
-
-const handle = createVideoHandler({
-  // Local development only. Replace with your session check before deploying.
-  authorize: (request) => {
-    if (process.env.VANILLASKY_LOCAL_DEMO !== "1") return false;
-    const hostname = new URL(request.url).hostname;
-    return hostname === "localhost" || hostname === "127.0.0.1";
-  },
-  streamText: ({ systemPrompt, userPrompt, signal }) => streamText({
-    model: videoModel,
-    system: systemPrompt,
-    prompt: userPrompt,
-    abortSignal: signal,
-  }),
-});
-
-export const POST = handle;
-export const OPTIONS = handle;
-```
+Then prompt: `Use $vanillasky to set up and verify a general-purpose video chat in this project.`
 
-The packaged development command supplies the local marker only to `next dev`,
-so production builds and `next start` deny every request. Replace it before
-deploying. The model can come from Anthropic, OpenAI, an AI SDK registry or
-gateway, or any compatible streaming adapter. The
-[Next.js quickstart](examples/nextjs-quickstart) shows the later, explicit
-provider-selection step with a quality-oriented Claude Sonnet model.
+## What init creates
 
-For planner-selected image and video backgrounds, configure the optional
-server-only `resolveMedia` callback described in
-[Media and soundtrack audio](docs/media-and-audio.md#media-providers).
+The generated application is a thin, editable shell:
 
-## Generate a video
+- `src/main.tsx` mounts the complete SDK-owned `<VideoChat />` interface;
+- `server.ts` connects app-owned text, speech, transcription, stock, and video
+  providers through one `createVideoChatHandler`;
+- `vite.config.ts` serves the UI and the single `/api/video-chat` endpoint;
+- `.env.local` holds server-only keys and is ignored by Git.
 
-Call the route from React and render the player:
+The UI stays this small:
 
 ```tsx
-"use client";
-
-import { VideoPlayer, useVideo } from "@vanillaskyai/video/react";
-
-export function VideoResponse() {
-  const video = useVideo();
+import { VideoChat } from "@vanillaskyai/video/react";
+import "@vanillaskyai/video/video-chat.css";
 
-  return <>
-    <button onClick={() => { void video.generate({
-      input: "Activation increased from 41% to 58% after guided onboarding.",
-      personalization: { firstName: "Maya" },
-    }); }}>
-      Generate video
-    </button>
-
-    {video.error && <p role="alert">Video generation failed.</p>}
-    <VideoPlayer {...video.playerProps} />
-  </>;
+export function App() {
+  return <VideoChat />;
 }
 ```
 
-That is the complete path. Built-in templates require no setup. VanillaSky
-shows each complete, validated scene as soon as it is ready and returns a
-deterministic `Video` object when generation finishes.
+Use `useVideoChat` when you want a custom interface while keeping the SDK-owned
+conversation and playback lifecycle. Edit the generated server when you want a
+different provider. The [provider guide](docs/provider-integration.md) explains
+both boundaries.
 
-A copy-and-run app is in [`examples/nextjs-quickstart`](examples/nextjs-quickstart).
+## Templates are the built-in fallback
 
-## Shape the response
+The packaged visual templates are the fast, inexpensive default and require no
+copied source tree. Add a video provider when you want generated footage; the
+same conversation can mix both modes.
 
-Start with `input`. It is the complete factual boundary by default:
+Copy template source only when you want to own and edit it:
 
-```ts
-video.generate({
-  input: JSON.stringify({
-    period: "Q2",
-    activation: { previous: 41, current: 58 },
-    cause: "guided onboarding",
-  }),
-  instructions: "Lead with the improvement, then explain what changed.",
-  personalization: { firstName: "Maya", plan: "Pro" },
-});
+```bash
+npm install --save-dev tsx
+npx vanillasky templates add bigNumber
 ```
 
-- Put claims, numbers, names, dates, and quotations in `input`.
-- Keep `knowledgeMode: "input-only"` (the default) for source-grounded video,
-  or choose `knowledgeMode: "general"` when the model should answer a question
-  or develop content with stable general knowledge.
-- Put presentation direction in `instructions`.
-- Put viewer or account context in `personalization`.
-- Add brand, approved media, soundtrack audio, or a smaller template set only
-  when the experience needs them.
+That compiler is needed only for source-owned templates. See
+[Custom templates](docs/custom-templates.md).
 
-VanillaSky does not provide an LLM, hosted generation service, narration, TTS,
-or speech synchronization. MP4/WebM encoding and export are application-owned.
-Completed videos can be stored as JSON and replayed without calling the LLM.
+## Go deeper
 
-Custom templates are optional. Only source-owned templates need the local TSX
-compiler: `npm install --save-dev tsx`.
+Completed chat responses are deterministic JSON and can be stored and replayed.
+MP4/WebM export remains application-owned.
 
 ## Documentation
 
 | Goal | Guide |
 | --- | --- |
-| Integrate with a coding agent | [Agent integration guide](docs/agent-integration.md) |
-| Build the first response | [Getting started](docs/getting-started.md) |
-| Copy the Next.js route and component | [Next.js integration](docs/integrate-nextjs.md) |
-| Connect another model | [Provider integration](docs/provider-integration.md) |
-| Understand grounding and prompts | [Prompt and input](docs/prompt-and-input.md) |
+| Run the complete chat | [Getting started](docs/getting-started.md) |
+| Set it up with a coding agent | [Agent integration guide](docs/agent-integration.md) |
+| Change or add providers | [Provider integration](docs/provider-integration.md) |
+| Customize the interface | [Customization](docs/customization.md) |
+| Understand prompts and grounding | [Prompt and input](docs/prompt-and-input.md) |
 | Add brand or viewer context | [Branding and personalization](docs/branding-and-personalization.md) |
 | Add media or soundtrack audio | [Media and soundtrack audio](docs/media-and-audio.md) |
 | Persist and replay results | [Persistence and replay](docs/persistence.md) |
-| Run a looping, self-refreshing channel | [Live channels](docs/live-channels.md) |
-| Create source-owned templates | [Custom templates](docs/custom-templates.md) |
 | Test routes and streams | [Test integrations](docs/testing.md) |
 | Deploy securely | [Production](docs/production.md) · [Security](docs/security.md) |
 | Inspect the API contract | [Public API](PUBLIC-API.md) · [Protocol](docs/reference/protocol.md) |
 
+Try a keyless template response in the
+[playground](https://vanillasky.ai/playground/), or visit
+[vanillasky.ai](https://vanillasky.ai/).
+
 Apache-2.0

package/dist/{bg-confetti-SHQI7ATB.js → bg-confetti-HITCGLGD.js}

@@ -4,7 +4,7 @@ import {
 import "./chunk-QAAO7OAY.js";
 import {
   TemplateText
-} from "./chunk-TCEHK2BW.js";
+} from "./chunk-YJJC4N4D.js";
 import "./chunk-L5BTTCZV.js";
 import {
   BrandGradientOverlay

package/dist/{bg-emoji-XYFRA63Q.js → bg-emoji-VU4UZYZN.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-QAAO7OAY.js";
 import {
   TemplateText
-} from "./chunk-TCEHK2BW.js";
+} from "./chunk-YJJC4N4D.js";
 import {
   Emoji
 } from "./chunk-L5BTTCZV.js";

package/dist/{bg-media-FEBATBT2.js → bg-media-L34PDQXJ.js}

@@ -5,18 +5,18 @@ import "./chunk-QAAO7OAY.js";
 import {
   SceneBackground,
   getMediaBackgroundProps
-} from "./chunk-6M6DATLW.js";
+} from "./chunk-MXZSDGZQ.js";
 import {
   TemplateText
-} from "./chunk-TCEHK2BW.js";
+} from "./chunk-YJJC4N4D.js";
 import "./chunk-L5BTTCZV.js";
-import "./chunk-HT6BGERF.js";
+import "./chunk-FRN6WKHA.js";
 import "./chunk-W3VDIBGR.js";
 import "./chunk-XTOXFMLM.js";
-import "./chunk-C6WVCZRW.js";
 import {
   hasSceneMedia
 } from "./chunk-224QNWRA.js";
+import "./chunk-5CDAM24P.js";
 import {
   resolveTokens
 } from "./chunk-XWWLKRNU.js";