framesail

Edit account — The account's default model and settings for one kind of generation, used when neither the call nor the item's prompt editor names one. voice_block needs provider and segment_video needs talking_head: each family keeps its own default.

Edit assets — Add a character, environment or object that Analyze Script missed, or rename one or rewrite its description. After a description change, render its reference image again (assets_generate asset_ids).

Generate reference images — Render reference images, which keep each character, environment and object looking the same in every segment. Needs both style template images. Without asset_ids it renders every asset with none, skipping ones already rendering, so a repeat never bills twice. Afterwards, view_image them to check likeness.

Read assets — The project's characters, environments and objects, each with its description (what every render follows), reference_image (null: not rendered; view_image it) and, for characters, voice_id. Each needs a reference image before the voiceover.

Delete — Permanently delete; irreversible, so confirm with the user first. project: it and everything in it. asset: a character, environment or object. music_track: a background music track. segment_extra: a segment's sound effect or overlay, with its scene layers. A segment's image, clip and voiceover can't be deleted.

Edit the video — Polish the video in the editor; changes show in the next export. scene_note: edit one scene with a note (move, restyle, add or remove layers and overlays, change the text of a lower third, title card or callout, change motion); spends credits. Returns the changes and skipped_mutations: edits that didn't land (applied=false) or landed differently than asked (applied=true), each with a reason; check them. Scene lengths follow the narration; the image, clip and voiceover layers can't be removed. project_note: a note for the whole video, applied to up to 10 scenes per call; spends credits. capti…

Read the editor — scenes: the editor timeline, one scene per segment, as {total, offset, returned, scenes}; scenes build on their own from the storyboard. music: {tracks}, timed in seconds. audio_library: tracks to add with editor_edit; when nothing matches, it lists the library's moods and genres.

Get generation options — What a generate call can be told to use. models: the allowed models with credit estimates and settings_schema (the valid settings keys); is_default marks the default (the account's saved choice, else Framesail's). Voice and clip models come in families, each with its own default: pass provider or talking_head for one family. prompt_sections: sections with entity_backed=false can be overridden with editable_sections; entity_backed=true sections show the item's own content (description, prompts, text, brief): change it with the edit tools.

Get status — Where things stand and what to do next; start and resume here. Always reports the account: plan, credits, credits held by running jobs, and credits_available to spend. project_id adds the project's settings, each step's state and web link, jobs with readable errors, export_url and next_step. channel_id reports the channel style instead: analysis_done, inputs_stale, templates, templates_stale and next_step. Without API access it reports only the account and subscription_needed: pass that on to the user.

Edit channels and projects — Create a channel or a project, or change a project's title, brief or video format. A new project takes its channel's style; a channel with no style needs one (style_edit action=create) before anything is generated. Share the returned web_url so the user can follow along.

Read channels and projects — Your channels, or the projects in one channel.

Render segments — Render segment images and clips, the biggest spend in the video: always run it with dry_run=true first and get the user's yes on the estimate. generate: without segment_numbers, everything not yet rendered (items rendering are skipped); with them, those segments, finished renders included, e.g. the first minute before the whole video. Overrides need segment_numbers and what=images or what=clips. animate: turn one segment's rendered image into a clip; animate only images worth motion. dry_run quotes the default clip or talking head model. A refused render leaves the segment as it was; to go …

Edit the script — Change the script or its settings; only revise spends credits. save: replace the active version's text (the old text is lost: show the user the current script first), then run Analyze Script. Notation, never read aloud: `[SCENE: <visual direction>]` as its own paragraph directs the storyboard for the narration after it, until the next one, over the director style. `<break time="1.5s" />` is the only thing that makes the voice pause (about 0.5s between thoughts, 1.0s between sections; one tag with the total, never two in a row). A paragraph starting `Name: "..."` is that character's dialogue.…

Generate the script or analyze it — generate: write the script from the brief and the narrative style; each run is a new version (review it with script_read). analyze (Analyze Script): find the script's characters, environments and objects (including any named only in `[SCENE: ...]` directions) and split it into voice blocks. Existing assets are kept as they are (description, reference image, voice) and new ones added; assets the script no longer names stay until the user deletes them. Review with assets_read.

