Picsart GenAI MCP Server

Replaces the background of an image with a new scene described by a prompt, keeping the foreground subject intact. Auto-picks the newest enabled Picsart change-bg model unless overridden via the `model` param — no need to call `picsart_list_models` first. Use this when the user wants to "change the background to X", "put this on a beach", "swap the background for a marble counter", or any compositing where the subject is kept and the backdrop changes. Do NOT use this to strip the background to transparency (use `picsart_remove_bg`), upscale or sharpen (use `picsart_enhance`), convert raster to SVG (use `picsart_vectorize`), or generate a brand-new image from scratch (use `picsart_generate`). Required inputs: `image` — a publicly-accessible URL, not a local file path — and `prompt` describing the new background. Optional: `model` to pin a specific change-bg model; preflight the explicit model id you plan to use (the default path may select `recraftv3-replace-bg` rather than the legacy `picsart-change-bg`). Example: `{ image: "https://example.com/product.jpg", prompt: "polished marble countertop with soft window light" }`. Returns `{ assets, id, model, created_at, prompt, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` plus a `resource_link` block per result URL. `id` is the SDK's generation handle; `metadata` may include model-specific tags (e.g. `exploreImageId` for Recraft Explore models). Spends credits. Requires Authorization: Bearer <picsart_token>.

Returns the current Picsart credit balance for the authenticated user — `balance` (active credits available now) plus the breakdown into `resettable` (recurring monthly/period quota) and `accumulative` (top-ups and add-ons), `total` (active credits across both pools), and `overdraftUsage` (credits spent past the balance, if any). When the resettable pool has a scheduled reset, `nextResetDate` is the ISO timestamp of the next refill. Use this before expensive operations to warn the user when the balance is low, or after a 402 from `picsart_generate` to confirm the issue is credits and not something else. Do NOT use it to estimate the cost of a specific generation (use `picsart_preflight`); this tool only reports the balance, not per-call cost. Takes no input. Returns `{ balance, total, resettable, accumulative, overdraftUsage, nextResetDate? }` where each number is non-negative. Requires Authorization: Bearer <picsart_token> (per-user account data).

Single entry point for the authenticated user's Picsart Drive. Pass `action`: - `list`: browse a folder. `folderUid` omitted = Drive root; set it to descend. Folders are returned first; files are paginated (`page`, `pageSize`<=128, optional `sort`, optional `type` filter). Set `flat: true` to list every file across all folders (folders are omitted in flat mode). - `create_folder`: requires `name`; `folderUid` = parent (omit for root). Optional `description`. - `upload`: save a file. Provide EITHER `file` (chat attachment) OR `url`+`name` (an HTTPS URL or an inline `data:` URI — data URIs are pushed to the Picsart CDN first). `folderUid` = destination, `type` = resource kind. `result.url` is the CDN-hosted URL of the saved file, ready to pass to `picsart_generate` reference params like `imageUrls`. - `move`: requires `itemUids`; `targetFolderUid` = destination (omit = root). - `delete`: requires `itemUids`; soft-deletes to trash unless `permanent` is true. - `update`: requires `itemUid` + `attributes`; sets custom key/value attributes on a file (e.g. `{ coverUrl }`). Every action returns the current folder listing (folders, files, page math) so the widget can render. Requires Authorization: Bearer <picsart_token> (per-user Drive content).

Upscales and enhances an image — sharpens edges, denoises, and raises resolution by an optional scale factor. Auto-picks the newest enabled Picsart upscale / enhance model unless overridden via the `model` param. Use this when the user asks to "upscale", "enhance", "make it higher resolution", "sharpen", "clean up this photo", or "make this 4k". Do NOT use this to remove the background (use `picsart_remove_bg`), replace the background (use `picsart_change_bg`), convert raster to SVG (use `picsart_vectorize`), or generate a new image (use `picsart_generate`). Required input: `image` — a publicly-accessible URL, not a local file path. Optional: `model` to pin a specific enhance model, `scaleFactor` (e.g. 2 or 4) for upscale ratio. Example: `{ image: "https://example.com/photo.jpg", scaleFactor: 4 }`. Returns `{ assets, id, model, created_at, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` plus a `resource_link` block per result URL. `id` is the SDK's generation handle; `metadata` may include model-specific tags. Spends credits. Requires Authorization: Bearer <picsart_token>.

