flashloop_assemble_video
ChatGPTStitch N block clips + optional per-block voiceover takes into ONE final MP4 (free — no credits). Each block occupies a fixed block_duration-second window: a short voice take is centered in its window, an overrunning take is sped up pitch-safely (warned above 1.35x — a shorter take avoids the speed-up). Hard cuts between blocks. subtitle_text lines are burned in as styled captions. With voice_generation_id (from generate_voiceover) instead of audio_url, the server times each caption word to the actual speech (word-synced karaoke); otherwise captions are spread evenly. Returns a job_id; wait_for_job returns the final MP4. warnings[] on the result lists squeezed takes and short clips. flashloop_edit_video is the timeline form for richer edits: per-clip slots and trims, anchored voice and captions, music, more aspect ratios, previews.
flashloop_change_voice
ChatGPTRe-render existing audio in a different voice (voice conversion). Async — returns a job_id (kind voice_generation); call wait_for_job for the new audio URL. audio_url accepts a raw public URL or a url returned by upload_media. Pick a voice_id from list_voices.
flashloop_clone_voice
ChatGPTClone a voice from a reference audio clip. Provide a name and an audio_url (a raw public URL or a url returned by upload_media for an uploaded audio asset). Returns the new voice; its id can then be used as a voice_id in generate_voiceover / change_voice. Only clone the user's own voice or a voice they have clear permission to use; the voice of a public figure or of someone else taken from a public link is not permitted.
flashloop_create_image
ChatGPTStart an image generation (1–4 images). Returns a job_id; call wait_for_job for the output URL(s). Pick a model_id from list_models. reference_image_urls takes https URLs only; inline data:image/base64 URIs are not accepted. A reference the user attached or that lives in the code-execution environment must be uploaded first (flashloop_create_sandbox_upload_url + its curl, or flashloop_upload_widget when the curl is blocked or no code-execution environment exists), and the returned url is what this tool accepts. Each model has a max reference-image count (see list_models capabilities); over-cap references are dropped, not rejected. Saved references from list_references share that same budget and go in their own fields — character_ids, location_ids, element_ids. The result's warnings[] field reports out-of-policy ids and dropped references; they appear nowhere else.
flashloop_create_project
ChatGPTCreate the Faceless video project of each episode in the user's Faceless Studio. Free: it creates the project folders only, and no video shows as generating. It saves these settings as /workspace/brief.json in each project's sandbox; flashloop_finish_video records them with the video, so never delete or edit that file. Call it once per video, after flashloop_get_instructions; the finished video is registered later with flashloop_finish_video. Returns {series_id, episodes: [{episode, project_id}], style: {id, title, reference_video_url} or null}. Next, pass each project_id to flashloop_exec (that episode's own sandbox) and to flashloop_generate_voiceover, flashloop_create_image and flashloop_upload_media, so their files appear in the project as they are made, then to flashloop_finish_video. Refuses with insufficient_credits when the balance cannot pay the voiceover of every episode, and with invalid_input when the user already has 8 videos in progress (started in the last 24 hours and not finished). Example: {"prompt": "What if the moon were made of glass", "duration_seconds": 60, "episodes": 1, "style_id": "bold-flat"}.
flashloop_create_reference
ChatGPTCreate a reusable PLACE (location) or OBJECT (element) from a description. SPENDS CREDITS — one image. Returns a job_id; call wait_for_job before using the new id in a generation, because until the image lands there is nothing for a model to reference. Worth it only for what recurs. A place seen once is that shot's prompt; saving it clutters a library the person has to live with. The test is whether you would have to describe it again later. The curated shelves and the user's own rows (list_references) already hold a lot, and reusing one costs nothing and looks the same every time. The framing is fixed server-side and is not a parameter: a location renders as a wide, empty establishing shot (16:9, no people), an element as one object centred on a plain background (1:1). Describe the subject, not the shot. NOT for people. To save a PERSON, generate their portrait with create_image and then keep it with upload_reference — that path is free and instant, and it lets the user see the face before it joins their library. upload_reference is also how you save an object the user already has a picture of, instead of generating a new one here.
flashloop_create_sandbox_upload_url
ChatGPTMint a single-use upload URL for a file in the code-execution environment (chat attachments on claude.ai and ChatGPT are written there as a real file). Returns put_url, a ready-to-run curl command (replace <FILE_PATH> with the file's path) and the limits. Bytes travel over the network (up to 30MB in seconds, no token cost), unlike base64 which streams through the model's output. The curl response JSON contains the asset url, which reference_image_urls in create_image / create_video accepts. The URL expires in 10 minutes and accepts exactly one upload. A network or connection error from the curl means the sandbox cannot reach this domain; flashloop_upload_widget is the alternative that needs no sandbox network access.
flashloop_create_video
ChatGPTStart a text-to-video or image-to-video generation. Returns a job_id; call wait_for_job for the final video URL. Pick a model from list_models (e.g. veo-3, sora-2, kling-3.0, kling-4.0, seedance-2.0, wan-2.6, gemini-omni). Which of duration/sound/resolution/speed/first_frame/references/multi-shot a model supports is per-model — see list_models capabilities (incl. reference_support for video/audio reference caps and multi_shot bounds). Image reference params (first_frame_image_url, end_frame_image_url, reference_image_urls) take https URLs only; inline data:image/base64 URIs are not accepted. An attached or code-execution-environment file must be uploaded first and the returned url passed here: flashloop_create_sandbox_upload_url + its curl (bytes over the network, up to 30MB in seconds), or flashloop_upload_widget when the curl is blocked or there is no code-execution environment. Video/audio reference params accept public URLs only. MULTI-SHOT (kling-3.0 and kling-4.0): AUTO = multi_shots:true + multi_shots_auto:true + a prompt (the backend LLM expands it into scenes); CUSTOM = multi_shots:true + your own multi_prompt[] (top-level prompt optional). KLING 4.0 (3-30s, prompt up to 8000 chars, audio always on) works in two modes that never combine. FRAMES: first_frame_image_url, optional end_frame_image_url, optional keyframe_image_urls (1-9 extra frames, needs first_frame_image_url) or multi-shot (2-6 shots, up to 2500 chars each, total 3-15s). REFERENCES: reference_image_urls (up to 10), reference_video_urls (up to 5, total up to 30s, send reference_video_durations_seconds), reference_audio_urls (up to 3), kling_elements (up to 7), at most 15 references in total, a prompt is required, and aspect_ratio may be auto; do not send first_frame_image_url, end_frame_image_url, keyframe_image_urls or multi_shots together with references. MOTION CONTROL (kling--motion-control): requires reference_video_url + first_frame_image_url + the measured reference_video_duration_seconds (3-30s). Saved references from list_references go in their OWN fields — character_ids, location_ids, element_ids — which this tool maps to the video route's _mention_ids keys. The result's warnings[] lists over-cap or out-of-policy references the backend dropped, with a reason.
flashloop_delete_image
ChatGPTPermanently delete one of the user's generated images by id. This cannot be undone. Use list_generations to find the image_id.
flashloop_delete_reference
ChatGPTDelete one of the user's own saved references. Curated library rows cannot be deleted. Past generations that used it keep their output — only the reusable row goes away. usage_count in list_references shows how often a location or element is used; a reference used across a series is what keeps that series consistent. Deleting a base character also deletes its variants, and the count comes back in deleted_variants.
flashloop_delete_video
ChatGPTPermanently delete one of the user's videos by id. This cannot be undone. Use list_generations to find the video_id.
flashloop_edit_video
ChatGPTEdit clips, voiceover takes, burned captions and music into ONE MP4 on a timeline (free, no credits). clips play in order with hard cuts; each is one of your completed videos (video_id, or its video:<id> job_id) or a Flashloop CDN src. A clip's slot is its own length unless duration is set; fit decides what a shorter clip does and scale how it fills the canvas. Anchors (at) place voice, captions and music: {clip: i} spans clip i, {clips: [i, j]} spans clips i through j, {start, end} are seconds on the output timeline. A take longer than its window is sped up to max_speed, then fails with VOICE_TOO_LONG unless overflow is 'trim'. A caption with voice: k follows take k, and with a voice_generation_id take its words are synced to the speech automatically. Music ducks under the voice. canvas.quality: 'preview' is a quick draft for checking timing. Submitting an edited timeline again makes a new video and re-renders only the clips that changed, so small fixes come back fast. Returns a job_id; wait_for_job returns the MP4 and warnings[] (for example a clip shorter than its slot). A failed job's message starts with a code such as VOICE_TOO_LONG, SOURCE_DOWNLOAD_FAILED or RENDER_FAILED. flashloop_assemble_video is the simpler fixed-block form.
flashloop_estimate_cost
ChatGPTEstimate the credit cost of a planned video, image or music generation before running it (for kind 'music', pass the music model and optionally max_mode: 1050 credits, or 2000 with max_mode), so you can check it against the balance from get_credits. Costs are derived from the model's pricing (pricing_tiers or pricing_per_second from list_models). This is an estimate; the server is authoritative and may differ (tiered duration/resolution, multi-shot, multi-image counts). duration accepts any whole second inside the model's capabilities.duration range when its mode is "range". For a multi-shot video pass the total of all shot durations as duration: per-second models bill that total. For a type: 'upscale' model (flashloop_upscale) this returns estimated_credits: null — that pricing is computed server-side from the source file's real duration/resolution, which is never known here; read credits_used from the completed job instead.
flashloop_exec
ChatGPTRun a bash command in a persistent Linux sandbox for building media and documents. /workspace keeps its files between calls; pass a project_id from flashloop_create_project to work in that video project's own sandbox, or leave it out for the general one. Preinstalled: bash, curl, git, jq, zip, ffmpeg and ffprobe, Node.js with npm, Bun, Python 3 with pillow, matplotlib, pandas, openpyxl, python-docx, python-pptx, reportlab, pypdf and faster-whisper, and flashloop-motion, which renders JSX motion scenes to mp4 (run flashloop-motion --help). The network reaches package registries, web fonts and the Flashloop CDN only: register any other public file with flashloop_upload_media url and download the returned url here. To hand a file made here to the user or to a generation, call flashloop_upload_media with sandbox_path (and the same project_id); a finished Faceless video goes to flashloop_finish_video by path. Foreground commands wait up to timeout_seconds (120 at most); longer work goes in background. Returns {exit_code, stdout, stderr, timed_out, truncated, sandbox_created, project_id}; sandbox_created true means a fresh sandbox, so earlier files are gone. Example: {"command": "ffprobe -v error -show_entries format=duration -of csv=p=0 out.mp4", "project_id": "0f8e2b9c-3a51-4d0e-9a7b-6c2d1e4f5a60"}.
flashloop_finish_video
ChatGPTRegister the finished video as the result of a project. First upload the mp4 (and optionally a cover image) from the sandbox with flashloop_upload_media and this project_id, run its curl command, then pass the returned public_urls here. Returns video_url and studio_url, the link to the video in the user's Faceless Studio. Safe to call again on a finished project.
flashloop_generate_music
ChatGPTGenerate a full song with Flashloop Music from a description (simple mode) or from your own lyrics and style (custom mode). Every generation returns two tracks, each as an mp3 preview and a wav download. It costs 1050 credits, or 2000 credits with max_mode, and the price always includes both wav files. It is asynchronous: it returns a job_id, and wait_for_job returns tracks[] with mp3_url, wav_url, title and duration_seconds for each track once the song is ready.
flashloop_generate_voiceover
ChatGPTGenerate a voiceover from text using a chosen voice. Find voice_id values via list_voices. Optional model_id: 'eleven-v3-voiceover' (default; 5000-char cap, cloned voices), 'eleven-v4-voiceover' (most expressive, audio tags like [whispered]; 10000-char cap, cloned voices), 'eleven-v4-turbo-voiceover' (lower latency, half the credits; 10000-char cap) or 'gemini-3-1-voiceover' (multilingual 70+ languages, 10000-char cap, 2x cheaper; use the gemini voice names from list_voices, no cloned voices). 'gemini-3-8-flash-voiceover' and 'gemini-3-8-flash-lite-voiceover' (5000 spoken chars, 30 gemini voices from list_voices, no cloned voices) read text literally: delivery direction goes in style (e.g. 'warm, upbeat host'), not in the text, and the accepted angle tags are <laugh>, <sigh>, <short pause>, <breath>, <cough> ([brackets] are not tags on these models). They also do a 2-speaker dialogue: send speakers and turns instead of text and voice_id. Voiceover is ASYNC on every model: generation time scales with script length (seconds for short lines, several minutes for long scripts), so it returns a job_id; wait_for_job returns the audio URL (a timeout means it is still processing). If the result already has audio_url, the audio is done and there is no job.
flashloop_get_credits
ChatGPTReturn the current credit balance. Cheap to call; comparing the balance before and after a batch of generations shows the spend.
flashloop_get_download_url
ChatGPTTurn a generation's cdn.flashloop.app URL (from list_generations / wait_for_job output) into a time-limited direct-download URL (Content-Disposition: attachment, expires in ~1 hour). Use when the user wants to SAVE a video/image/voiceover to their device rather than just view it. Calls the Flashloop API (https://www.flashloop.ai/mcp).
flashloop_get_instructions
ChatGPTRead the Flashloop Faceless video guide before making a video. Call it first: it explains the full flow, including the style catalog, with flashloop_start_video, flashloop_exec, flashloop_generate_voiceover, flashloop_upload_media and flashloop_finish_video. Without path it returns the main instructions and the list of extra files. With path it returns that one file.
flashloop_get_job
ChatGPTCheck an async generation ONCE (no blocking) and return its current state: completed, failed, or still-processing. Use this for a non-blocking peek; use wait_for_job to block until done.
flashloop_list_generations
ChatGPTList the user's generations — videos, images, or both mixed (newest first). Renders a gallery widget. Serves history and browse requests: show my videos, show my images, show recent generations, find a past result. Each row carries a job_id (usable with get_job / wait_for_job) and its output URL — a completed url can be reused as a reference in create_image / create_video. Voice generations have no paginated list and are not included. A generation created in the current conversation is already shown live by its own card.
flashloop_list_models
ChatGPTList the video/image/upscale/music models available, with the capabilities and pricing tiers of each. Returns the legal model/model_id values for create_video / create_image and which options (duration, sound, resolution, references, multi-shot) a model supports. Each model's capabilities block carries the per-model reference-image cap (max_reference_images), upload limits for validating reference files client-side (max_image_size_mb, max_video_size_mb, accepted_upload_formats), @-character support + caps, multi-shot limits, and special requirements (e.g. grok-imagine needs a first frame). capabilities.duration holds the legal duration domain, not the top-level supported_durations: when its mode is "range", ANY whole second between min_seconds and max_seconds is legal and values are just common presets — a duration like 20s on a 4-30s range model is valid even though 20 isn't in values. When mode is "enum", only the values in values are accepted. The top-level supported_durations field is the raw catalog preset list kept for backward compatibility only — capabilities.duration is authoritative.
flashloop_list_references
ChatGPTList the saved references the user can put in a generation — characters (people), locations (places) and elements (objects/props). Each kind spans BOTH the curated public library and the user's own rows; owned_by_me tells them apart and owner filters. Renders a gallery card. An id from here travels to a DIFFERENT field per kind AND per surface, and the wrong field is ignored silently — the render then costs full price and comes back WITHOUT the reference, with no error: create_image → character_ids | location_ids | element_ids create_video → character_mention_ids | location_mention_ids | element_mention_ids Ids are opaque values copied from the rows returned here, not derived from a name. A place in the character field attaches nothing, and describing a saved location in the prompt alone attaches nothing either. Only rows with status: "ready" can be referenced; one still generating has no image yet, so it attaches nothing either. The curated shelves are large and this endpoint cannot page or search server-side: search narrows the result, and counts and truncated show what was not returned. It applies when the user asks about their saved references or wants one in a generation; a subject with no saved reference is described in the prompt instead.
flashloop_list_styles
ChatGPTShow the Faceless video styles as a gallery the user can pick from. Free. After the user picks one, pass its id as style_id to flashloop_start_video.
flashloop_list_voices
ChatGPTList available voices: the built-in presets plus the user's own cloned voices. The returned id values feed voice_id in generate_voiceover and change_voice. Voices with model: 'gemini-3-1-voiceover', 'gemini-3-8-flash-voiceover' or 'gemini-3-8-flash-lite-voiceover' only work with that generate_voiceover model_id (and vice versa — default/ElevenLabs voices don't work on the gemini models). Cheap to call.
flashloop_remix_create_preset
ChatGPTMake one of the user's finished Remix Studio runs into a preset of their own; call it only when the user asks for that. Free: nothing is generated, copied or charged. The preset points at the run's final video and thumbnail and is private to this user: flashloop_remix_list_presets lists it with source: user, and its id works as preset_id in flashloop_remix_create_run. Pass run_id (a run flashloop_remix_finish completed) and category. Optional: title (default: the video's title), summary, prompt and images (what every run from the preset receives, saved in that run's run.json as preset_prompt and preset_images), and inputs (the run form; default: 1 to 10 images plus optional notes). Returns the preset {id (a uuid), title, summary, category, reference_video_url, thumbnail_url, preview_url, width, height, duration_seconds, inputs, source: user, prompt, images, next_step}. Refuses with not_found for a run_id that is not this user's run, and with invalid_input for an unfinished run, at 100 presets, or for an image this user did not upload. Example: {"run_id": "5b1f0c2a-8d3e-4f6a-9b7c-0d1e2f3a4b5c", "category": "personalized_edit", "title": "Skate remix"}.
flashloop_remix_create_run
ChatGPTCreate one Remix Studio run: a remix of a reference edit (a preset, or the user's own reference video) with the user's own footage or subject, in its own sandbox. Free: it creates the run and saves its settings in its sandbox; nothing is generated or charged. It saves the settings as /workspace/remix-studio/run.json in the run's sandbox; flashloop_remix_finish checks the final video against its width and height, so that file is never deleted or edited. With a preset and no reference_url, the run's reference_url is the preset's video. With one of the user's own presets, run.json also holds that preset's prompt and reference images as preset_prompt and preset_images in /workspace/remix-studio/run.json: they apply to the remix as part of the brief, and this run's prompt wins where they conflict; the result then adds a next_step saying so. Returns {run_id, title, status: in_progress, expired, created_at, expires_at, prompt, preset_id, preset_title, reference_url, output: {width, height}, source, video_url: null, thumbnail_url: null, scripts_dir}. The run_id is the run's sandbox: it goes to flashloop_exec as project_id (scripts_dir is the read-only folder of helper scripts there, /opt/remix-studio/scripts) and to flashloop_remix_finish. A run expires 24 hours after creation if no final video was registered. Refuses with invalid_input when the user already has 8 runs in progress, and with not_found for a preset_id that is not listed. Example: {"prompt": "Remix this golden-hour edit with my two rowers", "width": 1920, "height": 1080, "preset_id": "cinematic-film-look"}.
flashloop_remix_finish
ChatGPTRegister the finished video of one Remix Studio run in a single call. Pass exactly one of two forms. For a video rendered remotely with flashloop-motion-remote, pass the render_job_id (its printed jobId) alone: the render must be completed, whole (no --range) and at --quality final, and its video and thumbnail are taken from that render, so nothing is uploaded. For a video rendered in the run's sandbox (the /workspace of flashloop_exec with project_id set to this run_id), pass video_path and thumbnail_path once the final mp4 and its thumbnail are written there: the files are checked and copied from the sandbox, so they are not uploaded first. Either way the video must be an MP4 with H.264 video at exactly the width and height the run was created with, and any audio track AAC; the thumbnail a JPEG or PNG of the same size under 10 MB (a remote render's is a JPEG). If anything is wrong, nothing is saved and the invalid_input error lists every problem with its exact fix: fix them all, then call once more. It also refuses with invalid_input when /workspace/remix-studio/run.json is missing or the run expired. Free: no credits are charged. Returns {run_id, status: completed, video_url, thumbnail_url, video_id, title, studio: remix_studio, width, height} and shows the video in its result widget. Safe to call again on a finished run. Examples: {"run_id": "5b1f0c2a-8d3e-4f6a-9b7c-0d1e2f3a4b5c", "render_job_id": "7c9e6679-7425-40de-944b-e07fc1f90ae7", "title": "Skate remix"}, or {"run_id": "5b1f0c2a-8d3e-4f6a-9b7c-0d1e2f3a4b5c", "video_path": "/workspace/remix-studio/out/final.mp4", "thumbnail_path": "/workspace/remix-studio/out/thumbnail.jpg", "title": "Skate remix"}.
flashloop_remix_list_presets
ChatGPTList the Remix Studio presets: reference edits ready to remix with the user's own footage or subject. Free. There are two kinds: the Flashloop presets (source: flashloop, a slug id) and the presets this user made from their own runs (source: user, a uuid id, newest first). Returns {presets: [{id, title, summary, category, reference_video_url, thumbnail_url, preview_url, width, height, duration_seconds, inputs: [{path, label, kind, required, min_items, max_items, max_length, help}], source}]}; category is personalized_edit, style_transfer or motion_transfer, and inputs is the run form: what each preset needs from the user. With preset_id it returns that one preset as {...preset, prompt, images}: a user preset's own instructions and reference images (null and [] for a Flashloop preset). A preset's id, width and height go to flashloop_remix_create_run. Examples: {}, or {"preset_id": "cinematic-film-look"}.
flashloop_remix_list_runs
ChatGPTList the user's Remix Studio runs, newest first, or get one run by run_id. Free and read-only. Without run_id it returns {runs: [run], next_cursor}; pass next_cursor as cursor for the next page (null means no more). With run_id it returns that one run. Each run is {run_id, title, status, expired, created_at, expires_at, prompt, preset_id, preset_title, reference_url, output: {width, height}, source, video_url, thumbnail_url}; status is in_progress, expired or completed, and video_url is set once the final video is registered. Examples: {}, or {"run_id": "5b1f0c2a-8d3e-4f6a-9b7c-0d1e2f3a4b5c"}.
flashloop_start_video
ChatGPTCreate a Faceless video project in the user's Faceless Studio, free of charge. Returns series_id and one project_id per episode. Pass that project_id to flashloop_exec to build the episode in its own sandbox, then upload the finished video with flashloop_upload_media and register it with flashloop_finish_video. A user can have at most 8 videos in progress.
flashloop_translate_audio
ChatGPTTranslate spoken audio into another language while preserving the voice. Async — returns a job_id (kind voice_generation); call wait_for_job for the translated audio URL. audio_url accepts a raw public URL or a url returned by upload_media. target_language is a language code/name; voice_id (from list_voices) is an optional voice override.
flashloop_update_reference
ChatGPTRename one of the user's own saved references, and re-file an element's category or a character's role. Curated library rows and other people's rows cannot be edited. The PICTURE is deliberately not editable here. It is what every later generation references, and it was moderated when the row was created — a different look is a new reference, not an edit to this one. Save the new picture with upload_reference instead.
flashloop_upload_media
ChatGPTUpload a media file so it can be used as a reference in create_image / create_video, or registered as a finished video. Four input paths, by where the media lives: (1) a file in a code-execution environment (the Flashloop sandbox of flashloop_exec, or the chat's own: attachments on claude.ai and ChatGPT are written there as a real file): pass filename + content_type (no url, base64 or files) to get an upload_url, a public_url and a curl command; run that command in the environment, replacing <file> with the file's path, to send the bytes straight to storage (no size limit from the tool call, no token cost). The file is then served at public_url. Two outcomes: a reference or file the user brought (no project_id) belongs in the user's Assets, so call this tool again with url set to that public_url (and kind, content_type) to register it there and have it moderated; a file made for a Faceless video project (pass its project_id from flashloop_start_video) is never registered as an asset: hand the public_url to flashloop_finish_video, which files it under Faceless Studio. A client's own sandbox may need the storage host in the command allowed in its network settings; when the curl is blocked, use flashloop_upload_widget. (2) a public URL: pass url (up to 100MB); (3) files auto-populated by ChatGPT (openai/fileParams): pass them as files; (4) a tiny file (up to 100KB): pass base64 + content_type. Base64 is emitted token by token, so it stalls for minutes above ~100KB and fails past 500KB. When there is no code-execution environment, flashloop_upload_widget lets the user pick the file. Returns an asset_id and a url; the url is accepted by reference_image_urls in create_image / create_video. Uploaded media is moderated; rejected media can't be used. Calls the Flashloop API (https://www.flashloop.ai/mcp).
flashloop_upload_reference
ChatGPTSave an image the user ALREADY has as a reusable reference. FREE and INSTANT — nothing is generated, the image is stored as-is and the row comes back ready to use immediately. This is the natural way to turn something you just made into something reusable: generate a portrait with create_image, show it to the user, and when they like it save it here. It costs nothing and there is no wait. kind 'character' — a PERSON. name is required (it is how the user will refer to them) and exactly one image is saved. There is no autofill on this path. kind 'element' — an OBJECT or prop. Saves a whole batch in one call; name and category are filled in server-side per image. Every URL is moderated and ONE blocked image rejects the WHOLE batch. There is no upload path for LOCATIONS — use create_reference to generate one. To generate a person from a description rather than save an existing picture, generate the portrait with create_image first and then save it here.
flashloop_upload_widget
ChatGPTOpen an interactive upload widget where the user picks one or more local reference images from their device. It needs no sandbox network access, which makes it the option when the curl command of flashloop_upload_media is blocked or there is no code-execution environment. model_id (from list_models) sets the widget's limits: how many images, accepted formats and max file size for that model. Each file is uploaded and moderated immediately; when the batch finishes the widget posts all resulting URLs into the conversation by itself (a 'Done' button appears only when the host refuses that post). Those URLs are accepted by reference_image_urls. The widget accepts images only; video/audio references are uploaded with upload_media from a public URL.
flashloop_upscale
ChatGPTUpscale an EXISTING image or video 2x or 4x with Topaz for sharper, higher-resolution output from a file the user already has, not a new generation. Applies to requests to enhance, upscale or enlarge a file; create_image / create_video take a prompt and have no source url or factor parameter. Pick a model_id from list_models — any entry with type: 'upscale' (its upscale_input_type field says whether it takes an image or a video; this tool reads that field to route the request, and the wrong kind of source for the model returns an error). source_url must already be a reachable https URL; a file attached in chat or in the code-execution environment becomes one through flashloop_upload_media (its description covers the sandbox curl and upload widget paths), which returns the url to pass here. Returns a job_id; call wait_for_job for the finished output url, exactly like create_image/create_video. Pricing is NOT something this tool (or estimate_cost) can quote up front: the real charge is computed server-side from the source's actual duration or resolution, not from anything passed to this call. credits_remaining before and after, or the completed job's credits_used, gives the real number.
flashloop_wait_for_job
ChatGPTWait until an async generation (returned as a job_id by create_video/create_image and the voice/character tools) reaches a terminal state, then return its result (status + URLs). A timeout means the job is still processing; calling wait_for_job again with the same job_id keeps waiting and nothing is lost. The card rendered by create_image/create_video already shows the generation to the user live.
flashloop_whoami
ChatGPTReturn the signed-in Flashloop user's identity, credit balance, and subscription. Shows which account is acting and how many credits it has.