openart_account_get
ChatGPTGet the authenticated OpenArt account summary: email, subscription plan, and remaining credit balance. Use this for any question about the user's account, plan, or credits. Plan and credits are scoped to the current workspace; if a workspace field is present, attribute the numbers to that team, otherwise they are the user's personal account.
openart_creation_get
ChatGPTGet the read-only status (text only) of an OpenArt generation by historyId — does NOT show the result card. Returns PENDING or RUNNING while generating (with pollAfterSeconds), then terminal COMPLETED, FAILED, or CANCELLED. To show the result card, use openart_creation_show instead; for blocking completion on a CLI host, use openart_creation_wait. While a result card is visible it self-polls, so do NOT call this in a loop.
openart_creation_list
ChatGPTList past OpenArt generations in a project (defaults to the account default project); renders a generation-history widget where supported. One call returns every media type, so call it once. The widget handles filtering and pagination; while mounted, do not call this tool again because each call creates a new card. Without the widget, paginate with nextCursor. To reopen one item's result card, call openart_creation_show with its historyId, not this tool.
openart_creation_show
ChatGPTShow the OpenArt result card for an existing generation historyId — a visual, self-updating widget. Use whenever the user wants to see or re-open a result. Do NOT call it right after openart_generate_image / openart_generate_video — those already mount this card automatically. For text-only status instead of a card, use openart_creation_get.
openart_creation_wait
ChatGPTWait for an OpenArt generation (by historyId from openart_generate_image / openart_generate_video) to finish, then return it: COMPLETED with resource URLs, FAILED with an error message, or CANCELLED (terminal, no error). Only for hosts without an OpenArt result card (e.g. CLI); when a card is shown it self-polls, so skip this tool. If the wait elapses while still generating it returns STILL_RUNNING — not a failure: wait pollAfterSeconds, then call again with the same historyId to keep waiting. Set timeoutSeconds (1–90) to wait longer; defaults to 45.
openart_generate_image
ChatGPTSubmit an asynchronous image generation on OpenArt. Pick a model + mode via openart_model_list (modes: text2image, or image2image when the user supplies reference images), then openart_model_form_get(model, mode) for the exact fields, then call this with that model/mode and params filled to match. Generates 1 image unless params set a count. Returns a historyId with status PENDING — the image is NOT ready yet. If the host shows an OpenArt result card it self-polls: do NOT poll, openart_creation_get, openart_creation_show, or openart_creation_wait; tell the user it's underway and end your turn. On a CLI / text-only host, call openart_creation_wait(historyId) until it finishes. Send a fully-written prompt: expand the user's brief into a specific, detailed prompt unless they asked to use theirs verbatim. With no user to consult, choose the wording yourself and proceed.
openart_generate_video
ChatGPTSubmit an asynchronous video generation on OpenArt. Pick a model + mode via openart_model_list — each video mode (text2video / image2video / element2video) carries a description telling you when to use it; pick the mode fresh each turn from the user's actual intent, and when unsure between image2video and element2video choose element2video. Then openart_model_form_get(model, mode) for the exact fields, then call this with that model/mode and params filled to match. Returns a historyId with status PENDING. If the host shows an OpenArt result card it self-polls: do NOT poll or wait; tell the user it's underway and end your turn. On a CLI / text-only host, call openart_creation_wait(historyId) until it finishes — video often outlasts one wait window, so if it returns STILL_RUNNING call it again with the same historyId. Send a fully-written prompt: expand the user's brief into a specific, detailed prompt unless they asked to use theirs verbatim. With no user to consult, choose the wording yourself and proceed.
openart_model_cost
ChatGPTEstimate OpenArt credit costs (in credits). No arguments: prices every (model, mode) at its default config, cheapest-first — use for 'cheapest model' or 'how much does X cost'. With { model, mode, params }: prices ONE configuration (e.g. 4K, 10s) before generating. Each row's config is the settings priced, totalCredits is the cost of one job, and affordable says whether the account's balance covers the charge (if not, give the user upgradeUrl). See pricingNote for how to read and report a price.
openart_model_form_get
ChatGPTGet the input schema for a model + mode before generating. Pass a model and a mode from openart_model_list (e.g. text2image). Returns a JSON schema of the fields available for that mode. Then call the matching openart_generate_image / openart_generate_video tool with the same model/mode plus a params object filled per this schema.
openart_model_list
ChatGPTList the OpenArt models available via MCP, with a short description, which media each can produce (image / video / audio), each mode's default-config price, and whether the account's balance covers it. For a non-default config (e.g. 4K, 10s), call openart_model_cost. Generation flow. Step 1: among the modes marked affordable (when balance is present), pick the model and mode whose descriptions below best match the request's intent (subject, style, in-image text, audio, etc.). If what the user asked for is not affordable (a named model, or a medium with no affordable mode, e.g. video), do not generate it: tell them its price and their balance, and offer the affordable model whose description best fits their intent — an image model when no video is affordable — or adding credits, including upgradeUrl verbatim in your reply; switch only with their consent. Step 2: call openart_model_form_get with that model and mode for its input schema. Step 3: write the prompt against that form, then call openart_generate_image (image modes) or openart_generate_video (video modes). Send a fully-written prompt: expand the user's brief into a specific, detailed prompt unless they asked to use theirs verbatim. With no user to consult, choose the wording yourself and proceed.
openart_project_create
ChatGPTCreate a new project in the user's current OpenArt workspace, then target it by passing the returned project's id to the projectId parameter on openart_generate_image / openart_generate_video. Returns the created project (id, name, canGenerate). Creating more than one project requires an active subscription, and in a team workspace only an owner or admin can create projects; either limit returns a clear error. Call openart_project_list first to avoid duplicates.
openart_project_list
ChatGPTList the projects in the user's current OpenArt workspace. A project is the container a generation lands in; every user has a default project (isDefault), and generations target it unless you pass a project id. Each item's canGenerate flag says whether you can generate into it — only target a project with canGenerate: true via the projectId parameter on openart_generate_image / openart_generate_video. Paginated: when hasMore is true, pass nextCursor as cursor to get the next page; a member who reaches projects through grants gets their complete set in one page. Use openart_project_create to create one.
openart_run_video_tool
ChatGPTRun an OpenArt video tool on an existing video, picked by tool from the list below. First call openart_tool_form_get(tool) for its params and fill them to match, passing the source video as a reference: an upload or an earlier result. Before running, quote the cost with openart_tool_form_get(tool, params) and confirm it with the user; each run charges credits. Returns a historyId with status PENDING. If the host shows an OpenArt result card it self-polls: tell the user it's underway and end your turn. On a CLI / text-only host, call openart_creation_wait(historyId) until it finishes, again with the same historyId while it returns STILL_RUNNING. A result card's Try another ("Another look", "Another scene", "Another language") hands back a request for one more version of the same source: call openart_tool_form_get with the arguments of the tryAnother call it carries, offer a few choices the run did not use, quote the price, and confirm before running. To make a new video from a prompt or images, use openart_generate_video instead. OpenArt video tools: - dub-video — Dub Video: Translate the speech in an existing video into one or more languages, replacing the voice, with optional lip sync. The video needs audible speech and runs at most 3 minutes. (also: translate a video, dubbing, change the spoken language) Not for: Subtitles, captions or on-screen text, which it never changes; and new speech from a script. - replace-background — Replace Background: Put the subject of an existing video in a new scene, keeping the subject and its motion. Steer the scene with a preset, a reference image or a prompt. The source runs at most 240 frames (8s at 30fps). (also: change the background, background swap, green screen) Not for: Changing only the light on the original scene (relight-video), and making a new video from nothing (openart_generate_video). - relight-video — Relight Video: Change the lighting, mood or atmosphere of an existing video, keeping its content and motion. Steer the look with a preset, a reference image or a prompt. The source runs at most 240 frames (8s at 30fps). (also: change the lighting, relight, golden hour) Not for: Replacing the scene behind the subject (replace-background).
openart_tool_form_get
ChatGPTGet an OpenArt tool's form before running it. Pass tool, an id from openart_run_video_tool's list: returns what the tool does, a guide to settling its choices with the user, a JSON schema of its params, and preset options where it has them. Add params to check a call against the real source video before running it: the answer is then the check alone, not the form again — its price in credits (totalCredits is the list price; see pricingNote) and whether the balance covers it, or the issues to fix. Free; never charges.
openart_upload_import
ChatGPTImport chat attachments in OpenAI hosts with native attachment binding; no second picker is needed. Supply host-provided file objects with file_id and download_url, never invented values or local paths. Imports images, videos, and audio, returning accepted visualReference values without a separate metadata call. At most 10 files per batch, in reference order. Inspect every result and resolve required failures before generation. Retry only retryable failures with the same file IDs and Project, refreshing expired download URLs through the host. Stop after explicit network-policy denial.
openart_upload_list
ChatGPTList previously saved OpenArt reference assets in the current Workspace; renders an uploads-library widget where supported. Never use upload history to locate a newly attached chat file or wait for chat attachments to appear here. One call returns every media type, so call it once. The widget handles filtering, pagination and selection, and sends the picked files back as a chat message; while mounted, do not call this tool again because each call creates a new card. Without the widget, paginate with nextCursor. Each item includes a ready reference; use the field named by the model schema.
openart_upload_metadata_get
ChatGPTFetch media metadata and a ready visualReference. Generation backfills missing metadata. References in the upload-complete chat message from openart_upload_pick or successful openart_upload_import results are already verified; use them in generation without this call. Use this after a direct PUT you performed yourself to confirm acceptance (accessURL as mediaUrl; preserve uploadId and label), to inspect existing media, or to diagnose a generation rejected for source dimensions or file size. Pending or rejected uploads are not ready; a timeout means not yet accepted.
openart_upload_pick
ChatGPTUpload local or attached reference media through an interactive widget in Claude Desktop and other widget hosts. For OpenAI hosts that support native attachment binding, use openart_upload_import instead. Opens an upload widget where the user selects up to 20 reference images, videos, or audio files. The widget uploads and verifies the files internally. When the user clicks Continue, it sends an upload-complete message to the chat with the reference URLs for generation. The tool's initial ready status means the widget is open; wait for the upload-complete message before generation.
openart_upload_sign
ChatGPTRequest a presigned URL for direct transfer only in TUI/headless clients without widgets, when the caller can read file bytes and send an HTTP PUT. In widget hosts, use openart_upload_pick instead; widgets call this tool internally. This tool does not transfer bytes. PUT to signURL, then call openart_upload_metadata_get with accessURL and uploadId to wait for acceptance; the returned visualReference is provisional. Stop after explicit network-policy denial; retry only transient failures.
openart_workspace_list
ChatGPTList the user's workspaces — their personal workspace plus their teams — marking which one is currently active. Generations and library reads run in the current workspace; use openart_workspace_select to switch it. This list is always complete — the user's whole membership set, in one unpaged call. For the user's plan, credits, or email, use openart_account_get instead.
openart_workspace_select
ChatGPTSwitch the user's active OpenArt workspace. Pass an id from openart_workspace_list. Subsequent generations and library reads run in the selected workspace and bill its credits. Rejects a workspace the user is not a member of. Use openart_account_get to confirm the current workspace.