Runs any Picsart AI model end-to-end to produce an image, video, audio, or text result. Spends credits. Recommended flow: `picsart_list_models` to pick the model → `picsart_model_params` to learn its inputs → `picsart_preflight` to validate the payload and quote cost → `picsart_generate` to actually run. Do NOT use this for editing operations that have dedicated tools — background removal (`picsart_remove_bg`), background replacement (`picsart_change_bg`), upscale / enhancement (`picsart_enhance`), or raster-to-SVG conversion (`picsart_vectorize`). Also do NOT use it to validate params, quote cost, or browse the catalog — those are separate tools above. Required inputs: `model` (id) and `prompt`. Model-dependent optional inputs: `duration` (video seconds), `aspectRatio` (e.g. "16:9", "9:16", "1:1"), `resolution` (e.g. "1080p", "4k"), `count` (1–10 outputs), `quality`, `style`, `negativePrompt`, `imageUrls` (for image-to-X models), `videoUrl` (for video-to-X), `enhancePrompt`, `generateAudio`, and `extra` — a free-form record for model-specific params (discover them via `picsart_model_params`). Example (image): `{ model: "flux-2-pro", prompt: "a cat in a hat", aspectRatio: "1:1", count: 1 }`. Example (video): `{ model: "kling-v3-pro", prompt: "a cat skiing down a mountain", duration: 5, aspectRatio: "16:9" }`. Returns `{ assets, id, model, created_at, prompt, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` in structured content, plus one `resource_link` block per result URL — image models emit image links, video models emit video links (mime `video/mp4`). `id` is the SDK's generation handle; `metadata` may include model-specific tags (e.g. `exploreImageId` for Recraft Explore models). Text/LLM models (mode "text" in the catalog — e.g. gemini-3-pro, gpt-5.5, claude-*) run synchronously (`async` is ignored) and return the generated text as the text content block plus `text` in structured content. ChatGPT renders images and videos with the Picsart media gallery UI; clients fetch the assets from URLs, never base64. Spends credits and writes to the user's Picsart Drive when the Drive option is enabled. Requires Authorization: Bearer <picsart_token>.

Checks a generation job started by `picsart_generate` with `async: true`. Widget-facing: widgets poll this every few seconds with the returned job handle; assistants normally call `picsart_generate` synchronously and never need this tool. While running it returns `{ status: "ACCEPTED"|"IN_PROGRESS", progress?: { percent, estimatedSecondsLeft } }`. Once finished it returns the same media payload `picsart_generate` would have returned (`{ status: "COMPLETED", assets, results, url, ... }`), or an error for FAILED/CANCELED jobs. Requires Authorization: Bearer <picsart_token>.

Lists Picsart AI models across ALL modes (image / video / audio / text) and renders the Picsart Studio model-picker widget so the USER can browse, compare, and pick a model visually. Each item carries `id`, `name`, `mode`, `inputType` (and `provider`, `badges`, `description` when `verbose` is true). Use this when the user wants to SEE the available models or pick one themselves — especially when they have not committed to an output mode yet, or for cross-mode searches ("all flux models", "every model with image input"). For known output modes prefer the dedicated tools — `picsart_list_image_models`, `picsart_list_video_models`, `picsart_list_audio_models` — they route better from implicit prompts and need fewer filters. Do NOT use it to fetch a single model's parameter schema (use `picsart_model_params`) or estimate per-call cost (use `picsart_preflight`). If you only need catalog knowledge for your own reasoning (no UI shown to the user), use `picsart_model_catalog` instead. Inputs (all optional): `mode` (filter to image/video/audio/text — text = LLM models that return generated text), `provider` (case-insensitive substring like "flux", "kling", "google"), `acceptsImage` (true → only models that take an image input — i2i, i2v, i2t), `acceptsVideo` (true → only models that take a video input — v2v, v2a, v2t), `acceptsAudio` (true → only models that take an audio input — a2v, sts), `inputType` (exact-match escape hatch; one of t2v/i2v/v2v/a2v/t2i/i2i/t2a/v2a/tts/sts/sfx/music/t2t/i2t/v2t), `limit` (1–100, default 20), `verbose` (default false; when true each item adds provider/badges/description). inputType codes — first letter is input modality, second is output: t2i (text→image), i2i (image→image), t2v (text→video), i2v (image→video), v2v (video→video), a2v (audio→video), t2a (text→audio), v2a (video→audio), tts (text-to-speech), sts (speech-to-speech), sfx (sound effects), music (music gen), t2t/i2t/v2t (LLM text output from text/image/video input). Example: `{ mode: "video", acceptsImage: true, limit: 10 }` returns image-to-video models. Returns `{ items, total, truncated }` — `truncated` is true when more matched than were returned; refine filters or raise `limit` (max 100) to see more. Read-only; spends no credits and works without authentication.