Read the script — The active script, its versions, and the script settings (script_target_minutes, voice_mix, visual concept). Show the script to the user before Analyze Script.

Edit a segment — Change one segment without losing renders; only split spends credits. Returns the changed segments. set_prompts: write prompts verbatim, no AI rewrite. The renders stay as they are: render the segment again to apply the new prompts. set_continuation: make this segment's image continue an earlier one's (same composition, only the change); render the image again. rollback: restore one of the last 5 renders of the image or clip; the current one takes its place, so it can be undone, and the prompt editor's model stays as it is. split: cut into 2-4 parts; the inheriting part keeps the prompts and…

Restructure a segment — Change what a segment is. Every call previews first: when no rendered image or clip would be lost it runs; otherwise it changes nothing and returns what would be lost. Show the user, then call again with confirm=true. combine: merge with a neighboring segment. The kept segment's renders stay, retimed to the combined length, but go stale: its prompts are rewritten for the combined narration, so render it again after. The other's are deleted (the preview names it). change_type: to an image, real photo, B-roll (both fetched) or overlay segment. Clips and talking heads come from render action=a…

Edit storyboard settings — Storyboard settings, used by the next storyboard run.

Generate the storyboard — Plan the storyboard: every segment, its timing, image and motion prompts, overlays and continuations, following the channel style and any `[SCENE: ...]` directions. Needs the finished voiceover (its timing drives the cuts). It plans images, plus real photos and B-roll when the director style has the `@real-media` tag; clips come later, by animating rendered images. Running it again replaces the whole plan, edits included. The longest step (several minutes): get_status wait=true, repeatedly.

Read the storyboard — segments: {total, offset, returned, segments}. Each segment has its segment_number (the handle segment tools take), kind (image, clip, talking head, real photo, B-roll or overlay segment), narration, duration, direction, image_prompt, video_prompt (the motion when animated), media_queries (searches for a real photo or B-roll), the characters, environments and objects it shows, continues_from_segment (its image continues that earlier segment's image) and its assets. segment_assets: {segment_number, assets}: its image, clip, real photos, overlays and sound effects, each with kind, status, prom…

Edit the channel style — Create or change the channel style (one per channel, used by all its projects). create: offer the user two real options, never invented ones. (a) References (best): YouTube links of their channel or of videos whose look they like, or a written description. Analysis starts at once and writes the fields: wait with get_status channel_id wait=true, then render both template images (style_generate action=template). A reference informs every axis, narrative included; for its look only, give it contributes_to ["art_style"]. (b) Presets: one per axis, all three; instant, and the art preset brings it…

Generate for the channel style — analyze: read the references again and rewrite art_style, narrative_style, director_style and text_style, replacing hand edits. template: render one of the style's two template images. Reference images render on them (characters on the character template, environments and objects on the environment one) and segment images fall back on them, so finish both before any reference image. An existing one is refused unless replace=true: replacing it changes the look of everything rendered after.

Read the channel style — get: the channel style: its references, its fields (art_style, narrative_style, director_style, text_style, any added; script_prompt on request), the summary analysis wrote for each, and templates, the character and environment template images (null: not rendered; a URL: it exists, so view_image it rather than render it again). inputs_stale: the references changed since the last analysis (offer style_generate action=analyze). templates_stale: the art style changed since the templates were rendered (offer to render them again). presets: the preset catalog, one list per axis (art_style, narrat…

Edit voices and voice blocks — Voices and voice blocks; free. set_voice: the narrator's or a character's voice; every speaker needs one before the voiceover. rescan_blocks: split the active script into voice blocks again after an edit, assets untouched; blocks whose words are unchanged keep their audio. settings: the voice engine and narrator speed.

Generate the voiceover — Generate voice block audio. Every speaker needs a voice first, and every asset a reference image. Without voice_block_ids it fills every block with no audio, skipping ones already generating. A model must match the project's voice engine. An existing storyboard retimes to the new audio on its own.

Read voices and voice blocks — voices: one engine's voice ids, labels and preview audio, as {groups, voices}. blocks: the voice blocks (narration and dialogue) with their speaker, voice_id (the speaker's voice), audio and any `[SCENE: ...]` direction over them (never spoken), as {blocks, total_duration_ms, all_complete}.

Activate script version — Switch the project's active script to another saved version (ids come from get_script's version list — each generate_script run creates one; save_script edits the active version in place). Re-run scan_script / rescan_voice_blocks afterwards if the text differs, since downstream artifacts follow the active version.

