add_style_kit_item
ChatGPTAdd an item to a style kit. type: "text" needs content (a free-text guideline, e.g. "cinematic lighting, teal and orange grade"). type: "palette" needs colors (1-50 {hex, name?} entries) — keep a kit to ONE palette item; add every color into it (via update_style_kit_item if it already exists) rather than creating a second, even if asked for a separate/named palette — not every client that can view a kit renders more than one. type: "image" needs exactly one of input (an existing asset — {assetId} from upload_image/confirm_upload — or a previous generation's output — {generationId, outputIndex?}) or imageUrl (a public https URL the server fetches). Image items process asynchronously — check get_style_kit until assetStatus is "ready" before relying on it in a generation. When adding several items, complete every addition first, then call get_style_kit once to show the final widget; do not wait for image processing.
clone_voice
ChatGPTCreate a custom voice from a recording of it, usable afterwards in generate_voiceover (text-to-speech only — cloned voices can’t be used for speech-to-speech). Needs an audio sample of the voice: get one with upload_widget (type: "audio") where the client supports it, otherwise upload_audio, and pass the returned assetId as input: { assetId }. At least 10 seconds of clear speech; name is what the user will see the voice called. Optional: description, gender, previewLanguage (the language of the preview clip the new voice reads back — the voice can still speak any supported language), removeBackgroundNoise. Cloning always costs credits and always requires approval: the first call returns { status: "confirmation_required" } with the cost and a consentStatement — STOP, show the user BOTH, and only after they explicitly approve in a new message re-call with confirmCost: true and consent: true. Never set either flag yourself. On approval it returns { status: "queued", generationId } — poll get_generation_status until it completes, then find the new voice with list_voices (custom: true).
confirm_upload
ChatGPTFinalize a presigned upload: after PUTting the bytes to the uploadUrl from upload_image / upload_video / upload_audio, call this with the same uploadId and mimeType. Runs storage (and moderation, for images) and returns { assetId, ... } — the durable handle for input: { assetId } in generate_image / generate_video. If the response has urlPending: true and no url, that is NOT a failure — generation works immediately from the assetId.
create_style_kit
ChatGPTCreate a complete brand/style kit for a named brand; use when the user says create style kit, brand kit, or visual identity. Create the kit, then add a practical palette, written style guidelines, and selective visual references in the same turn. First add the primary logo or wordmark from an official site, press/media page, or official social channel; official SVGs are supported and converted to PNG automatically. Also add meaningful logo variants that are readily available, such as light/dark, horizontal/stacked, or icon-only, without exhaustive research. Do not use campaign images, screenshots, stock imagery, search thumbnails, or logo-directory results in place of the primary logo. If no official logo is available after a quick check, use the most reliable exact public logo reference rather than asking the user to supply one. Add an iconic product or marketing image only when it is strongly and unambiguously associated with the brand. Avoid duplicates and images dominated by another brand. Use the resulting kit by default for the user’s next image/video request, unless they opt out. After all additions, call get_style_kit once to show the final widget.
delete_style_kit_item
ChatGPTDelete an item from a style kit.
generate_3d_model
ChatGPTArtlist 3D generation. Supports text-to-3D from a prompt and image-to-3D from one input image. Image-to-3d: pass input: { assetId } (an uploaded image from upload_image / confirm_upload) or input: { generationId, outputIndex? } (a previous image generation) — ONE image only, no arrays; a prompt is optional. Text-to-3d: pass a prompt describing the object with no input. Optional settings (a single quality preset: low / medium / high, default medium) are validated against get_model_config; omitted keys use the model's defaults, echoed back as resolvedSettings. Returns { status: "queued", generationId } — immediately call get_generation_status; 3D models can take several minutes (deadline 540 s). The result is a textured GLB file with a preview image and extra download formats (OBJ / FBX / USDZ / …), not an image. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_batch
ChatGPTArtlist batch generation: several images and/or videos from one request, quoted and approved as one job. Use it whenever one request needs two or more generations with different prompts or inputs ("5 product shots", "ten stills and two clips") — never split such a request into separate generate_image/generate_video calls or several batches. For more takes of ONE prompt, use generate_image with settings.num_images instead. Each job takes the same arguments as generate_image or generate_video plus type. A batch holds at most a fixed number of jobs; over that it returns batch_too_large with maxJobs — then tell the user you can make at most that many in one go, and ask which to make first. Every job is checked and priced before any is created: if one is invalid it returns batch_invalid with each job's problem and nothing is spent. If it returns { status: "confirmation_required" }, nothing was spent: STOP, show the user the total (and how many generations it covers), and wait for their explicit approval in a new message — only then re-call with identical jobs plus confirmCost: true and approvedPrice set to that total. Never set confirmCost on your own. Otherwise it returns { status: "queued", jobs } with one outcome per job: queued (with generationId), failed (nothing charged), not_started (nothing charged) or unknown (may have been made and charged). Poll the queued generationIds with get_generation_status, at most 12 per call. Never resend a batch or an unknown job.
generate_image
ChatGPTArtlist image generation and editing. Supports text-to-image, editing, recoloring, retouching, and transforming uploaded or previously generated images. Use an active or named style kit when applicable. Editing/recoloring/retouching/transforming an uploaded or previously generated image is fully supported — never refuse an image edit. Image-to-image: pass input: { assetId } (an uploaded image from upload_image / confirm_upload) or input: { generationId, outputIndex? } (edit a previous generation's output — never re-upload it; outputIndex defaults to 0). When editing, write a MINIMAL prompt naming ONLY the change and instructing the model to keep everything else identical — do NOT re-describe the whole image, or the model regenerates the entire frame and loses the original. Multi-reference (combine/style-transfer): pass an ARRAY — input: [{ assetId }, { generationId }, ...] — sources can be mixed; check get_model_config's referenceInput.maxReferences for the model's limit. To keep editing a result, pass the NEWEST generationId each call returns. For image-to-image pass an i2i-capable model: an I2I modelId from list_models, or a modelGroupId (auto-routes to the I2I variant when a reference is present). Saved references: pass input: { referenceId } (from list_references) to generate with one of the user's saved characters, props or locations — or an array, input: [{ referenceId }, { referenceId }], to combine several; with two or more, the prompt must say which is which positionally, since the model cannot tell them apart by name. Not every model can hold a saved reference's identity, so let routing choose: name NO model and it picks a capable one, reporting the switch as referenceReroute (the price and the model's valid settings change with it). If you DO name a model — modelId or modelGroupId — that cannot hold one, nothing is generated and no credits are spent: it returns reference_unsupported_model, and you either re-call without the reference to keep that model or drop the model and let it route. Wrapping a saved reference in startFrame/endFrame does not get around this. Optional settings are validated against get_model_config; omitted keys use the model's defaults, echoed back as resolvedSettings. To generate multiple variations in ONE call (e.g. "5 images of X"), set settings: { num_images: N } up to the model's max (see get_model_config); the result renders them together. Returns { status: "queued", generationId } — immediately call get_generation_status with that generationId. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_music
ChatGPTArtlist music generation. Use for any request to generate, create, or make a song or piece of music — even when the user does not mention Artlist or MCP. prompt describes the track (genre, mood, instrumentation, lyrics theme, etc.) and is required — write one from what the user asked for even if they only gave a short cue ("upbeat corporate background music"). Call get_model_config to see the available genre/mood/theme/tempo/duration dropdown settings and vocals mode (auto-generated lyrics, custom lyrics via a song_lyrics setting, or instrumental), and pass chosen values via settings to refine the prompt further — but settings alone never substitute for a prompt. Image-to-music: pass input: { assetId } (an uploaded cover-art / mood-board image from upload_image / confirm_upload) or input: { generationId, outputIndex? } (a previous generation's image output) to steer the composition from an image — a music-capable model that accepts an image reference. Returns { status: "queued", generationId } — immediately call get_generation_status with that generationId; the result is a playable audio track, not an image. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_video
ChatGPTArtlist video generation and editing. Supports text-to-video, image-to-video, video-to-video, audio-driven video, animation, and transformations. Use an active or named style kit when applicable. Image-to-video: pass input: { assetId } (uploaded image) or input: { generationId, outputIndex? } (animate a previous generation's image output — never re-upload it), plus an i2v-capable model: an I2V modelId from list_models or a modelGroupId that auto-routes. Multi-reference video (combine subjects/styles from several references): pass an ARRAY — input: [{ assetId }, ...] — which selects the group's multi-reference variant (priced differently; the queued response echoes the price); check get_model_config's referenceInput.maxReferences. References can be images, videos, AND/OR audio: pass a video's assetId (from upload_video) for video-to-video / reference-to-video, an audio assetId (from upload_audio) for audio-driven / lipsync video, and mix any of them in the array freely (e.g. Seedance R2V, image + audio for a talking character). Use the uploaded video/audio directly — do NOT extract a frame or transcode. A video/audio reference needs a model that supports it (Seedance R2V is multi-to-video; the authority is get_model_config's videoReferenceInput / audioReferenceInput — pass its modelGroupId to auto-route). For audio-driven video, set generate_audio: true when get_model_config marks it supported. Start/end-frame interpolation: pass input: { startFrame: ref, endFrame?: ref } (each an image assetId or generationId) to interpolate between two frames; start alone is image-to-video, end requires start, and it needs a frames-capable model (get_model_config.frameInput). Draft mode: when get_model_config reports draftMode (Seedance 2.5), 480p makes a cheap draft that render_draft later renders in 1080p as the same take (within 7 days). Cost scales with duration — use the length the user asked for, or the model's default when they didn't say. Saved references: pass input: { referenceId } (from list_references) to animate one of the user's saved characters, props or locations — or an array, input: [{ referenceId }, { referenceId }], to combine several; with two or more, the prompt must say which is which positionally, since the model cannot tell them apart by name. Not every model can hold a saved reference's identity, so let routing choose: name NO model and it picks a capable one, reporting the switch as referenceReroute (the price and the model's valid settings change with it). If you DO name a model — modelId or modelGroupId — that cannot hold one, nothing is generated and no credits are spent: it returns reference_unsupported_model, and you either re-call without the reference to keep that model or drop the model and let it route. Wrapping a saved reference in startFrame/endFrame does not get around this. Optional settings are validated against get_model_config; omitted keys use defaults. Returns { status: "queued", generationId } — immediately call get_generation_status; videos can take several minutes (deadline 540 s). If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost from that result, and wait for their explicit approval — only then re-call with the same arguments plus confirmCost: true. Never set confirmCost on your own.
generate_voiceover
ChatGPTGenerate a voice-over in a chosen voice. Two modes, switched by input: text-to-speech (pass text to speak) or speech-to-speech (pass an audio input to re-voice a recording in the chosen voice — input: { assetId } from upload_audio, or input: { generationId } to re-voice a previous voice-over). First pick a voice with list_voices (present voices to the user by name/traits — never show any id), then pass its voiceId. For speech-to-speech the voice must be speech-to-speech-capable (find one with list_voices sts: true); cloned/custom voices are text-to-speech only, and any text is ignored when an audio input is present. Optionally call get_model_config with that voiceId to see the language / accent / emotion / speed options the voice supports, and pass chosen values via settings (omitted keys use the voice’s defaults). Omit modelId/modelGroupId to auto-route to the voice-over model; a voiceId that the pinned model can’t use is rejected in plain language. Returns { status: "queued", generationId } — immediately call get_generation_status with that generationId until it completes. If instead it returns { status: "confirmation_required" }, no credits were spent: STOP, show the user the cost, and only re-call with confirmCost: true after they explicitly approve. Never set confirmCost on your own.
get_balance
ChatGPTGet the user's plan and remaining AI credits — or, for users without an AI-credit plan, their remaining one-time free generations. Call when the user asks about their credits, balance, plan, or how many more generations they can make. Read-only. Present the values conversationally ("You have 120 credits left"), never as a raw dump; if the result says the balance is unavailable, say you couldn't check right now and offer to try again shortly.
get_generation_cost
ChatGPTGet the exact credit cost for a planned image, video, music, 3D model, or voice-over generation — or for rendering a Seedance 2.5 draft in 1080p (kind "draftRender" + generationId) — without starting it. Pass the same kind, prompt or text, modelId/modelGroupId, settings, and reference input you would use for the matching generate tool; use get_model_config for settings and list_models for a model. This is a read-only price quote — it never creates a generation. Call it whenever the user asks how many credits a generation will use; do not estimate from static sources. If the user then asks to generate, call the matching generate tool, which performs a fresh quote and its normal confirmation gate.
get_generation_status
ChatGPTCheck whether a generation has finished and get the result — pass one generationId, or an array of several to monitor them together (for example, one per style kit) instead of calling this tool separately for each. Blocks up to ~50 s waiting for completion, then returns immediately. If status is "pending", call again immediately with the same argument — do not sleep between calls; for an array, pass the exact same array again, even once some of its ids have individually completed. A single generationId returns its own result widget once done. An array stays quiet (no widget, no individual result cards) until every id in it reaches a final state, then returns one combined gallery so no result is lost when the host collapses repeated status cards. When completed, returns the image inline (small results) or a file URL; for a 3D model it returns the GLB URL, a formats list with per-format download links, and the preview thumbnail inline.
get_model_config
ChatGPTGet a model's configurable settings — keys, allowed values, defaults, required flags — for a modelId or modelGroupId from list_models. Call before generating; pass chosen values via settings. Media inputs (reference images) go through the generate tools' input argument, not settings. Voice-over: pass a voiceId from list_voices to narrow the language / accent / emotion / speed options to what that voice supports. draftMode: true means the model's 480p resolution makes a draft that render_draft can later render in 1080p.
get_recent_uploads
ChatGPTFetch the reference(s) the user just uploaded through the upload panel (upload_widget), as assetId(s). Call this as soon as the user’s message says they uploaded / added / attached a file via the panel — the panel cannot pass the assetId to you any other way, so without this call you have nothing to generate from. Optional kind narrows to "image" | "video" | "audio". Returns { status: "ok", uploads: [{ assetId, kind, fileName?, uploadedSecondsAgo }], routing } newest-first — follow routing to the right tool for each kind, and never show an assetId to the user. If it returns { status: "no_recent_uploads" }, the panel upload did not finish: ask the user to pick the file again, or fall back to upload_image / upload_video / upload_audio.
get_style_kit
ChatGPTView a style kit's full contents: its text guidelines, color palettes, and image items (with each image's readiness status and, once ready, a preview URL). Use this to show the user what's in a kit, or to check whether a just-added image has finished processing (assetStatus: "pending" → "ready").
get_track
ChatGPTLook up full details for one or more Artlist music tracks by songId, taken from a search_music result. Returns title, artist, duration, tempo, genres and a preview audio URL, plus — on request — separated stems, similar tracks, or the song's other versions. Pass includeSimilar: true for "more like this"; includeVersions: true when the user asks what versions exist. This tool cannot download — send the user to the returned artlist.io link.
list_generations
ChatGPTList the user's recent generations (paginated). Use to find a past result to show or iterate on.
list_models
ChatGPTList available generation models with ids, names, and features. kind: "image" (default), "video", "voice" (voice-over models), "music", or "model3d" (3D model generation). Optional feature filter: "text-to-image" | "image-to-image" | "text-to-video" | "image-to-video" | "multi-to-video" | "text-to-speech" | "speech-to-speech" | "voice-cloning" | "text-to-music" | "image-to-music" | "image-to-3d" | "text-to-3d". Use to resolve a model the user named, find an i2i/i2v/multi-reference-capable model, a text-to-speech / speech-to-speech voice-over model, a music model, or an image-to-3d / text-to-3d model, or answer what's available.
list_references
ChatGPTList the user's saved references — reusable characters, props and locations they created in Artlist Toolkit — so one can be used in an image or video generation. Call this whenever the user names one ("use Emma", "my sword prop", "that cave location", "the character I made") or asks which references they have. Optional type narrows to "character", "prop" or "location"; optional name filters by a case-insensitive substring. Each result returns the reference's name and type plus an inline picture of it; previewIndex gives the position of that picture among the images returned alongside the JSON. Present them to the user by name and picture and let them choose — NEVER show the id, and never pick one for them when several match. To generate with the chosen reference, pass input: { referenceId } to generate_image or generate_video (an array of them to combine several in one generation).
list_style_kits
ChatGPTList the user's saved style kits (name, id, item count). A style kit bundles reference images, text guidelines, and color palettes that can be applied to a generation via generate_image/generate_video's styleKitId. Call this when the user wants to generate with a style/brand kit or asks what kits they have.
list_voices
ChatGPTList voice-over voices (identities) to choose from before generating a voice-over. Library voices by default; custom: true for the user's own cloned voices. Optional filters: modelGroupId (only voices usable by that voice model group), gender (MALE / FEMALE / NEUTRAL), sts: true (speech-to-speech-capable voices), query (name match). Each voice returns name, gender, age, languages, accents, and a preview URL. Present voices by name and traits; never show voiceId or any id to the user.
record_uploads
ChatGPTInternal — used by the upload panel to hand its confirmed uploads to the server. Do not call this; read uploads with get_recent_uploads instead.
render_draft
ChatGPTRender a Seedance 2.5 draft video (a 480p generation) in full 1080p. This continues the SAME take at higher quality rather than generating a new one; the draft's prompt, settings and references are reused, so pass only the draft's generationId (plus outputIndex for a multi-output generation). Only drafts can be rendered, and only within 7 days of creation: get_generation_status reports drafts[].renderableUntil on a draft. Charges the normal 1080p price. Returns { status: "queued", generationId } — immediately call get_generation_status with the NEW generationId. If it returns { status: "confirmation_required" }, no credits were spent: show the user the cost and wait for their explicit approval, then re-call with confirmCost: true. On draft_unavailable, generate the video again at 1080p with generate_video instead; on reference_expired, tell the user the uploaded file must be uploaded again. On render_failed, tell the user the returned message.
search_music
ChatGPTSearch the Artlist stock music catalog for tracks that already exist. Results are ordered like artlist.io by default (Staff Picks) — do NOT pass sortBy unless the user asks for newest or most popular. Supports free-text search (mood, genre, instrument, artist, lyric fragment), vocal type, BPM range, duration range, genre categories, and a stems-only filter. Returns title, artist, duration, tempo, a preview audio URL and a link to the track on artlist.io. Use this to find, browse or discover catalog music. To create NEW music from a prompt instead, use generate_music. This tool does not download — send the user to the returned artlist.io link.
search_sfx
ChatGPTSearch the Artlist stock sound-effect catalog for clips that already exist. Results are ordered like artlist.io by default (Staff Picks) — do NOT pass sortBy unless the user asks for newest or most popular. Supports free-text search (what the sound should be — "glass breaking", "footsteps on gravel", "whoosh transition"); refine a search further with categoryIds or tags, but only using values copied from a previous result's categories or suggestedTags fields — never invent one. Returns title, a preview audio URL, a link to the clip on artlist.io, a link to the SFX pack the clip belongs to (packUrl, null when it has none), and curator-suggested tags for refining the search further. This tool always plays the ENTIRE clip — unlike music, sound effects have no highlight/preview window. Use this to find or browse catalog sound effects. This tool does not download — send the user to the returned artlist.io link.
update_style_kit_item
ChatGPTUpdate a style kit item's name or content (at least one required). An image item's content cannot be changed — delete it and add a new one instead.
upload_audio
ChatGPTStore a user-provided audio file and get a durable assetId back. Two modes: (1) pass audioUrl (a public https URL) — the server fetches and stores it; (2) pass mimeType (+ the user's real fileName whenever you know it — it names the asset and any generation made from it) to get a presigned uploadUrl + uploadId — PUT the file bytes to that URL (e.g. with curl), then call confirm_upload. Supported formats: MP3, WAV, M4A/AAC, OGG. Never send base64 data. Returns an assetId with two uses: (1) re-voice the recording in another voice (speech-to-speech) — pass input: { assetId } to generate_voiceover together with a speech-to-speech-capable voiceId from list_voices sts: true; (2) drive a video (audio-driven / lipsync) — pass input: { assetId } to generate_video (or mixed with image/video references in an array) with an audio-capable model (e.g. Seedance R2V-with-audio). If the user has a file on their DEVICE and this upload can’t complete in their client (the byte-upload is blocked, as in some sandboxed hosts), call upload_widget as a fallback — it opens an in-chat panel that uploads straight from the user’s browser.
upload_image
ChatGPTMake a user-provided image usable as a generation reference. Two modes: (1) pass imageUrl (a public https URL) — the server fetches, moderates, and stores it; (2) pass mimeType (+ the user's real fileName whenever you know it — it names the asset and any generation made from it) to get a presigned uploadUrl + uploadId — PUT the file bytes to that URL (e.g. with curl), then call confirm_upload. Never send base64 image data. Returns an assetId to pass as input: { assetId } to generate_image / generate_video. Not for generated outputs — pass input: { generationId } to the generate tools instead. If the user has a file on their DEVICE and this upload can’t complete in their client (the byte-upload is blocked, as in some sandboxed hosts), call upload_widget as a fallback — it opens an in-chat panel that uploads straight from the user’s browser.
upload_video
ChatGPTStore a user-provided video and get a durable assetId back. Two modes: (1) pass videoUrl (a public https URL) — the server fetches and stores it; (2) pass mimeType (+ the user's real fileName whenever you know it — it names the asset and any generation made from it) to get a presigned uploadUrl + uploadId — PUT the file bytes to that URL (e.g. with curl), then call confirm_upload. Supported formats: MP4, MOV, WebM. Never send base64 data. Returns an assetId — use it directly as a video reference in generate_video via input: { assetId } (or mix with image references in an array) for video-to-video / reference-to-video. Do NOT extract a frame from the video — pass the video itself. If the user has a file on their DEVICE and this upload can’t complete in their client (the byte-upload is blocked, as in some sandboxed hosts), call upload_widget as a fallback — it opens an in-chat panel that uploads straight from the user’s browser.
upload_widget
ChatGPTOpen Artlist’s in-chat upload panel as a FALLBACK for a file on the user’s DEVICE, when the direct upload_image / upload_video / upload_audio can’t complete in this client (the byte-upload is blocked — e.g. a sandboxed host whose egress can’t reach the upload URL). Prefer the direct upload tools first; open this panel only as a fallback when that path fails or the client can’t deliver the bytes. The user picks and uploads in the panel (it uploads straight from their browser). The panel NEVER tells you the assetId directly: the moment the user’s next message says they uploaded something, call get_recent_uploads to fetch the confirmed assetId(s), then generate IMMEDIATELY with them without asking anything further or re-confirming the request. type restricts what they can pick (default auto — image, video, or audio), maxFiles (default 1) allows several references at once for multi-reference models, label titles the panel (e.g. "Add your voice sample"). In clients without interactive panels (Claude Code / Cursor), use upload_image / upload_video / upload_audio.