Apply a named effect (gaussian_blur, drop_shadow, stroke, ...) to a visual layer in an MP Scene, with catalog defaults filled for any omitted params. Returns the updated scene with the effect merged into the target layer's effects[] -- re-applying the same effect id REPLACES it (idempotent), so params can be tuned without stacking duplicate effects. Each param is validated by kind and numeric range; an unknown effect id, unknown param, or out-of-range value is rejected with a clear error. Discoverable effect ids and their parameter shapes (ranges, defaults) are listed under `supports.effects` in `picsart_media_get_capabilities`. Pure: takes the full scene by value, returns a new scene; no server-side state.

Apply a composite 'look' (e.g. vintage_bw, light_leak, shimmer) to a media OR scene_ref layer. A look wraps the layer's content into an isolated nested composition so the treatment hits the composited result as one image. TWO MODES: mode:'reference' (DEFAULT) just appends a thin entry to the layer's `looks[]` array ({look, params}) and KEEPS the layer's content as the look's subject — nothing is baked; translate/preview/query expand it just-in-time (resolveLooks), or call picsart_media_resolve_looks to bake a self-contained scene. This keeps the stored scene small and the look non-destructively editable (re-tune params / drop the entry / stack multiple looks). mode:'expand' eagerly bakes the full nested sub-scene now (the original behavior). Params have catalog defaults; omit `params` for the default look. Discoverable looks + params are under `supports.looks` in picsart_media_get_capabilities. NOTE: a layer carrying its own effects/animations/mask/blendMode can't take a look (the look's scene_ref wrapper can't preserve them). Pure: takes the full scene by value, returns a new scene.

Apply a named motion preset (glow_pulse, ken_burns, scale_pop, ...) to a visual layer in an MP Scene. Returns the updated scene with the preset's animations + effects merged into the target layer. Each preset declares an `appliesTo` set of layer content kinds (text/media/color) -- mismatches are rejected with a clear `preset_kind_mismatch` error. Discoverable presets and their parameter shapes are listed under `supports.motionPresets` in `picsart_media_get_capabilities`. Pure: takes the full scene by value, returns a new scene; no server-side state.

Instantiate a scene template with the supplied parameter bindings. Two modes: `reference` (DEFAULT, canonical) packages an `MpSceneRefContent` snippet (kind:'scene_ref' with bindings + optional timeScale/trim/fit) to drop into a parent scene's `layers[]`; at translate/preview time the ref becomes its OWN nested composition (keeps its resolution/duration, fit/transform honoured — the template stays a reusable parameterized unit). For a STANDARD library template (`mpscene://montage`, …) the parent needs NO `scenes` entry; the translator resolves it from the registry. `bootstrap` returns a complete resolved standalone `MpScene` (substitutes every `$param`, synthesizes asset entries for asset-typed parameters, strips the `parameters` declaration) — use it to bake an editable starting scene. `inline` MERGES the template's resolved concrete layers + assets INTO a target `scene` you pass (no scene_ref) and returns it — the 'bring a preset's editable layers into my composition' op (ids prefixed so nothing collides, assetId refs rewired, brought-in layer starts offset by `at`). Use `picsart_media_describe_scene_template` first to learn what parameters the template accepts. Pure: returns either `sceneRef` or `scene` plus the applied parameter map.

Apply a named text-animation preset (typewriter, fade_in_chars, slide_up_lines, ...) to a text layer in an MP Scene. Returns the updated scene with the animation appended to the layer's `content.animations[]`. Discoverable presets and their parameter shapes are listed under `supports.textAnimationPresets` in `picsart_media_get_capabilities`. Agents wanting custom shapes can write `MpTextAnimation` entries directly into a scene without going through this tool. Pure: takes the full scene by value, returns a new scene; no server-side state.

