add_canvas_nodes
ChatGPTAdd nodes to a canvas: text inline; media from HTTPS URLs, upload receipts, assets or exact Element files. Shared canvas policy chooses collision-free placement; express intent (auto, relative, branch, merge, sequence) instead of pixels. Each node has a key; a later node in the same call may use it as parent_id or placement anchor, and the result's node_ids maps every key to its node id for the other canvas tools. Groups: kind group (title, theme) with parent_id on its children. Kind textbox is transparent free text written on the canvas (markdown; no tables): use it for an analysis, review or notes the user wants on the canvas, placed beside the nodes it covers. It needs text and cannot be connected; text that should feed a generation goes in a text node. Style a textbox with style. Textbox style fields: fontFamily (simple | bookish | soft | technical | scribbled | marker), fontSize (px 8-400; presets 16, 24, 40, 64, 96), color (#rrggbb or a preset name such as white, red, blue, mint, lavender; null = theme text color), bold, italic, underline, strikethrough (booleans; they style the whole box — for one word use markdown bold), textAlign (left | center | right | justify).
add_element_files
ChatGPTAdd images from prepared upload receipts to an existing Element. This resets the Element's provider registrations, so models that use it natively re-register it on next use. It does not place a canvas node: use add_canvas_nodes with an element source and the element and file IDs.
analyze_take
ChatGPTChecks one generated video take the way an editor does, in under a minute: exact cut times with a confidence, contact sheets of the whole take (about 3 frames a second) and the frames at each cut and motion spike as images for you to look at, word-level dialogue timings, the level either side of every cut, room tone, and letterbox / black-and-white / glitch flags. With script, it also diffs the words heard against the lines that should be spoken. Free: no credits (needs a positive balance; counts toward the daily frame-extraction limit). Takes up to 60 s. It does not judge the picture: read the returned images yourself for shot size, characters, props, background and differences from the prompt or shot plan.
analyze_video
ChatGPTBreaks a video into its shots (time range, shot size, camera movement, description) and, by default, writes a screenplay from them: the Video Analysis of the Astorie dashboard. Not every account includes it: where it is not available this refuses with PLAN_REQUIRED and charges nothing. MP4 or MOV, up to 120 s and 100 MB. Costs about 10 credits for the shot list and 3 for the screenplay, or nothing where the account runs Video Analysis free; the result gives the estimate. Runs in the background for a minute or more: this returns a handle at once; call get_video_analysis with it until status is succeeded or failed. request_id makes identical retries safe.
arrange_canvas_nodes
ChatGPTLay nodes out in a row, column or grid; the grid shifts to clear unselected siblings. To organize by category, arrange each group's children, then arrange the group frames. Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
cancel_generation
ChatGPTCancels a generation still waiting in the queue for a free slot (status queued, waiting_for_slot), so it never starts. Free: a queued generation has not been charged, but the request is dropped and has to be sent again. Confirm with the user first. A generation that already started cannot be canceled here.
canvas_capabilities
ChatGPTRead supported canvas content, file formats, operations and shared placement policy before importing. 3D supports self-contained glTF/GLB; renderer and generation support are separate.
change_camera_angle
ChatGPTRe-renders an image of an Astorie project (or an image url) from another camera angle, like the canvas Camera tool. rotate_degrees turns the camera around the subject (negative = left); vertical tilts from below (-1) to above (1); zoom moves closer (0-10, default 5 like the canvas). Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
complete_canvas_upload
ChatGPTValidate uploaded bytes and return a prepared receipt usable as a create source: {type:"upload",upload_id}.
connect_canvas_nodes
ChatGPTConnect nodes with edges. Reference edges supply generation input; relationship edges express sequence. Neither starts a generation; textboxes cannot be connected. Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
create_canvas_upload
ChatGPTFor images in Claude or ChatGPT call upload_image instead (the PUT usually cannot leave their sandbox). Begin a local file upload. PUT file bytes to upload_url, complete the upload, then create a matching content node with the returned receipt. Uploading alone does not place a node.
create_element
ChatGPTCreate a reusable visual Element (kind character, outfit, scene or prop; a product is a prop) from prepared image upload receipts (complete_canvas_upload or prepare_canvas_media). Adds to the library; changes nothing existing. It does not place a canvas node: use add_canvas_nodes with an element source and the element and file IDs.
create_folder
ChatGPTCreates a folder in the personal space or a workspace, or returns the existing folder of that name. Use it when the user wants projects organised, e.g. one folder per client or campaign; then pass its folder_id to create_project or move_project.
create_project
ChatGPTCreates a new, empty Astorie project. Call it once per project the user asks for (e.g. one per video, product or client): do not merge separate projects into one canvas. Not needed for a single generation: the first generate call creates a project by itself. Use a short human-readable name (e.g. "Summer Sale Ad – 3 Variants"), then pass the returned project_id to every call for that project.
crop_image
ChatGPTCrops an image stored in Astorie (an image node of a project, or an Astorie image url) into a new image node. Free: no credits. x, y, width and height are fractions of the image (0-1, from the top-left); omitted, the whole image is used. With rows/cols the crop is cut into a grid and each cell becomes its own node (e.g. rows 2, cols 2 splits a 2x2 contact sheet). Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
delete_element
ChatGPTPermanently delete an Element and all its files from the library. There is no undo: name the Element and get the user's yes first.
disconnect_canvas_nodes
ChatGPTRemove connections between nodes (edge ids from list_connections or get_canvas). undo_canvas_changes with the same request_id restores them.
duplicate_canvas_nodes
ChatGPTCopy existing nodes; each copy gets your key, returned in node_ids. Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
edit_canvas_nodes
ChatGPTOverwrite fields of existing nodes: title, text, prompt, dimensions, group theme or textbox style. Dimensions resize text, note and group frames; a group is never sized below the nodes inside it. Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
edit_options
ChatGPTLists the edits one image or video of an Astorie project (or an image/video url) can get, and shows them to the user as choices. Free and changes nothing. Call it when the user wants to edit or change existing media without naming the exact operation, then let the user pick: each option names the exact tool (and model) to call and what to collect first. Never choose a paid edit for the user.
edit_video
ChatGPTJoins, trims, speeds up/slows down or mutes video clips into ONE new video in an Astorie project. Free: no credits. Each clip is a video node of the project (node_id) or a video url stored in Astorie (import_video / upload_video other videos first). start/end are seconds into that clip's own video; a negative value counts back from its end (start -5 keeps the last 5 s, end -5 cuts the last 5 s off), measured on the actual file, so you never need its length. Clips play in the order given. With target_duration_sec, a longer result has its END cut to fit: the last clip is shortened, or dropped when the cut is longer than it and the clip before it shortened. Without width/height/fps the result matches the first clip's orientation; other aspect ratios are letterboxed. Adds a new video node linked from the source nodes and returns its node_id right away, with a job_id; if it is still running, get_job / jobs_wait return the result. To edit a part of a video, first cut it with edit_video (one clip with start/end), wait for it (jobs_wait), then call generate_video with a video-edit model and reference_node_ids=[that node_id]. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
enhance_prompt
ChatGPTRewrites a short prompt into a richer one for an image, video or audio generation, the way the canvas Enhance button does. Free: no credits. Show the user the result before generating with it.
finish_image_upload
ChatGPTUsed by the Astorie upload card: checks the uploaded file and returns its url.
gallery_page
ChatGPTUsed by the Astorie gallery card's Load more: the next page of the same view.
generate_3d
ChatGPTTurns one image into a 3D model (GLB) in an Astorie project using the user's credits (workspace credits for a workspace project). Adds a new 3D node and returns a job_id; call get_job for the GLB url when it finishes (usually 1–5 minutes). list_models lists the 3D models and the credits each costs (quote prices one too): tell the user the cost before calling.
generate_audio
ChatGPTGenerates audio in an Astorie project using the user's credits (workspace credits for a workspace project) and adds it as a new audio node. kind picks what to make and its default model: speech (text, optional voice), dialogue (lines: [{ text, voice }]), music (lyrics + text as the style/genre), sound_effect (text describing the sound, optional duration_sec; or a video-to-audio model with video_url / video_node_id), voice_design (voice_description + text as preview lines; the designed voice id then works as a voice for the minimax-speech models). list_models (audio section) names the models and the default per kind; list_voices their voices. Waits up to ~25 s; if not finished, returns a job_id for get_job. The result states the credits it cost. Every result carries project_id and node_id — reuse the project_id for the rest of the conversation.
generate_image
ChatGPTGenerates an image in an Astorie project using the user's credits (workspace credits for a workspace project). Adds a new image node, or regenerates node_id. Waits up to ~25 s; if not finished, returns a job_id for get_job. To edit an image with a prompt, pass it in reference_images (or its node in reference_node_ids) and describe the change; list_models names the edit models. Only when the user asked for a new generation or a prompt edit: for "improve/edit this image" without a named edit, call edit_options first. The result states the credits it cost. Before a batch of more than 4 images, call quote and confirm the total with the user. Every result carries project_id and node_id — reuse the project_id for the rest of the conversation.
generate_image_batch
ChatGPTStarts up to 8 image generations at once (e.g. variations), all in one project, using the user's credits. FIRST call quote with the same model and options and quantity = the number of prompts, and confirm the total with the user when it is more than 4. Returns job_ids immediately without waiting; then call jobs_wait ONCE with all of them. Items it could not start are returned as not_started with the reason; to finish them, call again with the SAME full prompt list and the same request_id (started items replay). Without project_id a new project is created; reuse the returned project_id afterwards.
generate_video
ChatGPTStarts a video generation in an Astorie project using the user's credits (workspace credits for a workspace project). Videos are expensive: FIRST call quote with the same model and options, tell the user the credit cost and wait for their go-ahead. Adds a new video node, or regenerates node_id. Returns a job_id right away; videos take 1–10 minutes — poll with get_job. Every result carries project_id and node_id — reuse the project_id for the rest of the conversation.
generate_video_batch
ChatGPTStarts up to 8 video generations at once, all in one project, using the user's credits. Videos are expensive: FIRST call quote with the same model and options and quantity = the number of prompts, tell the user the total and wait for their go-ahead. Returns job_ids immediately; videos take 1–10 minutes — call jobs_wait with all of them (repeat for those still running). Items it could not start are returned as not_started with the reason; to finish them, call again with the SAME full prompt list and the same request_id (started items replay).
get_balance
ChatGPTReturns the user's remaining personal Astorie credits. For a team workspace's shared balance, use get_workspace_credits with its id from list_workspaces.
get_canvas
ChatGPTRead the current canvas nodes, edges and revision for references, placement and editing. When a node carries prompt_rich_text, THAT is what its editor shows and what Generate submits, not prompt — an empty prompt_rich_text beside a non-empty prompt means the editor is blank.
get_elements
ChatGPTGet exact Elements and all their files within an explicit authorized library scope.
get_job
ChatGPTReturns the status of a generation and, when finished, its output URLs and the credits it cost. Waits up to ~25 s for it to finish.
get_node_history
ChatGPTLists the past outputs of one node of a project (every generation it made, newest first), like the history panel on the canvas.
get_project
ChatGPTSummarises a project's canvas: each node's id, type, prompt, model, latest output URLs and the nodes it references (up to 60 nodes). Use node ids with generate_* (node_id to regenerate, reference_node_ids to reuse outputs).
get_video_analysis
ChatGPTStatus of an analyze_video run. While running: the current step. When succeeded: title, summary, the shot list (times, shot size, camera movement, description) and the screenplay. Poll about every 30 seconds; a run takes one to a few minutes.
get_workspace_credits
ChatGPTA workspace's shared credit balance for its owner or an admin: monthly quota used and remaining, wallet credits, and when the quota resets. Workspace credits are separate from the personal credits get_balance reports. Members without the admin role are refused.
get_workspace_usage
ChatGPTFor a workspace owner or admin: every member with their credits spent, refunded and net over the last days days (UTC), plus each member's current spending cap and how much of it is used. Use it to answer "who spent what" and to find the member user_id a cap change needs. Owners or admins only.
group_canvas_nodes
ChatGPTFrame existing nodes in a new group (title, theme), keeping their positions; groups grow automatically to fit their children. For a new group of new nodes use add_canvas_nodes with kind group. Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
import_audio
ChatGPTCopies an audio file into Astorie so it can be used, e.g. as the audio_url of lipsync or on a canvas: a public https url, and/or (in ChatGPT) the audio the user attached in this chat, passed as files. MP3, WAV, M4A, OGG, FLAC or WebM, up to 100 MB.
import_image
ChatGPTCopies images into Astorie and places each on a project canvas as an image node: a public https url, and/or (in ChatGPT) the images the user attached in this chat, passed as files. Free. Returns project_id and node_ids to edit them or use them as references. In Claude, chat attachments cannot be passed: call upload_image instead.
import_video
ChatGPTCopies a video into Astorie so it can be edited, extended or used as a reference video: a public https url, and/or (in ChatGPT) the video the user attached in this chat, passed as files. MP4 or MOV, under 256 MB. In Claude, chat attachments cannot be passed: call upload_video instead.
inpaint_image
ChatGPTChanges only one area of an image in an Astorie project and keeps the rest, using the user's credits like generate_image (quote prices it with the same model). The source is an image node of the project (node_id) or a public https image url. The area is EITHER box (x, y, width, height as fractions 0-1 of the image, from the top-left) OR mask_url (a black-and-white image the same shape as the source: white = change, black = keep). The result is a new image node beside the source; the source is not changed. Waits up to ~25 s; if not finished, returns a job_id for get_job. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
jobs_wait
ChatGPTWaits up to ~25 s for several generations (job_ids from generate__batch or generate_) and returns each one's status, output URLs and credits. Call it again with the ids still running. Use it instead of one get_job per job.
lipsync
ChatGPTMakes the person in a video of an Astorie project speak an audio track, like the canvas Lipsync tool. Video: node_id or url; audio: audio_node_id (an audio node of the project) or audio_url. model: fal-ai/sync-lipsync/v2/pro, fal-ai/pixverse/lipsync, fal-ai/kling-video/lipsync/audio-to-video or creatify/lipsync; omit it for the default. sync_mode (cut_off, loop, bounce, silence, remap) handles audio longer or shorter than the video. Priced per second of video. Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
list_connections
ChatGPTRead both reference and relationship connections. Relationship edges are never generation inputs.
list_models
ChatGPTLists the image, video, audio and 3D (generate_3d) models available through Astorie, with their supported options. Audio models (for generate_audio) are listed under audio with the kinds they make and the default per kind; list_voices has their voices. A model marked requires_image needs at least one reference image (for an edit model, the image to edit); requires_video needs one video in reference_videos; requires_marketing needs the marketing argument. Models marked studio take presets or a template: call list_studio_options.
list_projects
ChatGPTLists the user's Astorie projects (personal and workspaces they belong to), newest first. Use it when the user refers to an existing project.
list_studio_options
ChatGPTLists what Astorie's two Studios offer this account. Astorie Director (lca-image, lca-video): every preset by kind — world, look, movement, speed, lens, palette — with the modes (image / video) each applies to, plus the user's saved color palettes. Astorie Ads (marketing-studio-video): the templates with their duration ranges, and the user's saved products (with their facts), people, voices and uploads. Call it before using either Studio and pass the slugs to generate_image / generate_video.
list_transactions
ChatGPTLists credit usage, newest first: what each generation cost, refunds and credits added, like the Usage page. Personal by default; pass workspace_id (from list_workspaces) for a workspace's log (owners and admins only). category: all, image, video, audio, threed or others. Pass next_cursor back as cursor for the next page.
list_uploads
ChatGPTLists the newest (up to 10) files the user uploaded or imported into Astorie in the last hour (upload_image / upload_video card, import_image, import_video), newest first, with their urls. Call it only when the user says they uploaded in the card and their message carries no urls and the card did not put them in your context; urls from the card always win (this list can include older files). Pass image urls in reference_images (or as Astorie Ads product_image / person_image) and video urls in reference_videos.
list_voices
ChatGPTLists the preset voices of the speech and dialogue audio models: name, voice_id (pass it as generate_audio voice, or a line's voice), model, and a preview_url to listen to where the provider publishes one. Pass model to list one model's voices.
list_workspaces
ChatGPTLists where the user's projects live: their personal space and every workspace they belong to, each with its folders. Use the ids with create_project (to create in a workspace or folder) and list_projects (to find projects in one). A folder the user wants that is not listed can be made with create_folder.
move_canvas_nodes
ChatGPTMove nodes to a new placement (prefer auto or relative intent over coordinates). Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
move_project
ChatGPTMoves a project the user manages into another folder of the same space (personal or its workspace), or out of any folder. Folder ids come from list_workspaces. A project cannot be moved to a different workspace. If the move changes access, first show the returned preview and ask the user to confirm.
poll_job
ChatGPTUsed by the Astorie result view to refresh a running generation. Returns immediately.
poll_jobs
ChatGPTUsed by the Astorie batch result view to refresh several running generations. Returns immediately.
prepare_canvas_media
ChatGPTImport and validate a public HTTPS media URL, returning a reusable prepared upload receipt for preview and placement.
preview_canvas_changes
ChatGPTDry run: validate changes (each with its op) and preview their shared placement and mutations. Read-only; creates and changes nothing. Prepare URL sources first with prepare_canvas_media. Apply them with the per-operation tools (add_canvas_nodes, connect_canvas_nodes, …); a key is only visible inside its own call.
preview_member_credit_limit
ChatGPTStep 1 of 2 to change a member's spending cap in a workspace (owner or admin only). Returns the member, their current cap and usage, the proposed cap and the billing cycle it applies to, with a confirmation_token. Show the preview to the user and call set_member_credit_limit with the token only after they explicitly agree. Nothing changes until then. Pass limit_credits for a cap, or remove_limit: true to lift the cap. Resolve the member's user_id with get_workspace_usage first; never guess from a name.
quote
ChatGPTReturns exactly how many credits generate_image / generate_video / generate_audio / generate_3d would charge for these options in this project (personal or workspace credits), without generating or charging anything. Call it and confirm with the user before any video, before a batch of more than 4 images, and whenever the user asks what something costs. A requires_image model can be priced before the image is chosen: reference_images may be omitted here. It is the price IF the generation is accepted: submit can still refuse it (e.g. no free capacity or insufficient credits).
relight_image
ChatGPTChanges the lighting of an image of an Astorie project (or an image url), like the canvas Relight tool. prompt describes the light (e.g. "golden hour from the left"); style is one of standard, darker_but_realistic, clean, smooth, brighter, contrasted_n_hdr, just_composition. Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
remove_background
ChatGPTCuts the subject of an image of an Astorie project (or an image url) out onto a transparent background. Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
remove_canvas_nodes
ChatGPTRemove nodes and their connections from the canvas; a group needs include_children. Name what will be removed and get the user's yes first. undo_canvas_changes with the same request_id puts them back while unchanged.
remove_element_file
ChatGPTPermanently remove one file from an Element. There is no undo: name the file and get the user's yes first.
remove_workspace_member
ChatGPTRemoves a member from a workspace (owner or admin only): they lose access to its projects and shared credits, and their spending cap and invite links are dropped. Admins can remove members; only the owner can remove an admin; the owner cannot be removed. Confirm the exact person with the user before calling. Resolve member_user_id with get_workspace_usage first.
rename_element
ChatGPTRename an Element, overwriting its current name. Names cannot contain whitespace or @ and must be unique in the library.
rename_project
ChatGPTRenames an existing project the user can edit (find it with list_projects). Only the name changes; the canvas is untouched.
reparent_canvas_nodes
ChatGPTMove nodes into another group (parent_id), or out of any group (parent_id null). Refer to nodes by the ids get_canvas shows or the node_ids an earlier call returned.
resolve_element_references
ChatGPTResolve exact Element/file pairs and explicit roles against model capabilities without registration or spending credits. Only ready results may be submitted.
search_elements
ChatGPTSearch authorized reusable Elements by name and kind. Inspect previews and ask the user when selection is ambiguous.
search_nodes
ChatGPTFind canvas nodes by content kind or literal text. Returns bounded results and current canvas revision.
set_element_primary_file
ChatGPTChoose which of an Element's files is its primary image, replacing the current primary.
set_member_credit_limit
ChatGPTStep 2 of 2: applies the exact change a preview_member_credit_limit token describes, after the user agreed to that preview. The token is valid for 15 minutes, for this account and connection only, and is refused if the member's cap or billing cycle changed since the preview (preview again). Re-sending a token already applied returns the first result without changing anything.
show_elements
ChatGPTShows the user's reusable Elements (characters, outfits, scenes, props) with a preview each, tabbed by kind, for the user to pick from. Their pick comes back as a message with element_id and file_id. For your own lookup use search_elements.
show_generation
ChatGPTShows one past result in the Astorie result card (video player or image, with Open in Astorie): by job_id, or by the project_id and node_id of an image or video node. Call it when the user wants to see an earlier generation again. To check on a running job use get_job.
show_projects
ChatGPTShows the user's recent Astorie projects with their cover images (personal and workspaces they belong to), newest first, for the user to pick from. Their pick comes back as a message with the project_id. For your own lookup use list_projects.
show_studio_options
ChatGPTShows Astorie Director presets (world, look, movement, speed, lens, palette) and Astorie Ads templates with their cover images, tabbed by kind, for the user to pick from. Their pick comes back as a message with the kind and slug. Pass media "image" for an image (lca-image) request: only presets image mode takes are shown. For your own lookup (and saved palettes / products) use list_studio_options.
show_uploads
ChatGPTShows everything the user uploaded to Astorie (web app uploads plus the upload card, import_image and import_video; all time, newest first) as a grid they can pick from. Call it when the user wants to see or choose from their uploads; their pick comes back as a message with the url. For your own lookup use list_uploads.
split_layers
ChatGPTSplits an image of an Astorie project (or an image url) into separate transparent layers (subject, background, ...), like the canvas Layers tool. Not available on every account. Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
start_image_upload
ChatGPTUsed by the Astorie upload card: a one-time URL its browser uploads the picked file to directly.
transcribe
ChatGPTTurns the speech in an audio or video into text, like the canvas audio node's Transcribe. Free: no credits. Source: node_id (an audio or video node of project_id) or url (an Astorie media url). With add_text_node, the transcript is also written to a new text node beside the source.
undo_canvas_changes
ChatGPTUndo one of your committed canvas requests (pass its request_id) only if its nodes and incident connections are unchanged; a removed node comes back with its image or video. Does not undo library edits or refund generation charges.
ungroup_canvas_nodes
ChatGPTRemove a group frame and keep its children on the canvas. undo_canvas_changes with the same request_id restores it.
update_workspace_member_role
ChatGPTMakes a workspace member an admin or a regular member (owner or admin). Admins can promote a member to admin; only the owner can demote an admin; the owner's own role cannot change. Admins can manage members, invites and spending caps; demoting an admin also revokes their invite links and may drop their access to admin-only projects. Confirm with the user before calling. Resolve member_user_id with get_workspace_usage first.
upload_image
ChatGPTShows a card where the user picks images or videos (MP4/MOV) from their own device to upload into Astorie — for a local file or a chat attachment you cannot pass as a public https URL or as import_image / import_video files. Call it as the only tool in the turn: the user can pick up to 10 files at once and presses Continue, and the card posts their urls in the chat. Place them on a canvas with ONE add_canvas_nodes call (urls as media sources), or pass image urls in reference_images and video urls in reference_videos.
upload_image_data
ChatGPTUsed by the Astorie upload card to store the file the user picked.
upload_video
ChatGPTShows a card where the user picks a video (MP4/MOV, under 256 MB) or images from their own device to upload into Astorie — e.g. a video to edit or extend. Call it as the only tool in the turn: after the user picks files and presses Continue, the card posts their urls in the chat; pass video urls in reference_videos.
upscale_image
ChatGPTUpscales an image of an Astorie project (or an image url) to higher resolution, like the canvas Upscale tool. model: fal-topaz-upscale-image (scale 1-4), fal-recraft-upscale-crisp, freepik-magnific-upscale (scale 2-16), freepik-magnific-creative (scale 2, 4, 8 or 16, optional prompt), freepik-skin-enhancer (portraits); omit it for the default. Bigger outputs cost more. Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
upscale_video
ChatGPTUpscales a video of an Astorie project (or a video url) to higher resolution, like the canvas Upscale tool. model: fal-topaz-upscale-video (scale 1-4, fps 60 doubles the frame rate and the price), fal-ai/seedvr/upscale/video (scale, capped so the output stays within 1920x1080), freepik-video-upscaler (resolution 1k, 2k or 4k); omit it for the default. Priced per second of video. Spends credits like the same tool on the Astorie canvas (quote does not price it; tell the user it costs credits, per second for videos). Adds a new node linked from the source and returns its node_id with a job_id right away; get_job / jobs_wait return the result if it is still running. Call when the user named this edit or picked it in edit_options; when they already named it, do not show edit_options first.
verify_element
ChatGPTVerify an Element's images for Seedance, so a person in them is accepted as a reference. A Seedance submission that references an unverified file starts this for that file itself; call it ahead of time when the user plans to use the Element with Seedance, or to retry a failed file. Sends the Element's images to the video provider for registration; no credits. Waits up to about 20 s, then reports each file.
view_media
ChatGPTShows you an image, or frames of a video, from an Astorie project so you can look at it yourself: use it to check a result, compare shots or read a frame, instead of asking the user to download and re-upload a file. Free: no credits (a video needs a positive balance and counts toward the daily frame-extraction limit); nothing is written to the canvas. A video returns frames evenly spaced frames, or the frames at at_sec. For speech in audio or video, use transcribe.