CueFrame

Tools

• compare_framesCompare a certified reference frame with an existing full-resolution PNG preview. Returns unaligned side-by-side and overlay images with exact source identities. Read editorial_run_source for the reference identity and preview_frame then wait_job for the candidate artifact. This call never rerenders or edits the composition. Frame numbers refer to the certified representation; use explicit event correspondence after intentional retiming. Optional views and identical-coordinate crop change only diagnostic evidence.
• editorial_run_sourceRead the certified decode representation for media selected in this project before starting an editorial run. Supply projectId and mediaId; a null representation means this source cannot be pinned. The response omits internal storage paths. Select a bounded range from the returned frameCount and exact fps ratio; do not invent a source identity.
• editorial_list_briefsRecover persisted authored briefs for a project. Read bounded pages; pass nextCursor as cursor until done. Brief IDs link to editorial runs.
• editorial_list_runsRecover persisted editorial runs for a project in bounded pages. Pass nextCursor as cursor until done, then read each relevant run for its integration decisions and unresolved gaps.
• editorial_get_runRead a persisted editorial run, including its revision, state, inputs, outline, selected finding IDs, omitted reasons and unresolved integration gaps. Read findings and evidence separately for complete coverage.
• editorial_list_evidenceRead delivered evidence and inspection coverage for a run in bounded pages. Pass nextCursor as cursor until done; an empty page does not prove the whole source was inspected.
• editorial_findings_listRead durable observations, including useful, nothing-useful and uncertain outcomes, in bounded pages. Pass nextCursor as cursor until done; retain evidence IDs, supersession and uncertainty when recovering decisions.
• editorial_create_briefPersist an authored brief for the selected project. The projectId belongs in body.brief; use the returned briefId to start an editorial run.
• editorial_create_runStart an editorial run from a persisted brief and explicitly selected certified source ranges. Read editorial_run_source for each project media source first; use its exact identity, revision, frame count and fps ratio. Never invent a source pin or infer inspection from an index.
• editorial_inspect_sourceDeliver one exact decoded source frame as JPEG and save its evidence receipt. Only that sampled frame is visually inspected; preserve the returned evidenceId and coverage.
• editorial_sample_motionDeliver bounded sampled motion frames and save their evidence receipt. The sampled frames do not certify continuous visual coverage.
• editorial_inspect_audioDeliver a bounded 16 kHz source audio interval and save an audio evidence receipt. The interval must lie inside a certified run input.
• editorial_inspect_transcriptDeliver at most 100 verified transcript words with their mapped certified decode interval and save a transcript evidence receipt.
• editorial_findings_appendPersist one evidence-backed observation. A nothing_useful outcome may cover only what the cited evidence actually inspected; sparse stills do not certify an unsampled interval.
• editorial_integrateSave selected finding IDs, explicit omitted reasons and unresolved gaps with the observed run revision. Read the run and findings before deciding.
• editorial_applyCommit an integrated editorial edit to the saved project composition with both runExpectedRevision and guarded composition fields. Preserve the observed concurrency basis and the composition journal identity: nested composition.commandId must equal composition.clientId + ":" + composition.sequence. The session call commandId is a separate HTTP request identity.
• composeStart an async Director compose job: it authors an ensemble of full composition candidates, verifies each, and saves the winner to the project. Body must set EXACTLY ONE source (mutually exclusive): `briefId` — author FROM a persisted Brief (the PLANNED path: create_brief first; every Brief field is honored or the compose is refused loudly naming the field); `fromComposition: true` — author from the project's CURRENT composition (the GENERAL path: seed it with apply_composition first — your media clips are the intent, and any graphics you authored are CARRIED VERBATIM as locked clips the Director authors around, never re-authors or drops); or `suggestionId` — author from an AI clip suggestion (the CLIPPING path, paired with suggest_briefs). Returns { composeJobId, status, streamUrl }. Then call wait_job(kind="compose", id=composeJobId, projectId=...) to block until the winner is selected.
• apply_compositionAtomically apply an array of CompositionOps to a project composition. All ops succeed or none do (transactional). Call describe_composition_ops without type for the compact operation list, then with a type for its exact JSON Schema. For negotiated component execution, read get_composition with componentExecutionVersions=["3","4"] and includeDependencies="true", then send componentExecutionVersions:[3,4] and that exact expectedBrandIdentity. A changed brand refuses the command; never refresh the witness to conceal a conflict. Explicit builtinSources selectors attach only the approved exact source pins referenced by the final composition. The additive `concurrency` envelope requires an endpoint confirmed to enforce guardedCompositionV1; unsupported hosted endpoints refuse it with unsupported_concurrency. Obtain dependency expectations from the observed composition; never rebuild a stale basis from current state. Every committing call REQUIRES `if_match`, the composition ETag from a fresh get_composition, or the `concurrency` envelope; a call with neither is refused with 428 precondition_required. On 409 stale_etag, read get_composition again and reconsider the batch against what changed; never copy the error's currentEtag into a retry without that read. `dry_run: true` validates the batch without persisting and needs no revision. Ops land on the project's ACTIVE composition unless you pass `composition_id` (mutually exclusive with `session_id`), which targets a specific one — that is how you author a second composition minted with new_composition and run an A/B. Use this to seed a composition (add media clips) or make targeted edits (set a crop intent, reorder clips, set the format). CAPTIONS FOR EDITED TIMELINES: after saving all clip edits, call again with {type:"captions.fromComposition", trackId} to build captions from every audible clip on that track, honoring trims, exclusions and placement. Clips must have duration matching playable source duration divided by p
• validate_compositionDry-run a full Composition object against the SAME pure, DB-free authoring guards saveComposition enforces, WITHOUT persisting it (no project needed). Checks: wire shape (Zod), primitive membership (unknown_primitive / custom_missing_sourcecode), required-param shape (invalid_primitive_params), clip↔track family (clip_source_track_mismatch), and reframe coverage (reframe_coverage_gap). Always returns ONE shape — 200 { valid, errors, quote } — for BOTH malformed wire shapes and deep-invariant failures (so branch on `valid`, not on HTTP status); errors[] lists every problem at once as a sanitized envelope { code, stage, category, retryable, message, fix } you can fix before composing/rendering. The `quote` triple states the render price to finish from a valid composition — relay it to your human BEFORE create_render. `valid:true` means save-safe EXCEPT for the three genuinely DB-bound checks that can only run at save/render, because this tool takes no project: trim-bounds (needs the media duration), image/asset-on-a-video-track (needs the media kind), and componentId resolution (needs the installed components of YOUR org — a `{kind:'component', componentId, props}` clip naming a component you have not created, or naming a CATALOG PRIMITIVE, passes here and is refused at save with `component_source_unavailable`). Pass the Composition as `body`.
• create_renderQueue an MP4 render of a project's composition (in a compose session, the session's scratch). Returns { id (renderId), status, warnings? } — `warnings[]` carries non-fatal advisories (omitted when none). The render themes from the project's brand kit (bind one via create_project / update_project with brandKitId — or PATCH /projects/:id over REST; without one the output is unbranded). Then call wait_job(kind="render", id=renderId, projectId=...) to block until the file is ready and get the download URL, or register a webhook (create_webhook on render.completed — status rides the payload).
• preview_frameQueue durable still-frame evidence for layout/copy judgment. Returns immediately with {jobId, kind:'preview_frame', status}; then call wait_job(kind="preview_frame", id=jobId) for artifact metadata and up to four embedded frame images; fetch failures or payload limits may return fewer. Use wait_job imageIndices to read other original image artifacts from the completed job, at most four indices per call, without rendering again. Repeating the same arguments repeats the same selection. Artifact URLs alone are not observed pixels. The immutable snapshot records geometry, layers, warnings, and whether the target was persisted, inline, or session scratch. A still cannot prove motion — use preview_clip or preview_component for animation.
• preview_componentQueue a typed preview artifact for ONE org-installed component — ASYNC: returns a jobId immediately; then wait_job(kind="preview", id=jobId). The preview and production compositor consume the same content-addressed component bundle and verified artifact contract. `body.componentId` selects the component; pass `body.params` to render it with props (the mount's `params`); declared manifest slots are bound separately and reach the scene's `assets`, never params. Admission/runtime/capability failures land on the job terminal with sanitized author-fixable messages. Idempotent per immutable render key.
• preview_clipRender a scoped, cheap MOTION preview — ONLY body.fromSec→body.toSec of the composition (max 60s) at preview quality (capped resolution, lighter encode) through the real render pipeline. THE way to judge motion — a cut, a transition, a component's animation — at full fidelity BEFORE paying for a full render (a still cannot show motion; a full render costs the export). ASYNC: returns a render job; wait_job(kind="render", id=renderId) or a render.completed webhook for the URL. Meters the capture feature, never an exports credit.
• score_compositionQueue the durable server-side judge — it snapshots the exact authored target, samples eval beats, captures frames asynchronously, and grades editorial/spatial/brand/caption. Then wait_job(kind="verify", id=jobId) for per-criterion scores, weighted composite, worst-first critique, and checkpointId. `body.composition` is optional (absent ⇒ ACTIVE). Fix the lowest criterion via apply_composition and re-score. Idempotent per immutable snapshot; compose_verify bills only on the guarded success terminal.
• consultAsk the Director for editing advice on the project's CURRENT composition — it NEVER writes your composition (you stay the decider). Async: returns a consultJobId; then wait_job(kind="consult", id=consultJobId, projectId=...) surfaces the advisory envelope (assessment / proposals / principles / plan). `body.mode`: 'advise' = the planner agent (fast, ~30s-2min) returns a `plan` (framing/cuts/captions/graphics intents) as GUIDANCE you re-author from — no grounded scores, nothing to adopt; 'amend' (default) = the full author→judge→refine loop (minutes) returns a graded `assessment` + a fix candidate you ADOPT via select_candidate with its candidateIndex. ('explore' is coming soon → use amend.) `body.intent` = your goal in plain English; optional `body.focus` (editorial|spatial|brand|caption); `body.ifMatch` binds to your current etag. Use advise for a fast directional nudge, amend for a grounded, adoptable fix.
• resumeAnswer the checkpoint packet wait_job reported as awaiting_input (its {checkpointId} — read the packet FIRST with get_checkpoint and relay the stills + money triple to your human). ONE `body.decision` per gate: 'approve' (proceed; comments allowed — they record as taste without gating), 'revise' (the director revises per your `body.comments` [{anchor: {beatId}|{timecodeMs}, verdict: 'approve'|'revise'|'lock', note}] and/or `body.edits`, then RE-PRESENTS this same gate as a new packet — in-job, no new charge; the brief quote states the included revision cycles, beyond them revise is refused 402), or 'abandon' (end the run — the only terminal refusal). 'lock' freezes an element contractually: the director touching it surfaces as a lock_violation verdict on the next packet. On approve/revise the Director rehydrates its warm box and continues; then wait_job again.
• create_briefPersist the video's INTENT as a Brief — the Director's rich input contract (spec: the storyboard skill's output lands here). Fields: goal (required), audience, platform, format, durationSec, tone, cta, locale (output language — all on-screen copy + captions), hook, caption, beats[] (each with an editorial intent and optional MOMENT PINNING {mediaId, startSec, endSec} — honored to-the-frame or refused), mustIncludes, captions {styleId, emphasisPhrases} (the big-serif emphasis treatment), motionStyle, seededGraphics (your authored overlay/component/card clips, carried VERBATIM as locked clips — never re-authored), exclusions (hard negatives: graphic kinds the Director must NEVER author + 'no-transitions'), gates {holdAt, autoApprove}. Then compose it: compose with {briefId}. The response carries the QUOTE (compose + estimated render) — relay it to your human BEFORE composing.
• get_briefRead a brief by id — the persisted intent plus its current quote (compose + estimated render).
• list_briefsList briefs. DEFAULT shows human-authored briefs only; kind:"clip" shows the machine-minted clip briefs (suggest_briefs output), kind:"all" shows everything. Each carries its quote.
• get_checkpointRead a checkpoint packet — the durable approval unit a held compose pauses at (wait_job reports awaiting_input with {checkpointId, stage, version}). Carries the stage artifact, presigned storyboard stills (REVIEW THE EVIDENCE, not raw JSON), critic verdicts, the money triple {thisStepUsd, jobSpendSoFarUsd, estimatedJourneyTotalUsd} to relay to your human, and the recorded decision once resolved. When the Brief's gates set reviewMode:'hosted' the packet also carries reviewUrl — a browser review page where your human decides directly (relay THAT link instead of raw stills; you learn the decision via checkpoint webhooks / wait_job). Answer an awaiting packet with resume(checkpointId, ...).
• list_checkpointsList checkpoint packets newest-first (filter with composeJobId for one run's v1→vN gate history, or projectId). The version stack with per-version status + decisions IS the review history — nothing is deleted.
• update_briefEdit a brief (partial). REFUSED with 409 while an ACTIVE compose job references it — finish, resume, or abandon the job first (the Director never has its input edited mid-run). Edits apply to the NEXT compose.
• delete_briefDelete a brief. Compose jobs already run from it are unaffected (they snapshot).
• select_candidateSelect one candidate from a finished compose/consult ensemble as the project's saved composition (whole-candidate replace). Body REQUIRES both fields: { candidateIndex, selectStrategy: "agent-authoritative" } — candidateIndex from wait_job(kind="consult") proposals (mode=amend) or the compose winner report; selectStrategy is required and API keys must use 'agent-authoritative' (editor-merge/editor-replace need an editor-session token and 403 on an API key). agent-authoritative replaces the saved composition unconditionally and ignores ifMatch, so read get_composition first and adopt only when no edit made since the consult or compose must survive. After selecting, render with create_render.
• create_componentCreate and store a custom component for the tenant: a native scene that arranges its declared images and videos as tiles in 3D space. Returns the ComponentResponse (id + metadata) you can then reference from a composition. No project arg — components are tenant-scoped. SOURCE CONTRACT (version 4; the server instructions' Component Contract has the full rules and an example): send the complete source object {version:4, componentId, template, manifest, definition}. `template` is one sub-composition: a root <div id="root" data-composition-id="<componentId>" data-width data-height data-no-timeline data-composition-variables='…'> holding <div data-cf-scene></div>, and one inline script ending in __cfScene.mount({ root: document.getElementById('root'), component, variables: __hyperframes.getVariables() }). data-composition-variables is the definition's projection (scalar inputSchema properties, then manifest slots). The manifest is {version:4, runtime:'hyperframes', hfContract:1, kind:'scene', assets, graphics:{api:'webgl2',…}, alphaPolicy}; slots are image or video. The source is admitted before it is stored: template lint, determinism (no timers, Date, network or CSS animation) and the declaration are checked, and a refusal names the rule. A version-3 source is retired and refused as component_source_retired. Place it with execution {version:4, componentId, sourceVersionId, params, seed, assets:{ slot: mediaId }} and placement {version:3, kind:'clip'}; slots never travel in params.
• list_catalogUse projection:'component-library' for the unified source-free library page, returned as complete JSON with exact scoped definition/preset/recipe cards and pagination. Choose origin:'builtin' for the maintained builtins or origin:'library' for the authenticated serving home; use libraryKind, category, q, limit and after to filter/page. Preserve each card identity.scope and identity.revision, its source/definition pin or exact recipe document identity; same names/IDs in different scopes remain distinct. Resolve the selected exact source with sourceVersionId (plus builtinCollection for an explicitly selected builtin), never a latest-head or another-home lookup. Presets identify their exact presetVersionId, definition pin and historical document witness; recipes identify their complete exact document and member source pins. This projection contains no source bodies or legacy thumbnail substitution. Omit projection for the historical catalog protocol below. DISCOVER WHAT TO BUILD WITH — list the component catalog: the one built-in primitive (heroText, the behind-subject overlay) plus your org-installed components. Desktop also includes bundled kind:'component-package' entries: these are complete reusable authored packages; insert them with the desktop apply_template tool using placement.template and explicit insert.startTime/idPrefix, media bindings and parameter values. Do not pass their ids to clip.add, get_component_source, or cueframe://component resources. Their draft status does not certify visual review or licensing. For hosted builtin preset/recipe cards, call resolve_builtin_component with the exact collection, id and revision, then apply_template with template:<builtin id> and body:{projectId,documentSha256,insert:{startTime,idPrefix},...}. Hosted tool request fields live under body; desktop tool shapes may differ. The agent-safe default page is 20 entries; use pagination.nextCursor as `after`, or narrow with category, kind, tier, useCase, mood, q, or intent.
• resolve_builtin_componentResolve a selected builtin component-library card using its exact collection, id and revision. Returns the canonical pinned document and source snapshots for a preset or recipe, or the exact source for a definition. Preserve documentSha256 and all identities; a missing revision refuses without falling back to another version or scope. Resolve before apply_template; do not invent wrapper source or reconstruct a package from a thumbnail.
• list_templatesList this organization's saved templates. Follow pagination.nextCursor with after to read further pages. Public catalog slugs are not enumerated here; read a known public slug with get_template.
• get_templateRead a saved organization template by id or a known public catalog template by slug. The answer is a summary: the media and value parameters with their kinds and options, presets with their values and brand kit, the brand kit, rubric, components (id, version, asset slots) and an outline of the tracks and clips; never component sources (read one with get_component_source, or pass full: true for the whole document). Use the exact reference with start_template or apply_template. Do not invent a slug from a component-library card.
• apply_templateInsert a resolved builtin component package into an existing project. Pass template as the selected builtin id and body with projectId, the resolved documentSha256, insert:{startTime,idPrefix}, parameter values and explicit media bindings. Read get_composition first and retain expectedRevision, commandId, componentExecutionVersions:[3,4] and expectedBrandIdentity as required by the contract. Insertion preserves existing timeline content and package source offsets. Select pinned samples explicitly with media:{slot:{sample:true}}, or bind real media IDs. Missing required media is refused; samples are never selected implicitly. A stale revision, pin or brand refuses; do not silently refresh the witness. For ordinary templates, this operation retains its existing apply behavior.
• get_component_sourceRead an exact component source as complete JSON. Supply sourceVersionId from the selected catalog card to read that immutable revision, retaining sourceSnapshot with its complete versioned definition, manifest and template beside its exact pin and schema metadata. For an explicitly selected builtin, also supply builtinCollection:'native'|'curated-definitions' and its exact sourceVersionId; without builtinCollection resolution is scoped to the authenticated org. An unavailable exact pin refuses; never retry a head or another scope. To fork, keep the version-4 snapshot whole, change its componentId (the template root's data-composition-id too) and template, and send it to create_component. Builtins always require an exact collection and pin; ID-only builtin reads are refused. Declared slots are bound per placement in execution.assets, never caller params.
• get_media_contextFetch bounded authoring context for a media item: dimensions/thumbnail, compact face roster, transcript counts/sample, temporal grids, and fact readiness. Transcript and word-grid counts cover one page only (default 20 utterances); pass transcript.data.pagination.nextCursor as after to get_media_context for the next context page, or use get_transcript for exact paginated word timings.
• get_transcriptRead exact source-time transcript words in bounded utterance pages. Word start/end values are seconds from the source media start. Default limit is 20; pass pagination.nextCursor as after for later pages. The formatter omits the unbounded fullText duplicate.
• prepare_mediaPrepare the perception artifact an authored edit needs BEFORE sighted review. Pass body.kind="subjectTrack" for face/active-speaker reframing, or body.kind="matte" for a true zPlane:"behind-subject" graphic. Pass body.intent {startSec,endSec} using SOURCE time (the media trim, not timeline time); it is required for mattes and strongly recommended for subject tracks so the prepared fact exactly matches the clip and quote. This is the supported product path — never accept a preview that silently flattens depth or ignores speaker tracking. Returns a fact receipt; with intent, poll get_media_facts using the same kind/window until exact.state is ready; without intent, omit all three filters and find the whole-source subjectTrack in facts until status is ready (failed is terminal). Existing pending/ready facts are reused without another charge.
• get_media_factsRead prepared subject tracks and behind-subject mattes for one media item. For an exact readiness check, pass kind + startSec + endSec together using the same SOURCE window sent to prepare_media; exact.state is pending | ready | failed | available | unavailable. If subjectTrack was prepared without intent, omit all three filters and check the whole-source subjectTrack in facts instead. Wait for the required fact to be ready before preview_frame / score_composition.
• list_mediaList the media in your CueFrame library. Filter a real library with kind (video|audio|image|gif|asset|source|stock), source (upload|generated|import-url|stock), or tag — so you find YOUR footage, not e2e debris. Returns media item IDs and metadata; use an ID with get_media_context, suggest_briefs, or as a composition source.
• download_mediaGet a presigned download URL for a media item's stored SOURCE file — the bytes CueFrame composes from (the raw upload, or its conformed transcode). This is how you copy media OUT of a library: fetch the URL directly (no auth header) and PUT the bytes elsewhere with create_upload, or hand it to import_media on another account. Works as soon as the upload or import is stored, before processing completes. The URL expires at `expiresAt` (about an hour) — call again for a fresh one rather than caching it. Read-only and free; nothing is persisted. For a render's MP4 use refresh_render_url instead.
• get_renderRead ONE render's record without waiting on it: status, progress while it runs, outputUrl + outputExpiresAt once complete, the typed failure (errorCode / category / retryable) if it failed, and WHAT RENDERED — compositionId (the composition it froze), format (aspect/fps/resolution it encoded at), engine, createdAt / completedAt, outputDurationSec, and the preview window for a preview_clip. Free, read-only, instant — use it to audit or correlate a past render (which composition, when, how long) where wait_job would block; wait_job remains the way to block until a running render finishes. An expired outputUrl is refreshed with refresh_render_url.
• refresh_render_urlRe-sign a COMPLETE render's output URL. A render's presigned MP4 link lasts ~7 days, so wait_job / getRender on an old render hands back a link that 403s; this mints a fresh one for the same file and returns { outputUrl, outputExpiresAt }. Needs projectId + renderId (from create_render). 422 render_not_complete while the render is still running or failed — wait_job for it first. Requires renders:write (the row's stored URL is updated).
• create_projectCreate a new project — the unit you compose and render into. compose / apply_composition / create_render / the preview family all require a projectId; this mints one. Pass name (required) plus optionally a format (aspectRatio/fps/resolution) and brandKitId. brandKitId binds a brand kit to the PROJECT (pass the kitId from create_brand_kit): colors/fonts/motion theme every render of this project automatically (omit it and the output is unbranded). Bind or change it later via update_project (PATCH /projects/:id over REST). Returns the ProjectResponse (id + metadata).
• new_compositionCreate a NEW composition (a new video) inside a project — a project is a workspace that holds many videos. Returns { compositionId, format, etag }. Pass an optional name and format (aspectRatio/fps/resolution); format defaults to the project's compositionFormat. The first composition becomes the project's active default. To author it, seed with apply_composition then compose({ fromComposition: true }) — your authored graphics ride as locked clips, carried verbatim; to render a specific one, pass its compositionId to create_render. (For a reframed sibling in another aspect, use derive_composition.)
• get_compositionRead a compact structural composition view by default, preserving observed ETag, authority metadata, clip timing, token values and source pins without large HTML bodies. Ordinary exact-ETag reads can omit includeDependencies. With includeDependencies=true, compact returns a dependency key/size index, not executable tokens; these tokens can contain full sources. Request explicit dependencyKeys for exact selected tokens, or response:"full" for all tokens. Selection does not establish a sufficient operation basis. Use clipIds:[id] with response:"full" for complete exact selected sources; unknown IDs are refused. Use response:"full" without clipIds for the original full backend JSON. Local response/clipIds/dependencyKeys arguments never reach the backend. READ BACK a composition as JSON — the edit itself: tracks, clips, card HTML, reframe segments, captions, markers, format. This is what create_render encodes, so it is also what you hand to validate_composition (which needs a full inline composition body), what you diff after an edit, and what you archive/share so someone else can re-render the SAME video. Read-only and free. Authoring stays op-based (apply_composition) — do not round-trip this object back as a write. A composition too large for routine model context can be read selectively with clipIds and response:"full"; the compact view explicitly identifies omitted source bodies. Defaults to the project's ACTIVE composition; pass `compositionId` to read a specific one (the same id apply_composition takes as `composition_id`, and preview_frame / create_render take as compositionId) so an A/B variant can be read back, not just written. The result includes the exact HTTP etag string; copy it to apply_composition.body.if_match (the numeric revision is not an ETag). In a compose session this reads the session's scratch, the composition its edits, previews and renders target. Pass includeDependencies="true" on a v1 guarded endpoint to read composition_id, revision and de
• list_compositionsList every composition (video) in a project, with its format and which one is active. Use a returned compositionId with create_render(compositionId=...) to render a specific video, or apply_composition to edit it.
• delete_compositionDelete a composition (and its version history) from a project. REFUSES the ACTIVE composition (409) — make another one active first, or delete the project. Use list_compositions to see which is active.
• list_projectsList your projects — re-orient in an existing workspace instead of minting duplicates (steady-state entry, A9). Each row carries the id every other tool needs.
• derive_compositionDerive a reframed SIBLING composition for a different aspect ratio (the agent-native Auto-Reframe / Magic-Resize). Pass projectId + body { fromCompositionId, targetFormat: { aspectRatio, fps?, resolution? } }. CueFrame copies the source composition's authored intent and content-aware-reframes every clip for the new aspect (point/face/active-speaker focus), then saves a new independent composition in the same project. Returns { compositionId } — render it with create_render, or refine it with apply_composition. Use this to make 9:16 + 1:1 + 4:5 cuts from one 16:9 edit. (To only change resolution within the SAME aspect, pass create_render.format instead — that is a scale-only export override, not a new composition.)
• import_mediaImport a media item into your library from a public URL — the agent-friendly ingest path (single call, no upload protocol). Pass url (https) + filename (+ optional contentType). Returns { id, status:"importing" }. Processing is async: call wait_job(kind="media", id=mediaItemId), or register a webhook (create_webhook on media.completed — status: complete|failed rides the payload). Use the returned id with get_media_context, suggest_briefs, or as a composition source.
• generate_mediaGenerate one first-class Library media item from a prompt. Choose generator: text-to-video | text-to-image | image-to-video | text-to-music | text-to-speech | text-to-sfx | auto. Put supported presentation controls in body.style and first/last/image references in body.refs. Returns { id, status:"generating", estimateUsd? }; returns 402 if the estimate exceeds the per-call ceiling. Async — call wait_job(kind="media", id=mediaItemId) or use a webhook (media.completed — status rides the payload). Use the returned id like any other media item.
• create_uploadIngest a LOCAL file — bytes you hold, when there is no public URL to hand import_media (prefer import_media whenever the bytes already sit at an https URL). TWO steps: (1) this tool reserves a media item and returns { id, uploadUrl, expiresAt } — a short-lived PUT URL. PUT the raw file bytes to uploadUrl over HTTPS with your declared Content-Type (≤ ~5 GB per PUT). (2) call finalize_upload({ mediaItemId: id }) to start processing. Body: filename, contentType (allowed enum), size (bytes). Thereafter it is async exactly like import_media: poll list_media for processingStatus, or register a webhook (create_webhook on media.completed). Use the returned id with get_media_context, suggest_briefs, or as a composition source.
• finalize_uploadFinalize a direct upload once you have PUT the bytes to the uploadUrl from create_upload. Confirms the bytes landed and starts ingest: image/asset become ready immediately (status "complete"); audio/video enter processing (status "processing"). Returns { id, status, processingPhase }. 400 if no bytes were uploaded (PUT first) or the item is not yours. Then call wait_job(kind="media", id=mediaItemId), or use a media.completed webhook.

Updated：2026-10-29 (tools/list verified)

Configure in Claude / Cursor

{
  "mcpServers": {
    "remote-ai-cueframe-cueframe": {
      "type": "http",
      "url": "https://api.cueframe.ai/v1/mcp"
    }
  }
}