Render a cheap multi-frame OVERVIEW of a scene as low-res jpeg thumbnails with their scene times — `{ frames: [{time, url}] }`. Two modes: pass `times` (PREFERRED — you usually know the interesting moments: clip seams, animation midpoints, entrance ends) to get an EXACT thumbnail per requested time, rendered concurrently; or pass `frames` (default 8, max 24) for evenly-spaced sampling across the whole timeline (one image-sequence render at 1fps — integer-second granularity only). Sits between mp_render_preview (1 full-res frame) and picsart_media_export (full encode): use it to eyeball pacing, seams, and content presence across the WHOLE timeline before exporting, instead of calling mp_render_preview repeatedly. Requires `MP_EXPORT_TOKEN` (same auth as picsart_media_export). Validate the scene first.

Describe a single MP Scene template by URI -- returns its declared parameters (with types, defaults, ranges, required flags, descriptions) and composition dimensions. Use this before `picsart_media_apply_scene_template` so you know what to pass. Accepts `mpscene://<id>` URIs in v1; other schemes are deferred. Returns `{ id?, uri, composition, parameters }` where `parameters` is the full declarations map.

DETACH a scene_ref into editable layers: replace a resolvable scene_ref layer (or every resolvable one, if no `layerId`) with the referenced template's concrete resolved layers, inlined IN PLACE (prefixed by the ref layer's id, started at its `start`, assetId refs rewired). The result has no scene_ref for the expanded layers, so you can edit the brought-in layers directly. Inverse of the by-reference model: 'I referenced a template, now bake this instance to customize it beyond its parameters.' One level in v1 (a brought-in layer that is itself a scene_ref stays a reference — run again to go deeper). This is a SYNC op that does NOT fetch: it resolves only in-memory `mpscene://` refs (local `scenes{}` / inherited / registry). A REMOTE `https://`/`http://` ref (e.g. a CDN-hosted scene) is left as-is here — those ARE resolved automatically at translate / render-preview / query-layout time (and by the deck compilers mp_present/mp_bake_deck/picsart_media_overview when called over MCP, though their bare runners do not self-fetch), so detach after a translate/preview/query has inlined it, or inline the piece locally. Unresolvable refs (unfetched remote URLs / unknown ids) are left as-is in bulk mode; in single-layer mode they error. Pure.