Add music track — Add background music to the project from the audio library (find track ids with browse_audio_library, category="music"). Defaults loop the track under the whole video at bed level (volume 0.12 ≈ -18.4 dB under narration — don't raise it without being asked); re-run export_video to hear it.

Add segment sound effect — Attach a sound effect from the audio library to a segment (find track ids via browse_audio_library with category="sfx"). It lands on the segment's scene immediately — no build_scenes needed.

Re-analyze style — Re-run style analysis (after changing a style's inputs). Async — await_jobs(style_id=...) until the style_analysis job completes.

Animate segment — Animate one segment in a single call: flip it to a generated video shot (keeping its rendered image as the clip's first frame) and START the clip render immediately. BILLS video credits on this call — the segment's image must already be rendered (400 otherwise). A refused generation (out of credits, already running) rolls the flip back, so the segment is either animating or exactly as it was. This is the ONLY way to a generated video (voice=true for a Talking Head) — change_segment_type refuses that target; it owns the other kind switches (real media, overlay scene…

Wait for jobs — Block (server-side) until the scope has no pending/running jobs, or the timeout passes — use this instead of polling get_workflow_status yourself. Returns {done, jobs}. If done=false the work is still running: just call await_jobs again (a 3-5 minute storyboard takes a few consecutive calls). Keep timeout_seconds <= 50 so the client doesn't time out the tool call.

Browse audio library — Browse the audio library for background music and sound effects. category: "music" | "sfx". Returns {tracks} — track ids feed add_music_track / add_segment_sfx. Zero matches also returns the mood and genre tags the library actually carries, so retry with one of those rather than guessing new filter words.

Build scenes — Compile segments + assets + voiceover into the editor/render timeline (scenes). Run after segment assets are complete, before export. Returns a receipt — {scene_count, scenes: [{scene_id, segment_number, duration_frames, status, layer_count}]}; composition detail via list_scenes.

Change segment type — Change what a segment's base visual IS: a generated still ("image"), fetched real media (media_source="real" — a real photo for "image", stock b-roll footage for "video"), or an overlay scene. Generated video is NOT set here — it's the state a rendered still reaches through animate_segment (voice=true for a Talking Head), and a "video" target without media_source="real" is refused with that guidance. segment_type "image" with carry_frame=true reverts an animated shot back to its still for free. media_source="real" turns the shot into fetched media with no start fra…

Combine segments — Merge a segment with an adjacent one (segment numbers must be neighbors). keep: "this" | "other" — whose creative data survives: its assets are kept (rendered frame/clip marked stale against the combined narration and its prompts re-derived); the other segment's assets are deleted. Later segments renumber — re-check get_segments before further edits.

Create asset — Manually add a character/environment/object the scan missed. asset_type: "character" | "environment" | "object". The description is the generation-facing spec of its look — be specific. The scan reads narration and `[SCENE: ...]` directions, so the common miss is anyone NEITHER ever names — a host the video needs but no text mentions, a recurring set the script only implies. Name the asset exactly as the script or directions will refer to it so the storyboard binds the two, then generate_asset_reference it like any scanned asset.

Create channel — Create a new channel — the container for projects and their reusable styles. Use when the user wants a fresh creative identity rather than adding to an existing channel.

Create project — Create a project. The description (the video concept/topic) seeds script generation, so write a meaningful one. Pass video_format='portrait' for a vertical video — every shot, overlay, and the export are then composed for a 9:16 frame. The response's web_url is the project's page in the web app — share it so the user can follow along.

Create style — Create a style. Two mutually exclusive paths: References (best): inputs=[{"input_type": "youtube" | "text", "value": "<url or description>"}] — YouTube videos are watched (a channel link or @handle resolves to that channel's newest usable upload) and text directions read; async analysis writes the style's art/narrative/director fields: await_jobs(style_id=...) before using the style. (Image/video FILE references require the multipart REST endpoint POST /styles.) Presets (instant, no analysis): presets={"art_style": id, "narrative_style": id, "director_style":…

Delete asset — Delete a project asset (e.g. one the scan over-extracted).

Delete project — Permanently delete a project and everything in it (script versions, assets, voiceover, segments, renders). Irreversible — confirm with your user first.

Delete style — Delete a style (e.g. a failed analysis experiment). Don't delete a style that projects still use as their default — rebind them first with set_project_style.

Director note (one scene) — Edit ONE scene with a natural-language note (the same director chat the editor UI uses): move/restyle/add/remove layers and overlays, change motion, etc. Storyboard image, video and voiceover layers can't be removed. Synchronous — returns summary, mutations, skipped_mutations (edits that did NOT land, with reasons — check it) and the scene's layers ({id, name, layerType, segmentAssetId}); list_scenes(include_composition=True) has the full composition. Address the scene by project_id + segment_number (preferred) or a scene_id from a fresh list_scenes call. Scene…

Generate asset reference image — Render an asset's reference image in the channel's art style — the visual anchor that keeps a character/environment looking identical across every shot. EVERY character, environment, and object asset needs one before generate_voiceover (the server enforces this; fire the jobs for all assets, then one await_jobs). Async — the job writes the image onto the asset row: await_jobs(project_id), then list_assets and view_image the file_path to check likeness.

Generate script — Generate the project's script from its description/concept and the channel's narrative style. Async — returns {job_id}; poll get_workflow_status.

Render segment assets — Render every actionable segment asset (images, video clips, overlays) across the project, in dependency order. THE most expensive call in the pipeline: ALWAYS dry_run=true first, show your user the estimate next to get_credit_balance, and wait for a fresh yes before the real run — prior blanket permission ("do the whole thing") does not cover this spend. The staged flow is cheapest: asset_scope="no_clips" first (images + overlays), review, then animate_segment the shots that deserve motion. Pass segment_numbers to render only a subset — e.g. segments 1-18 for the …

Generate storyboard — Plan the full visual storyboard: segments, shot pacing, image/video prompts, overlays, continuation chains — driven by the channel's director and art styles. Requires voiceover to exist (timing comes from it). Plans generated stills + real media only (real media requires the style's @real-media tag); generated video is added per segment after the images render, with animate_segment. Async — returns {job_id}; this is the longest LLM step.

Generate style template — Render one of a style's two template images — a REAL step of style setup, not an optional extra: a style isn't finished until both its character and environment templates are rendered (the app shows them on the style card). Asset reference images render against them (characters → character template; environments and objects → environment template), and segment renders fall back on them when a shot has no asset reference — so finish BOTH before generate_asset_reference. Run once per template_type ("character" | "environment") for every new style; skip types the styl…

Generate voiceover — Generate TTS audio for the project's voice blocks. Without voice_block_ids it fills gaps: only blocks with no audio yet run, so re-calling it is always safe (already-generated and currently-generating blocks are skipped, never re-billed). Pass voice_block_ids to explicitly REgenerate those blocks (e.g. after changing a block's voice). Speakers must have voices bound first — set_narrator_voice / set_character_voice. Optional editable_sections/settings apply to every selected block (see get_section_template("voice_block") and list_models("voice_block")). On a pro…

Get credit balance — Current credit balance + plan info. Check before expensive steps (a full segment render can cost hundreds of credits — generate_segments dry_run gives the estimate). Jobs covered by a BYOK provider key bill 0.

Get pipeline progress — THE resume/orientation tool: one call returns every pipeline step's state (script -> scan -> reference_images -> voices -> voiceover -> style_templates -> storyboard -> segment_assets -> scenes -> export), any running jobs, and a next_action telling you exactly what to do next. Call this when picking up an existing project, after any await_jobs, or whenever you're unsure where a video stands — never guess pipeline position. Every step carries a web_url — the page in the Framesail web app where your user can see that step's output. Share it whenever you present a s…

Get project — Fetch a project row — settings, voice config, default style, export URL.

Get script — Read the active script's full text + the version list. Use this to show the script to your user for review/feedback before scan_script — the review-edit-resave loop (get_script -> discuss -> save_script) is the expected workflow when the user wants input.

Get section template — Inspect the prompt sections a generation job exposes for per-call override via editable_sections (jobs: script, script_scan, storyboard, segment_image, segment_video, voice_block, ...). Sections marked locked cannot be overridden.

Get segment assets — List one segment's assets (images/video/overlays) including their status, config (prompts, model), and public URLs of rendered files — pass an image's public_url to view_image to actually look at it.

List segments — List the storyboard's segments (narration span, type, duration, creative direction). The 1-based segment_number is the handle every segment tool takes (update/split/combine/continuation/regenerate) — you never need a UUID. Returns {total, offset, returned, segments}; on big projects page through with offset/limit rather than fetching all segments in one call. Each segment reports `continues_from_segment`: when set, this shot CONTINUES that earlier segment's frame (same composition, only the delta changes); null is a fresh shot. Adjust with set_segment_continuation…

Get style — Fetch one style row — its inputs (reference material), analyzed fields (art_style, narrative_style, director_style, script_prompt, ...), and `templates`: {"character": url|null, "environment": url|null}, the two template images. A null there means that template is genuinely missing and needs generate_style_template; a URL means it exists (view_image it) — don't re-render it. Show fields to the user for review; fine-tune with update_style_fields. `inputs_stale: true` means the references changed since the last analysis run — the analyzed fields don't reflect them; …

Get video download URL — Download URL for the most recent completed export.

Get workflow status — Poll this between steps: returns active + recently-finished AI jobs (scope by project_id, or style_id for style analysis), plus per-segment- asset render statuses for projects. A step is done when its jobs reach status=complete (or error, with a user-readable message). NOTE: finished jobs drop out of `jobs` after ~30s — a short list does NOT mean work was lost; judge render batches by `segment_assets` statuses (or get_pipeline_progress), never by counting jobs. Prefer await_jobs over polling this in a tight loop.

List assets — List the project's assets extracted by scan_script — characters, environments, objects. Each has a description (the spec every shot uses to render it — surfaced top-level here; the raw row nests it at ai_output.description), an optional reference image (file_path is a public URL — view_image it), and for characters a voice_id. Review these after scan_script: fix descriptions, then generate_asset_reference for each one (all of them need a reference image before voiceover). asset_type filter: "character" | "environment" | "object".

List channels — List your channels. Every project lives in a channel, which owns the reusable styles (art/narrative/director) that drive generation.

List models — List the models allowed for a generation job, with display names, credit estimates, and each model's settings_schema — the valid keys for that tool's `settings` param (e.g. image quality/orientation, video duration). When model is omitted the server picks: the scope's saved expert-drawer choice if one exists, else the account's default for the job (set on the account page), else the first entry here. The list is personalized — the account default is listed first with its saved settings as the schema defaults. Jobs whose models split into families (voice_block by pr…

List music tracks — List the project's background music tracks (volume, loop, timing).

List projects — List projects in a channel.

List provider keys — List registered BYOK providers (masked — only the last 4 characters). Returns {keys: [...]}; an empty list means no keys are registered (every job bills platform credits).

List scenes — List the project's scenes in timeline order. Default rows are light summaries ({scene_id, segment_number, duration_frames, status, layer_count}) — enough to address a scene by number or id; include_composition=True returns the full layer/layout JSON (bulky — page with offset/limit on long projects). Returns {total, offset, returned, scenes}.

List style presets — The curated preset catalog for the no-AI style creation path, grouped by axis (art_style / narrative_style / director_style). Show the user the labels + descriptions and let THEM pick one per axis — don't choose silently. Art presets include preview image URLs (view_image works on them). Create with create_style(presets={axis: id, ...}) — instant, no analysis job. Full field text lands on the style row (get_style shows it after creation).

List styles — List the channel's style rows (variable groups). Styles hold the art_style / narrative_style / director_style / script_prompt fields that drive every generation step, plus any custom @variables.

List voice blocks — List the project's voice blocks (per-speaker narration chunks) with their audio status and assigned voices. A block's `scene_direction` is the script's `[SCENE: ...]` direction governing it (never spoken; null when the span carries none). Word-level subtitle timings are stripped unless include_subtitle_data=True.

List voices — List available TTS voices (id, label, preview audio URL) for a provider: "minimax" (default engine) or "elevenlabs". Match the project's voice_tts_provider (see get_project) so picked ids work with its engine. Returns {groups: {name: count}, voices}; the ElevenLabs catalogue is 150+ voices, so pass group (names from `groups`) rather than reading it all at once.

Director note (whole project) — Apply a project-WIDE director note ("make the intro punchier", "all captions bigger"). A routing pass picks the scenes the note applies to and edits each — at most 10 scenes per call, so a change touching more needs repeat calls or per-scene director_note. Synchronous — a few seconds per scene. Returns per-scene results (summary, mutation_count).

Regenerate segment asset — Regenerate a segment's primary image or video with optional overrides — the API equivalent of the editor's expert drawer. asset_type: "image" | "video" (for a video segment, "image" targets its start frame). Use a different model, override prompt sections (see get_section_template("segment_image")), or tweak settings (e.g. image quality), then re-run just this asset. Async — returns {job_id}.

Remove music track — Remove a music track from the project.

Remove segment asset — Delete a segment's sound effect or overlay (lower third, title card, callout) — the asset and every scene layer built from it, immediately. These are the only removable assets: the segment's image, video and voiceover are structural. With one SFX/overlay attached, no id needed.

Rescan voice blocks — Re-extract voice blocks from the active script WITHOUT touching assets or their reference images — the non-destructive alternative to scan_script after a script edit. Blocks whose spoken text is unchanged keep their audio; only edited blocks come back empty, so a follow-up generate_voiceover fills just the gaps. Synchronous and free — the split is deterministic. Returns {block_count}.

Revise script — AI-rewrite a passage of the active script in the project's narrative voice (the same in-editor revise the UI offers). selected_text must appear verbatim in the script; omit it to revise the whole script. `[SCENE: ...]` directions in range are preserved exactly, in place, unless the instruction asks to change them. Synchronous — returns {revised_text}, which is NOT saved: splice it over selected_text (or replace the full script) and call save_script to keep it.

Restore previous render — Restore a previously rendered version of a segment's image or video — every regeneration archives the render it replaces (last 5), so a regen that came out worse is reversible for free. The current render is archived in its place, making the rollback itself reversible. The frame/clip pair restales as usual: rolling the image back marks a rendered clip out of date.

Save script — Save script text (your own draft, or an edited version of the generated one). Saving UPDATES the active version in place — the previous text is not kept, so show the user the current script (get_script) before overwriting it. New versions are created by generate_script runs, and activate_script_version switches between those. Run scan_script afterwards so assets and voice blocks reflect the new text. Three notations the script text carries, none of them ever spoken: SCENE DIRECTIONS — `[SCENE: <visual direction>]` as its OWN paragraph (blank line before and a…

Scan script — Analyze the active script: extracts character/environment/object assets and splits narration into voice blocks. DESTRUCTIVE on re-run (assets are recreated, not merged — curated descriptions, reference images, and voices are lost; prefer rescan_voice_blocks after script edits). Extraction reads the narration AND any `[SCENE: ...]` directions — a character or place named only inside a direction is still extracted, under the exact name the direction uses. Directions never leak into voice blocks (they ride onto the blocks they govern as staging instead). Review l…

Set character voice — Bind a TTS voice to a character asset — required before generate_voiceover for every character with dialogue (the narrator's voice is separate: set_narrator_voice). Browse ids with list_voices.

Set narrator voice — Set the project's narrator TTS voice — required before generate_voiceover whenever the script has narration. Browse ids with list_voices. (Character dialogue voices are separate: set_character_voice.)

Set project style — Set the project's default style — the style whose art/narrative/director fields drive its generations. Use after create_style to put a new visual identity into effect, or to switch a project between channel styles.

Set provider key — Register a BYOK provider API key (encrypted at rest, BYOK plan only). Jobs whose model belongs to this provider then run on YOUR key and charge 0 credits. Providers: openai, gemini, anthropic, fal, elevenlabs, minimax.

Set segment continuation — Make a segment's image render as a continuation of an EARLIER segment's frame (same composition evolving — the storyboard's continues_from_segment, settable after the fact). continues_from is that earlier segment's number; pass 0 to clear the link. Regenerate the segment's image afterwards — the reference is applied at generation time.

Split segment — Split a segment at the given time offsets (ms, 1-3 cuts → 2-4 parts). inherit_index picks which resulting part keeps the original creative data — that part keeps its rendered assets, SFX, overlays and continuation links (a rendered clip goes stale; re-render it). The other parts start fresh. Later segments renumber — re-check get_segments before further edits.

Update asset — Rename an asset and/or rewrite its description. If the look changed, regenerate its reference image afterwards so renders match.

Update caption config — Merge a patch into the project's burned-in caption config (keys like enabled, plus styling). Read the current value from get_project (caption_config). Applies at the next export — no rebuild needed.

Update music track — Tweak a music track. fields keys: name, volume (0-1), loop, start_frame, duration_frames, position, trim_start_frame, trim_end_frame.

Update project — Patch project fields. Updatable: title, description, sfx_level, video_concept, voice_mix, voice_tts_provider, script_target_minutes, narrator_speed, video_format. (The narrator's TTS voice is NOT here — use set_narrator_voice.) narrator_speed is the narration rate (0.5-2.0, default 1.0; clamped to 0.7-1.2 on ElevenLabs). It changes how fast words are SAID and nothing else — it adds no silence between them, so "slow this down" usually wants `<break>` tags in the script text too (see save_script). video_format ('landscape' | 'portrait') is only changeable until…

Rewrite segment content — Rewrite one segment's creative direction from feedback ("make this shot a close-up", "show the machine from above") — an LLM rewrites the shot's prompts; continuation links, SFX, and overlays are preserved. The visual assets reset to not_started: re-render them afterwards (generate_segments or regenerate_segment_asset). When you already know the exact prompt text, use update_segment_prompts instead — it writes your words verbatim with no LLM in the loop.

Update segment prompts — Set one segment's final prompts VERBATIM — no LLM rewrite. The direct counterpart to update_segment_content: your text is written as-is to the segment's creative direction and to the matching asset configs the renderer reads. Asset statuses are untouched: an already-rendered asset stays complete, and generate_segments skips complete assets — so to see the edit rendered, call regenerate_segment_asset on that segment (the ONLY re-render path after a prompt edit). Continuation links, SFX, and overlays are untouched. Pass only the prompt(s) you want to change; medi…

Update style fields — Hand-edit a style's analyzed fields after reviewing them — e.g. tighten the art_style wording or adjust the director_style pacing rules. `fields` is a PATCH, merged over what the style already has: send only the keys you are changing and leave the rest out — there is no need to read the whole dict back with get_style and round-trip it. Pass {key: null} to delete a user-added key (the well-known art_style / narrative_style / director_style / script_prompt cannot be deleted, only rewritten, and cannot be set empty). Editing fields does NOT trigger re-analysis, so yo…

Update style references — Replace a style's reference set — add or remove references without touching the analyzed fields. FULL REPLACE: read the current list with get_style first and send every entry you're keeping plus the changes. New entries are youtube (video link, or a channel link/@handle) or text; new image/video FILES can only be added via the multipart REST endpoint PATCH /styles/{id}, but existing ones round-trip fine. Optional `contributes_to` scopes an entry to a subset of the analyzed fields (art_style / narrative_style / director_style); omit it for all three. Savin…

Update voice block — Override one voice block's voice or playback volume (block ids from list_voice_blocks). Re-run generate_voiceover for the block afterwards if you changed its voice — existing audio is not regenerated automatically.

Who am I — Verify the connection: the account email and plan behind the current credential. Call once after connecting — before creating anything — to confirm you're on the right account; costs nothing.

Remove segment asset — Delete a segment's sound effect or overlay (lower third, title card, callout) — the asset and every scene layer built from it, immediately. These are the only removable assets: the segment's image, video and voiceover are structural. With one SFX/overlay attached, no id needed.

Remove segment sound effect — Remove a sound effect from a segment. With one SFX attached, no name needed; with several, pass sfx_name (the asset name shown by get_segment_assets).