Render a fully-authored MP Scene to a final file via the server-side `media-platform/v3/export` workflow, returning the output URL(s). `format:"video"` (default) renders an MP4; `format:"image"` renders a single PNG still. Unlike `mp_bake_deck` (a pure scene→scene deck compiler), this performs the ACTUAL render: it translates the scene to a V3/Replay project and dispatches it to the export service over an authenticated HTTP call — no local renderer. Requires an app token in the `MP_EXPORT_TOKEN` environment variable (the MCP host sets it in the server's `env`). Validate the scene (`picsart_media_validate_scene`) and check a frame (`mp_render_preview`) BEFORE exporting.

Returns the MP SDK tool layer's capabilities: supported layer content kinds, animatable properties, effect ids, transition ids, and operational limits (max duration, max layers, max resolution). Call this first when planning a composition so subsequent calls stay within supported bounds. The full document is large (~8K tokens); pass `sections` to fetch only the slices you need — PREFER the granular supports sub-keys over the whole `supports` block (e.g. ["effects","limits"] or ["generativeTemplates","limits"] for a montage plan). Top-level: supports, limits, engine, featureMatrix; supports sub-keys: effects, transitions, easing, blendModes, animatableProperties, textAnimationPresets, motionPresets, looks, layerContentKinds, sceneRefs, mask, generativeTemplates, presentation, export, templateModes, expressionAnimation. Idempotent and dependency-free; safe to cache.

Returns the JSON Schema for an MP Scene document. Use this to construct valid scenes from scratch or to remind yourself of the exact shape of layers, animations, effects, and transitions before calling picsart_media_validate_scene or mp_render_preview. The returned schema is authoritative; any document that validates against it is accepted by the renderer. Pass `name` (e.g. "MpMediaContent") to get back just that one definition instead of the full ~66 KB schema — its internal $refs point into the full schema's #/definitions.

Returns the curated font catalog. Use this before authoring any text layer so `font.family` resolves to a real font: every entry has a stable `key` (passable directly in MpFont.family) and a resolved `.otf`/`.ttf` URL. The renderer has no system-font fallback — passing CSS family names like `Inter`, `Arial`, or `Helvetica` produces empty text and a `unknown_font_family` validation error. Agents may also pass a direct font URL matching `accepted_url_pattern`. The tool is dependency-free and idempotent; safe to cache.

Enumerate the curated MP Scene template catalog. Each entry summarises a reusable, parameterized scene (title cards, lower thirds, product cards, ...). Use this to discover templates by id/category/aspect before describing or applying one. Returns `{ templates: [{ id, displayName, description, category?, width, height, parameterCount }, ...] }`. Pure: no inputs, no state.

Compile a presentation DECK (an MP Scene with one top-level `track` layer of `scene_ref` slide clips) into an OVERVIEW / 'badges' board: a single MP Scene that lays the SAME slide `scene_ref`s into a grid of shrunken thumbnails — same content, a spatial projection. Each cell is the page positioned at its grid-cell centre with `fit:"none"` and a baked contain-scale (the compiler resolves each page to read its real composition size, because `scene_ref.fit` fits against the whole composition, not a cell). Defaults: a near-square grid (`ceil(sqrt(n))` columns), the deck format for board size, and a duration long enough for every slide's entrance to settle. Carries the deck's `scenes`/`assets` so the refs still resolve. Override `cols`/`gap`/`width`/`height`/`duration`. Pure scene→scene; validate / preview / translate the output.

Apply a batch of incremental, ID-ANCHORED edit ops to an MP Scene and return the patched result — the token-cheap alternative to re-emitting the entire scene on every edit. Three verbs: `set` (create-or-replace a value; last-write-wins, idempotent; `replace` is accepted as a first-class alias), `remove` (delete a field/array element, or an entire anchored entity when no `path` is given), and `add` (insert a new id-keyed layer/asset/audio/marker; requires `kind` and a `value` carrying the new entity's `id`). Address the target with exactly one ANCHOR + id — `layer`, `asset`, `audio`, or `marker` — never a root index path: `{op:"set",path:"layers/3/..."}` is rejected with `use_id_anchor` and a corrected anchored form embedded in the message; omit the anchor only for true document-root fields like `composition/*`, `version`, or `scenes/<id>`. `path` is a slash-separated RFC-6901-style pointer relative to the anchored entity (e.g. `content/text`, `effects/0/params/amount`) — `~0`/`~1` escapes are honored, and dot-separated paths fail strict with a slash-form hint. All ops in one call are ATOMIC: they apply sequentially against a single clone and the first failing op aborts the WHOLE batch with no partial result (a typed error carrying `code` and `opIndex`); the input scene is never mutated, and later ops see earlier ops' results. Validation runs INSIDE this tool: the patched result goes through the exact picsart_media_validate_scene pipeline (JSON-Schema structural pass + semantic rules) and any severity:error fails the whole batch loudly with the diagnostics — a success has already passed that pipeline, so do NOT call picsart_media_validate_scene again right after a successful patch; only validate once you've made further hand-edits outside this tool. (Validation proves conformance to the scene contract, not that every referenced remote asset or scene_ref is fetchable at render time.) Id-less collections — track clips, `transitions`, `animations`, `keyframes`, text `content/animations` — carry no per-element id, so edit them with a whole-array `set` on the owning anchor's array path (e.g. `{op:"set",layer:"main_track",path:"content/layers",value:[...]}`) rather than addressing individual elements by index across calls.

Returns a remote media URL's metadata WITHOUT downloading the file: `kind` (image/video/audio), as-displayed `width`/`height` (EXIF orientation applied, plus the raw `orientation`), `durationSeconds` (mp4/mov/m4a), `contentType`, and total `bytes` — from at most two small ranged fetches (≤256KiB). Use this BEFORE authoring a scene to size compositions, pick `fit`, set clip windows to the real source duration, and reject wrong assets early — instead of shelling out to curl/ffprobe or guessing. Covers PNG/JPEG/GIF/WebP/HEIC/AVIF/SVG/TIFF dimensions and ISO-BMFF (mp4/mov/m4a) dimensions+duration, including moov-at-end files. Unrecognized containers still return `kind`/`contentType`/`bytes` plus a `notes[]` entry — dimensions are never invented. URLs are SSRF-guarded (public http(s) only; every redirect hop re-checked). Marked stochastic only because a URL's content can change between calls — probing an immutable asset is stable.

Resolves where every layer ACTUALLY LANDS in the root composition at a given time — without rendering pixels. Runs the engine's Scene Query System and returns each layer's final geometry in root-composition space: `box {x,y,width,height}` (top-left pixels), `center`, `rotationDeg`, paint-order `zIndex`, `visible`/`active`, an `onCanvas` coverage flag (`full`/`partial`/`off`), `timing`, and composition/parent/nesting. This is the cheap, structured answer to 'what does my composition look like, spatially?' — use it instead of (or before) mp_render_preview to verify positions, sizes, overlap, off-canvas layers, and stacking order, since reasoning over numbers beats eyeballing a PNG. Coordinates are ALWAYS top-left pixels in root space for BOTH engines — the query layer unifies Jet's pixel coords and V3's internal normalized coords, so a layer WITH RESOLVED GEOMETRY reports the same box on `jet` or `v3` (the `engine` arg only changes the translation path). Text is the exception (see limitations). Nested children (scene_ref/look comps) are returned too, namespaced (e.g. `a__bg`) with `nestingLevel` and `composition`; inactive layers at the queried time come back marked `active:false` with their box omitted. Set `verbose:true` to also get raw 4x4 transform matrices and the per-component transform chain (for transform-editing tools); omit it for layout reasoning. Determinism is deterministic — identical (scene,time,engine) returns an identical report. Limitations: (1) text layers — the query system does not resolve laid-out glyph bounds, so a text layer's POSITION/center is accurate but its box size is a placeholder (Jet 0x0, V3 ~2000x1); a `notes[]` entry flags any layer with a degenerate dimension. (2) multi-group V3 scenes may need a `sceneContext` (e.g. { canvasGroupId }); single-composition scenes do not. (3) GEOMETRY ONLY — this is NOT a render/export gate. The query is GL-free and never resolves effects, assets, codecs, or engine-specific support, so a clean layout here does NOT guarantee the scene renders or exports. A clean report carries this caveat in its `scope` field — confirm renderability with mp_render_preview / picsart_media_export.

Call FIRST when the user asks how to accomplish a media task (merge/concat videos, make a contact sheet, or export/render a scene). Returns ready-to-run mp_* tool-call sequences. Omit `recipe` for the index.

Expand every by-reference look (each layer's `looks[]` annotation) in an MP Scene into its concrete nested composition, returning a SELF-CONTAINED scene — the preset logic baked in, no look-catalog dependency at render time. The explicit, on-demand counterpart of the just-in-time resolution that picsart_media_translate_scene / mp_render_preview / picsart_media_query_layout already do internally. Use it to 'flatten' a thin look-annotated scene into a portable one (e.g. to hand off, archive, or edit the expanded layers directly). Idempotent: a scene with no `looks[]` returns unchanged. Pure: takes the full scene by value, returns a new scene.

Translate an MP Scene document into an engine's project format, WRITE it to a content-addressed file, and return `{ path, cached, summary }`. The engine project itself is NOT inlined — a large scene's project can be ~100 KB of JSON and would overflow this tool's result token cap, so it goes to disk (under MP_AI_OUTPUT_DIR/projects/<hash>.<engine>.json) and you get a path plus a compact summary. The target engine is chosen by `engine` (default `v3` → a full, openable Replay file `{ meta, context:{layers,…}, actions, settings }`; `jet` → a Jet `{ compositions, activeCompositionID, ColorSpace }` project). Read the file when you need the full project. Validate the scene first; the translator does not re-validate. Deterministic: identical (scene, engine) hash to the same path (`cached:true` on a repeat).

Validates an MP Scene document and returns a list of structured diagnostics. Use this whenever you've assembled or modified a scene, especially before rendering. Each diagnostic carries a JSON path, a stable machine-readable `code`, a human-readable `message`, and optional `hints`. A scene is considered valid when no diagnostic has severity `error`. The tool is pure: it takes the full scene in and returns diagnostics; if you keep editing, call again with the updated scene.

Generate a NEW short motion-graphics video (title cards, animated logos, ambient loops, kinetic-typography clips) from a natural-language brief, at up to 3840x2160 — use this for output above 1920x1920, since the mp_* Scene tools (picsart_media_export, picsart_media_apply_scene_template, etc.) cap at 1920x1920. NOT for template-based slideshows/decks (picsart_media_apply_scene_template + mp_present), montage/concat of existing clips (picsart_media_apply_scene_template with the montage template), contact sheets (picsart_media_contact_sheet), or captions burned over existing user media — those are all mp_* Scene tools and are cheaper and deterministic; this tool writes NEW code from a brief every time. Returns a code_url (never renders — call picsart_media_video_render next) plus a thumbnail_url; the thumbnail cannot currently be shown to you as an image (this MCP surface returns text content only), so describe the result to the user as unverified until it has actually been rendered. Costs 25 credits.

Render an picsart_media_video_create/picsart_media_video_revise code_url to a final MP4, up to 3840x2160 — use for output above 1920x1920 (the mp_* Scene tools, e.g. picsart_media_export, cap at 1920x1920). Resolutions: hd (1280x720), full_hd (1920x1080, default), ultra_hd (3840x2160, the one output size no mp_* tool can produce). Cost: 5 credits (full_hd), 10 credits (ultra_hd); hd not separately measured, expected no higher than full_hd. IMPORTANT: duration_seconds is currently capped conservatively — 15s for hd/full_hd, 10s for ultra_hd — because a 30s render measured ~32 minutes of real wall time in testing regardless of resolution; requests above the cap are refused up front rather than risking a charged, uncompleted render. If the clip will be composited into an MP Scene afterward (picsart_media_patch_scene, picsart_media_export, etc.), render at hd/full_hd — MP composition itself caps at 1920x1920, so a 4K render only matters as a final, standalone output, never as a scene input.

Edit or fix an existing picsart_media_video_create/picsart_media_video_revise output (code_url). Use for output above 1920x1920 — same routing rule as picsart_media_video_create: for template slideshows, montage/concat, contact sheets, or captions over user media, use the mp_* Scene tools instead. Pass `error` (a compilation error/stack trace) only when fixing a broken render from picsart_media_video_render; omit it for a normal content edit. Stateless — describe the FULL desired change in `instruction` each call; no conversation memory is kept between calls. Returns a new code_url (never renders — call picsart_media_video_render next). Costs 25 credits.

Returns the Picsart AI model catalog as plain data — renders NO widget or UI. Use this when YOU (the assistant) need catalog knowledge for your own reasoning: picking a model before `picsart_generate`, answering "which models support X", or comparing options — without pushing a model-picker widget into the conversation. When the user wants to SEE or browse models visually, use `picsart_list_models` instead (it renders the Picsart Studio picker). Same filters and result shape as `picsart_list_models`, but every item is rich by default: `id`, `name`, `mode`, `inputType`, `provider`, `badges`, `description`. Do NOT use it to fetch a single model's parameter schema (use `picsart_model_params`) or estimate per-call cost (use `picsart_preflight`). Inputs (all optional): `mode` (filter to image/video/audio/text — text = LLM models that return generated text), `provider` (case-insensitive substring like "flux", "kling", "google"), `acceptsImage` (true → only models that take an image input — i2i, i2v, i2t), `acceptsVideo` (true → only models that take a video input — v2v, v2a, v2t), `acceptsAudio` (true → only models that take an audio input — a2v, sts), `inputType` (exact-match escape hatch; one of t2v/i2v/v2v/a2v/t2i/i2i/t2a/v2a/tts/sts/sfx/music/t2t/i2t/v2t), `limit` (1–100, default 20), `concise` (default false; when true items carry only id/name/mode/inputType to save tokens). inputType codes — first letter is input modality, second is output: t2i (text→image), i2i (image→image), t2v (text→video), i2v (image→video), v2v (video→video), a2v (audio→video), t2a (text→audio), v2a (video→audio), tts (text-to-speech), sts (speech-to-speech), sfx (sound effects), music (music gen), t2t/i2t/v2t (LLM text output from text/image/video input). Example: `{ mode: "audio", inputType: "music" }` returns music-generation models. Returns `{ items, total, truncated }` — `truncated` is true when more matched than were returned; refine filters or raise `limit` (max 100) to see more. Read-only; spends no credits and works without authentication.

Returns the parameter schema for a specific Picsart model — a map of param name to descriptor ({ type, required, default, enum, min, max, step, label, accept }). Use this once you have a model id and need to construct the params payload for `picsart_generate` or feed `picsart_preflight` with a candidate object. Do NOT use it to discover which models exist (use `picsart_list_models`) or estimate cost (use `picsart_preflight`). Required input: `model` id. Example: `{ model: "flux-2-pro" }`. Returns `{ model, schema: { <paramName>: { type: "string"|"number"|"boolean"|"file", required?, default?, enum?, min?, max?, step?, label?, accept? } } }`. Read-only; spends no credits and works without authentication.

Opens the Picsart Music Studio: browse music/audio models, compose with a guided prompt builder, generate and play tracks, create AI album-cover art, revisit previously generated tracks, and save everything into a "Music Studio" folder in the user's Picsart Drive. Use when the user wants to MAKE music, a song, a soundtrack, a jingle, or sound effects. Covers text-to-music (MiniMax Music v2, Google Lyria 3 Pro/Clip, ElevenLabs Music v2), short audio clips (Kling T2A), and sound effects (ElevenLabs SFX). Does NOT edit existing audio (no trimming, remixing, or stem work), and is not for text-to-speech / voice cloning or image/video generation. Takes no input. Returns `{ items, total, truncated }` — the curated music catalog the widget renders. Read-only; spends no credits and works without authentication.

Free pre-flight check before `picsart_generate`: in ONE call it (1) validates a candidate params object against the model's parameter schema + inter-parameter constraints, and (2) quotes the credit cost — without running the model or charging the user. Use this after assembling params (user input, derived defaults, model swaps) and before generating, to surface bad arguments and show cost. Do NOT use it to look up which params a model accepts (use `picsart_model_params`) or to actually generate (use `picsart_generate`). Required inputs: `model` id and a `params` object (put the `prompt` inside `params`). Example: `{ model: "flux-2-pro", params: { prompt: "a cat in a hat", aspectRatio: "1:1", count: 1 } }`. Returns `{ model, valid, errors?, credits }`: `valid`/`errors` are from local validation (always present, no auth needed; `errors` only when invalid); `credits` is the dry-run cost (a number), or `null` when pricing is unavailable or the request is unauthenticated.

Removes the background from an image, returning a transparent cutout of the foreground subject. Auto-picks the newest enabled Picsart remove-bg model unless overridden via the `model` param — no need to call `picsart_list_models` first. Use this when the user asks to "remove the background", "cut out the subject", or "make the background transparent". Do NOT use this to replace the background with a new scene (use `picsart_change_bg`), upscale or sharpen the result (use `picsart_enhance`), convert raster to SVG (use `picsart_vectorize`), or generate a new image from scratch (use `picsart_generate`). Required input: `image` — a publicly-accessible URL. Local files are not supported; if you only have a local file, first make it available as a public or app-authorized URL. Optional: `model` to pin a specific remove-bg model, `outputFormat` (e.g. "png"). Example: `{ image: "https://example.com/portrait.jpg" }`. Returns `{ assets, id, model, created_at, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` plus a `resource_link` block per result URL. `id` is the SDK's generation handle; `metadata` may include model-specific tags. Spends credits. Requires Authorization: Bearer <picsart_token>.

Converts a raster image (PNG, JPG) into an SVG vector. Auto-picks the newest enabled Picsart vectorize model unless overridden via the `model` param. Use this when the user asks to "vectorize", "convert to SVG", "make this a vector", or wants a scalable version of a logo or icon. Best results on logos, icons, and simple graphics — photographic images vectorize poorly and the user should be warned. Do NOT use this to remove the background (use `picsart_remove_bg`), replace the background (use `picsart_change_bg`), upscale a raster image (use `picsart_enhance`), or generate a new image (use `picsart_generate`). Required input: `image` — a publicly-accessible URL to a PNG or JPG (not a local file path). Optional: `model` to pin a specific vectorize model. Example: `{ image: "https://example.com/logo.png" }`. Returns `{ assets, id, model, created_at, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` plus a `resource_link` block for the SVG URL (mime `image/svg+xml`). `id` is the SDK's generation handle. Clients fetch the SVG from that URL. Spends credits. Requires Authorization: Bearer <picsart_token>.