Picsart

Builds a film generation prompt — a video run, a scene picture/still, a room map, or an edit — from your structured picks plus your own writing, and returns the finished string to send to picsart_generate, with a `promptToken` — the compiler's receipt for this exact text. Send the prompt verbatim, and pass the token to picsart_prompt_verify beside it so the check can tell a compiled prompt from a retyped one. Character portraits, profiles and sheets are built by picsart_film_compile_asset_prompt instead: a neutral reference carries the film's asset prefix, and pasting this scenic one onto it bakes a location into every shot that reference touches. Give `look` (genre/tone/palette/rig ids) and it assembles the STYLE line too — a tone is an era recipe that fills the rig on its own. USE THIS INSTEAD OF WRITING A FILM PROMPT BY HAND. It pastes the house lines and the camera/lighting/acting preset text that were tuned against real renders; written from memory those come out paraphrased, and a paraphrase renders worse. You supply everything only you can write: the scene, the geography, each shot's framing, action, lines and delivery. YOU MAY ADD ANYTHING, ANYWHERE — per-shot `extra`, whole `filmConstraints` lines, a `note` on any performance — and you may edit the returned prompt freely. What you should not do is retype a preset or a house line in your own words. It also derives the cut list and total length from each shot's `sec`, decides whether the global camera line is dropped (it is, when every shot has its own `move`), and returns `notes` for things it will not silently repair — a spoken line too long for its shot is reported, because `sec` belongs to the user. For a still it also returns the `negativePrompt` to pass alongside the prompt: the medium ban always, plus the lettering ban on everything EXCEPT a room map — a map's own prompt asks for a label on each side, and banning lettering there destroys it. A video kind returns none; that field is image-model-only and never goes in prose. Every result carries `stylePrefix` — the STYLE line exactly as it went into the prompt. Store THAT verbatim rather than rebuilding it later; a rebuilt line drifts. An unknown preset id or an unfilled placeholder is refused with a message naming it. Read-only; spends no credits.

picsart_film_compile_prompt

Auth is handled by the platform automatically — no token setup needed on your end. Renders a cheap multi-frame OVERVIEW of a scene as low-res jpeg thumbnails YOU CAN ACTUALLY SEE: each sampled frame comes back as an inline image content block (labeled with its scene time), alongside the machine-readable `{ frames: [{time, url, inline}] }`. Two modes: pass `times` (PREFERRED — you usually know the interesting moments: clip seams, animation midpoints, entrance ends) to get one thumbnail per requested time, rendered concurrently — at most 8 per call (pass more and 8 of them are picked evenly; the rest are not rendered); or pass `frames` (default 8) for evenly-spaced sampling across the whole timeline. Those frames fall on whole seconds, so a scene shorter than `frames` seconds returns one frame per second. At most 8 come back as images; a larger `frames` (up to 24) lists the rest as urls only. Use it to eyeball pacing, seams, and content presence across the WHOLE timeline before exporting, in one call. Validate the scene first. Inline images are best-effort under a total size/count budget: a frame that fails to download, is oversized, or falls outside the budget still comes back with its `url` and `inline: false` in the JSON — a partially-inlined sheet is a SUCCESS, not an error, because the render has already happened. Do not retry this call just to get the missing pictures (that re-renders them for no benefit) — open those urls instead. Scope: this samples a scene you have already authored, to look at it. It is NOT a metadata probe — use picsart_media_probe_media first for a source clip's duration/dimensions/frame rate. Sparse-sampling frames here to discover duration is only the fallback when picsart_media_probe_media genuinely cannot determine it (every frame is a real GPU render). Use picsart_media_query_layout to check layer geometry, overlap and stacking order without rendering.

picsart_media_contact_sheet

Creates folders in the authenticated user's Picsart Drive. Requires `name` OR `path`; `folderUid` = parent (omit for root). Optional `description`. `name` alone always creates. `path` ("Picsart Films/my-film") ensures a whole chain — missing segments created, existing ones reused — and `children` ensures named folders inside the leaf, their uids returned as `result.createdUids`. Use path+children to provision a project tree in one call. Returns the listing of the folder just created — never its parent — plus `result.createdUid`. If the re-list itself fails, the listing is empty and `result.staleListing` is true -- that does not mean the change failed. Requires an authenticated Picsart session (per-user Drive content).

picsart_drive_create_folder

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 a signed-in Picsart account (per-user account data).

picsart_credits

Deletes one saved film asset. Call it only when the user explicitly asks to delete that asset, and pass the `assetId` exactly as `picsart_list_assets` or `picsart_save_asset` returned it — never a guessed or constructed uid; a folder that is not a film asset folder is refused by a scope check. It permanently removes the asset's subfolder (and the portrait, turnaround, and voice sample inside it) from Picsart Drive after verifying the target really is a film asset folder (a child of a project Library/Assets, or of the global "Film Assets" folder). Returns `{ deleted, assetId, message }`. Writes to Picsart Drive; requires a signed-in Picsart account.

picsart_delete_asset

Deletes files or folders from the authenticated user's Picsart Drive. Requires `itemUids`. Soft-deletes to the trash (recoverable) unless `permanent` is true, which purges them for good. `result.deleted` lists the removed uids. Returns the listing of `folderUid` (omit = root) plus `result`. If the re-list itself fails, the listing is empty and `result.staleListing` is true -- that does not mean the change failed. Requires an authenticated Picsart session (per-user Drive content).

picsart_drive_delete

Describe a single 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.

picsart_media_describe_scene_template

Replies with a media job receipt by default, not the description: pass the receipt's `job` object verbatim to the status tool named in its `tools.jobStatus`, which reports progress and, once the job finishes, the same description this tool returns with async:false. Set async:false to wait for the description in this call instead. Describe what is happening in a video: subjects, setting, actions, on-screen text, mood, pacing, and dominant colors. The content-understanding counterpart to `picsart_media_probe_media` (which reports container facts only — dimensions, codec, duration — never what is actually shown). Also returns a `suggestedAspect` you can feed straight into `picsart_media_reframe_video`, and, when `question` is given, an `answer` field addressing it specifically. Not a transcription tool: it describes visual content and never transcribes speech — for that, use `picsart_media_transcribe`. Charges credits on every call.

picsart_media_describe_video

CAN BE UNAVAILABLE: it resolves through picsart_media_query_layout, so it fails whenever that tool is unavailable (that tool says what to do instead). Diffs the resolved LAYOUT of two scenes (two storyboard boards) and reports, per layer, WHAT CHANGED — the geometry a motion author needs instead of hand-diffing coordinates. Resolves BOTH exactly as picsart_media_query_layout does (root-space, top-left-pixel boxes and centres, any engine), matches each layer of A to one in B, and classifies it `moved` / `resized` / `restyled` / `content-changed` / `unchanged`, or `entered` (B only) / `exited` (A only). Matching order: explicit `matchHints`, then same content id + kind (same asset/text), then geometry (best IoU / nearest centre) — NEVER layer id, since ids differ across independently-authored boards. A matched layer carries `delta` { dPos:[dx,dy], travelPx, dScale, dScaleXY, dRotation, dZ, visibilityChanged, contentChanged }, in root-space top-left pixels with centre-based positions. A whole-pair `relationship` (`shared-layers` / `zoom-detail` (B ≈ a uniform re-scale of A) / `in-place-emphasis` / `unrelated` / `indeterminate`) routes smart-animate vs camera vs cut. `indeterminate` means no comparison was possible (a board offered no layer with geometry; see `notes`), NOT that the boards differ — two identical text-only boards reach it on `jet`; boards whose comparable layers do not pair report `unrelated`. Geometry only: it recommends and applies nothing — turn deltas into motion with picsart_media_patch_scene / picsart_media_apply_motion_preset / picsart_media_apply_text_animation. Inherited from picsart_media_query_layout: no numeric opacity (restyle is detected via visibility + rotation), and text boxes are unmeasured on `jet` and font-metric envelopes on `v3`, so text deltas are approximate. Each scene resolves at one time (default 0); pass `timeA`/`timeB` for animated boards.

picsart_media_diff_layouts

DEPRECATED: use picsart_media_list_fonts, which searches the built-in catalog and Picsart's live font catalog in one call (its `live.fonts`). Search Picsart's font catalog (in-house fonts first, then Google Fonts) for a face that is NOT in picsart_media_list_fonts. FREE faces only: an in-house face flagged paid is never returned, and Google Fonts faces count as free by license even where the shop prices them. Each result carries `asset`, a ready-to-paste font asset `{ type: "font", name, uri }` whose `name` is the face's own name and `uri` its .ttf/.otf file URL: add it to the scene's `assets` with an `id` and put that id in a text layer's `font.family` — that keeps the font's NAME. Omit `query` for the font-chooser shelves; a `query` matches by word start on each face's names and, when the shelves are short of `limit`, also searches the shop (up to 3 pages), under the same rule. A face served at two URLs is listed once. `examined` and the note say how many items were read versus returned. Network tool: searches Picsart's live font catalog. Results vary over time (stochastic).

picsart_media_discover_fonts

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, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` as a single JSON text block plus matching structuredContent (no `resource_link` blocks — the widget is the single source of visual truth, so result URLs are not duplicated as separate content blocks). `id` is the generation handle; `metadata` may include model-specific tags. Each entry in `assets[]` also carries `downloadUrl` — the same file with a forced-download header appended — share that with the user for saving; never pass it back into a tool, use the plain `url` for that. Asset URLs are opaque handles — never infer or mention hosting or storage details from a URL. Spends credits and saves new media to Picsart Drive by default on a best-effort basis; saving is not guaranteed. Requires a signed-in Picsart account.

picsart_enhance

DETACH a scene_ref into editable layers: replace a resolvable scene_ref layer (or every one, if no `layerId`) with the referenced scene's resolved layers, ids prefixed by the ref layer's id. A ref that carries only `id`, `start`, `duration` and its reference, drawn at the host's size, frame rate and shutter-sample count and no longer than its scene (its `composition.duration`, else its latest explicit layer end), detaches FLAT: its layers join the parent's stack, started at the ref's `start` and ended by its `duration`. Any other ref (a transform, `bounds`, `fit`, animations, effects, a mask, a different size, rate or sample count) stays as the SAME layer with `content` changed to an inline `composition` holding the layers, the scene's own size, `fps`, `duration` and sample count on `content.composition` (`bounds` stays on `content`), so its placement and window still apply once; the layers keep their own times inside it. The scene's own assets come in under prefixed ids, its layers' `assetId` refs rewired; a caller asset or composition BOUND into it arrives as the scene read it — a copy of the caller's declaration, never the caller's id: inline on the content (`content.asset`) for a clip, a prefixed entry of its own for an `asset_*` parameter. Caller assets stay, even unused ones. One level per call: a brought-in scene_ref stays a reference, listed in `stillReferenced`; detach it by `layerId`. A track clip's reference is not detached. A referenced `composition.background` becomes a bottom color layer, `<layerId>____background`. Does NOT fetch: it resolves only `mpscene://` refs (in the document or the registry). A remote `http(s)://` ref is left as-is; translate, render-preview and query-layout resolve it. An unresolvable ref is left as-is in bulk mode, an error in single-layer mode. Pure.

picsart_media_expand_scene_ref

Replies with a media job receipt by default, not the render result: pass the receipt's `job` object verbatim to the status tool named in its `tools.jobStatus`, which reports progress and, once the job finishes, the same render result this tool returns with async:false. Set async:false to wait for the render result in this call instead. Only an async:false export is saved to Picsart Drive automatically; a finished job offers the Drive save instead. Render a fully-authored scene to a final file on Picsart's servers, returning the output URL(s). The output container is chosen with `mediaType`: omit it (default) to render an MP4, or pass `mediaType:"png"` for a single still (`mov`/`webm`/`jpeg`/`webp`/`heif`/`gif`/`image-sequence` are also accepted). This performs the ACTUAL render: the scene is dispatched to the export service over an authenticated HTTP call — no local renderer. Auth is handled by the platform automatically — no token setup needed on your end. Validate the scene (`picsart_media_validate_scene`) and check a frame (`picsart_media_contact_sheet` with `times:[t]` — sample one frame near the point you want to verify; it returns that frame as an inline image you can look at) BEFORE exporting. For a signed-in caller, an eligible single output is also saved to Picsart Drive on a best-effort basis. A failed or skipped save does not fail the render; only report a successful save when driveUid is returned. If you do not yet have a scene, get the whole sequence from picsart_media_quickstart rather than reverse-engineering the document shape from picsart_media_get_scene_schema. Every url in `urls` may also appear at the same index in `downloadUrls` — the same file with a forced-download header appended. Hand a `downloadUrls` entry to the user for saving (e.g. in a host that just renders links); never pass it back into another tool call, use the matching `urls` entry for that. `downloadUrls` is present only when the render landed on a Picsart-hosted url. Asset URLs are opaque handles — never infer or mention hosting, CDN or storage details from a URL.

picsart_media_export

Lists the user's saved Picsart film assets — pairs each portrait file with its sibling turnaround file (when present) and parses each portrait's asset manifest. Pass `projectFolderUid` (the film's Drive project folder) to read ONE film: `scope` then picks "library" (locked passports — the default, and what the film is built from), "assets" (the working record, every version) or "all". Omit it to read the flat global "Film Assets" folder, which holds assets saved without a project. Use when the user wants to see the assets they built earlier ("show my film assets", "open the asset library"), pick one to reuse, or manage them. Do NOT use it to create or edit an asset (an asset is saved with `picsart_save_asset` once approved on `picsart_asset_review`). Returns the asset configuration (`models`, `voicePresets`) alongside `{ items, total, byStatus }`, so no second round trip is needed. Newest first. `byStatus` counts the rows by status (draft / review / locked / unknown) — it is the answer to "is this block ready to generate?", and a non-zero draft or review count against zero locked is a hole in the scene×assets matrix, not a detail. Read-only; spends no credits. Requires a signed-in Picsart account.

picsart_list_assets

Opens the Picsart Film Setup console: three look sections browsed as artwork (genre; tone — an era recipe that sets the RIG to a named period of cinema and adds one clause of its own, Auto by default; colour as a scheme and a hue wheel — monochromatic, analogous, complementary or triadic, built around a named hue. The colour is ALWAYS the user's: a tone brings the rig and nothing else, so picking an era never rewrites a colour already chosen, and the wheel is live whenever a scheme is. There are no palette presets on the console; the palette is `auto` unless a shot picks its own on the shot list), the delivery bounds every generation inherits (frame aspect ratio, total film duration, handles), a two-part camera rig (camera, lens family). The widget compiles the picks client-side into the film's style prefix — the exact text pasted word for word into every prompt of that world — and the user's decision arrives as widget context when they press Lock (film_setup_feedback: selections, stylePrefix, summary, verdict "locked"; selections.scheme and selections.hue arrive when the user chose a scheme — pass them as look.scheme / look.hue to picsart_film_compile_prompt). THIS IS THE FIRST CONSOLE THE USER SEES. It opens at the start of the film, BEFORE `picsart_shotlist_board` — the shot cards inherit its presets, so a shot list opened first asks for framing and colour from a vocabulary the film has not adopted yet. It needs only the script and the logline, which the film has from the start. When the film's look is locked later, that lock keeps what was set here rather than choosing it late; reopen the console with `current` only when the reference images genuinely argue for a different direction, or whenever the user wants to revise a look. One call per visual world. Every control opens on a defensible default, so the console is never blocked waiting for input; use `suggested` to replace those defaults with what the script, logline, or moodboard actually decides, one line of `why` each — and pass `ratio` whenever the user has named a format at all, since the frame is the one default that is visibly wrong when the user already said "vertical". Store the returned stylePrefix verbatim; never reword it. Returns the normalised console payload the widget renders. Read-only; spends no credits and works without authentication. HOW THE DECISION ARRIVES: when the user presses the board's button, their decision is delivered as WIDGET CONTEXT, not inside their chat message — the chat shows only a one-line user sentence announcing it. On that turn, BEFORE replying, read the widget context: call the host's widget-context tool, if it has one, and act on its result; where a host attaches the context to the turn instead, read that. Only when both are empty may you say the payload is missing. Never ask the user to repeat, describe, press again or paste it.

picsart_film_setup

Creates new media from a prompt: one call is one run of the Picsart model named in `model`, and it returns that run's image, video, audio, or text result. Spends credits. Every call is this same operation — a prompt and any input media in, a new result out — and `model` only selects which engine renders it, as `model` does on `picsart_enhance`. All inputs are declared below; a value the selected model does not support is rejected before anything is charged. Choose `model` from the Picsart catalog (`picsart_model_catalog`). Background removal (`picsart_remove_bg`), background replacement (`picsart_change_bg`), upscale / enhancement (`picsart_enhance`) and raster-to-SVG conversion (`picsart_vectorize`) have their own tools. 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 — when the model has no native count, ONE call fans out N jobs server-side, so never loop `picsart_generate` to get N candidates; async fan-out returns `jobs: [...]` — put them all on picsart_render_monitor), `quality`, `style`, `negativePrompt`, `imageUrls` (input pictures — probed before dispatch: a picture with any side under 300 px, a contact-sheet thumbnail or a too-narrow crop off a character sheet, is refused with the fix and nothing is charged; on a video model that also takes a `startFrame`/`endFrame`, a frame mixed with reference media is refused before dispatch on Seedance — the provider rejects the mix after the wait — and a frame sent alone returns a `warnings[]` entry: only the people visible in that frame have a picture, so put the frame first in `imageUrls`, say "IMAGE 1 — START FRAME" in the prompt, and keep the face and outfit pictures beside it), `videoUrl` (an input video), `enhancePrompt`, `generateAudio`, and `extra` — the selected model's further named settings, such as `startFrame`, `endFrame` or `voiceId`, as `picsart_model_params` lists them for that model. 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, prompt, summary, why_relevant, url, results: [{ url, metadata? }], drive? }` as a single JSON text block plus matching structuredContent; the media gallery displays the results without separate `resource_link` blocks. `id` is the generation handle; `metadata` may include extra tags about the result. Each entry in `assets[]` also carries `downloadUrl` — the same file with a forced-download header appended — share that with the user for saving (e.g. in a host that renders links only); never pass it back into a tool, use the plain `url` for that. Preserve asset URLs verbatim when passing them into tools; URL structure does not establish durability. A text result (a model whose mode is "text") is produced synchronously (`async` is ignored) and returned as the text content block plus `text` in structured content. Every image, video or audio result defaults to async: the call returns `{ job, status: "ACCEPTED" }` immediately, and you poll `picsart_job_status` with the job handle until it completes (it then returns this same media payload). `picsart_render_monitor` displays job progress in a widget for image, video and audio jobs. Never re-submit ANY generation because a call seemed to hang or the host reported a timeout: the render usually completed and already charged — poll the handle; for a call you made with `async: false`, check Drive for the new file before any retry (a dropped response is not a failed render). Pass `async: false` only for a call you know finishes inside the host's window. Hosts that support widgets render images and videos in the Picsart media gallery; clients fetch the assets from URLs, never base64. Spends credits; media results are saved to the user's Picsart Drive by default on a best-effort basis unless `saveToDrive: false`, except an async job given a `folderUid`, whose result you save into that folder once it completes (see `folderUid`). Requires a signed-in Picsart account.

picsart_generate

Fetch one recipe by name -- its full markdown body (the authoring instructions) plus the list of any companion reference files it links to (e.g. `references/motion-rules.md`). Call this after `picsart_media_list_recipes` has identified a relevant recipe from its metadata. Pass the optional `reference` argument (one of the returned `referenceFiles` paths) to fetch that companion file's raw content INSTEAD of the body -- this lets an agent pull extra detail on demand rather than loading everything a recipe carries up front. Returns `{ name, description, metadata?, body, referenceFiles }`, or `{ name, reference, content }` when `reference` is given.

picsart_media_get_recipe

Returns this tool layer's capabilities: layer content kinds, animatable properties, the effect/transition/look catalogs with their params, per-feature format notes, and `limits` — the sizes the pipeline is exercised at, none of them enforced (see its `enforced` note). Call it when planning a composition. Omitting `sections` returns the section INDEX — every section name, top-level and `supports` sub-keys alike — plus a `hint` with the full document's current size and of every section too large for one answer. The document is large: pass `sections` for the slices you need, preferring granular `supports` sub-keys over the whole `supports` block (e.g. ["effects","limits"], ["textAnimations"], or ["generativeTemplates","limits"] for a montage plan — `generativeTemplates` holds parametric layout templates such as montage and collage, with no AI generation), or ["all"] for everything. `looks` alone (full prose + param schemas for every look) can overflow a result cap even as the one section requested — ask `looksCompact` first (id/summary/appliesTo/fade plus each param's name, type (with `animatable`), min/max and default); only a param declared `animatable: true` takes keyframes/an expression, every other is static-only. For one look's full entry use a `look:<id>` token in `sections` (see that param). Every answer carries `build`, the package version that produced it, so two answers to this call that differ can be told apart by their `build`. Idempotent and dependency-free; safe to cache.

picsart_media_get_capabilities

Returns the JSON Schema for a scene. Use it to build a scene or to check the shape of layers, animations, effects and transitions. The schema is authoritative for STRUCTURE only. Passing it does not mean a document renders, and schema validity does not guarantee successful rendering: semantic rules live in picsart_media_validate_scene, and some of the schema's own field descriptions name values it structurally admits and the validator then rejects (`font.family` is a bare string in the schema, but a CSS-style name like 'Arial' is an `unknown_font_family` error). Always run picsart_media_validate_scene before rendering. The whole document carries every definition and is large, so prefer one of the narrower views: `name` returns that definition plus every definition it references, self-contained and validator-ready, while that stays under 60,000 characters; past that (MpScene, MpVisualLayer, MpAsset, a track or scene_ref content, which reach most of the schema) it returns the definition and its DIRECT references only, with `partial` saying so and `notIncluded` naming the rest to fetch by name. `summary: true` returns field names and types with no prose, plus `rules` (a field's one-line rule its type cannot show, e.g. when a clip's omitted `duration` is legal) and `typeArguments` (what a `Name<Arg>` argument means). Read `summary` first to find the definition you want, then fetch that one by `name`. A `Name<Arg>` is one definition, fetched by that full spelling; asking for a bare type argument such as `MpDefinitionValues` answers what it means and which definitions carry it. A `Type.field` pointer such as `MpClip.cameraExempt` (the form descriptions use) answers that one property: its schema and description, whether it is required, and the type that declares it. A type built on another states the relation rather than repeating it: `allOf` over the base's `<Base>Fields` list plus its own fields (`false` marks a base field it drops), or, for a type that re-types base fields, a `$ref` from each field it takes over unchanged to the base's.

picsart_media_get_scene_schema

Convert a Figma element's CSS paint (a panel's CSS paint from the design file the user shared) into scene items on a layer, instead of baking the element to an opaque SVG that cannot animate, scale or recolor. Three paints map cleanly and are applied; a fourth has no scene primitive yet and is reported, not dropped: `fill` (a CSS color, e.g. 'rgba(0,0,0,0.5)' or '#ff47ff') becomes a shape fill (a shape paint's color is RGB-only, so any alpha is stored in the fill item's `opacity`); `boxShadow` (a CSS box-shadow, one layer or a comma-joined list) becomes a drop_shadow effect for OUTER shadows, while an INSET shadow is returned in `skipped` because there is no inner-shadow primitive yet (keep the SVG for that one glow); `gradient` (a CSS 'linear-gradient(...)' or 'radial-gradient(...)') becomes a gradientFill (or gradientStroke). `fill` and `gradient` need a shape layer since they are shape items; a gradient also needs the element `size` [w,h] because CSS carries only an angle, not box-local endpoints. Returns the updated scene, `applied` (the item/effect types created), and `skipped` ({what, reason}) so you know exactly which treatments still need a bake. Pure: takes the full scene by value, returns a new scene; no server-side state.

picsart_media_import_figma_paint

Convert an SVG path-data string (the `d` attribute) into scene `path` shape item(s) on a shape layer, instead of baking the outline to an opaque SVG asset that cannot animate, scale or recolor. Parses the FULL SVG path grammar, absolute AND relative -- M m L l H h V v C c S s Q q T t A a Z z, with repeated coordinate sets after one command letter: quadratic curves (Q/q/T/t) are elevated to cubics, elliptical arcs (A/a) are decomposed to cubic beziers, and the smooth shorthands (S/s, T/t) reflect the previous control point. Each SUBPATH (every new moveto) becomes one `path` item -- the model spells a bezier outline the Lottie/AE way ({ closed, vertices: [{ point, inTangent, outTangent }] }, tangents RELATIVE to their point, content-local px) -- and a closed subpath folds its closing tangent onto the start vertex. A `path` is geometry only; pass `color` for a solid `#rrggbb` fill (with `fillRule` 'evenodd' when the source SVG sets fill-rule="evenodd") and/or `stroke` + `width` for an outline. With either paint, the paths and their paint are appended together as ONE `group` item, so the paint reaches only the imported outline and never repaints the layer's existing shapes; with neither, the bare paths are appended for you to paint. For a GRADIENT outline, import geometry-only (no `color`/`stroke`) onto a dedicated shape layer, then call picsart_media_apply_gradient on it: a gradient is a top-level paint and cannot reach paths nested inside the paint group (and a top-level paint also covers any other top-level geometry on that layer). Transparency goes in `fillOpacity` / `strokeOpacity` (SVG fill-opacity / stroke-opacity), since a paint color carries no alpha byte. Genuinely unparseable input fails LOUD (invalid_path_data) rather than emitting wrong geometry. Returns the updated scene, `applied` (the item types created, e.g. ['path','fill','group']), and `skipped` ({what, reason}) for any subpath that had no drawable outline. Pure: takes the full scene by value, returns a new scene; no server-side state.

picsart_media_import_svg_path

Checks a job: a generation started by `picsart_generate`, which returns asynchronously by default for every media model — image and audio as well as video — or a media job whose receipt named this tool in `tools.jobStatus`. Assistants and widgets poll this every few seconds with the returned job handle, passed back verbatim. A generation handle also needs the model it was submitted with; a media handle (`kind: "media"`) needs nothing else. Polling only reads job results and existing Drive metadata; it never saves files, creates folders, or starts a job. While running it returns `{ status: "ACCEPTED"|"IN_PROGRESS", progress?: { percent, estimatedSecondsLeft } }`. A finished generation returns the same media payload `picsart_generate` would have returned (`{ status: "COMPLETED", assets, results, url, ... }`), or an error for FAILED/CANCELED jobs. A finished media job returns `status: "COMPLETED"` with `result` exactly as that tool returns with async:false, or `status: "FAILED"` with a user-facing `error`. Only the job's owner can read it. Preserve asset URLs verbatim when passing them into tools; URL structure does not establish durability. Requires a signed-in Picsart account.

picsart_job_status

CAN BE UNAVAILABLE: it samples picsart_media_query_layout, so it fails whenever that tool is unavailable (that tool says what to do instead). Detects UNINTENDED layer overlaps over TIME and CLASSIFIES every overlapping pair rather than suppressing any. Samples picsart_media_query_layout over a window (default the whole composition, step 0.25 s) and, per sample, considers visible+active+on-canvas layers. Pairs are compared only within the same `composition` scope (picsart_media_query_layout's field): a nested scene_ref/look's inner layers against each other, never against the caller's, while the nested reference's own box IS compared with its top-level siblings. Each pair is classified over its overlap lifetime as exactly one of: `containment` (one box holds ≥90% of the other for ≥80% of their shared visible time — a chip in a bar, a badge on a card) or `backdrop` (the paint-order-lower layer covers ≥85% of the canvas — a full-bleed plate), both intentional and not flagged; `transient` (under 0.4 s, e.g. a handoff crossing), reported as `info`; `collision` (a sustained ≥0.4 s overlap between peers with IoU ≥ `iou`), FLAGGED under `findings`. `allow: ['idA:idB', …]` suppresses a specific pair (order-insensitive); it still appears under `allowed` with its real classification. A LINT, not a gate: found overlaps never fail the call; it fails loud only for an unreadable scene, a non-positive duration, an empty sampling window, or an engine/query error. Before trusting a clean report: on `jet` TEXT layers are not measured and are excluded from every comparison (noted); on `v3` text boxes are font-METRIC envelopes, not glyph bounds, so a text overlap can be conservative; rotated layers compare by their axis-aligned envelope. Each sample is a full query, so narrow `t0`/`t1` to the suspect region on long timelines.

picsart_media_layout_lint

Enumerate the curated recipe registry -- reusable authoring know-how guides (Agent Skills-format markdown, e.g. how to turn a Figma storyboard into an animated scene) written for this toolset's own commands. Each entry is the METADATA TIER ONLY: name, description, and any category/version declared in the recipe's frontmatter `metadata` map -- no body text, so the whole catalog stays small enough to read in full before deciding which recipe is relevant. Call `picsart_media_get_recipe` with a chosen name to fetch its full instructions. Pure: no inputs, no state.

picsart_media_list_recipes

Lists one folder of the authenticated user's Picsart Drive and shows it in the Drive browser. Read-only. `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). Each file's `url` is its Picsart-hosted URL, ready to pass to `picsart_generate` reference params like `imageUrls`; its `downloadUrl` is the same file with a forced-download header appended — hand that to the user for saving, never pass it back into a tool. Preserve asset URLs verbatim when passing them into tools; URL structure does not establish durability. Requires an authenticated Picsart session (per-user Drive content).

picsart_drive_list

Finds fonts for text layers: the built-in catalog, plus (on page 1) a live search of Picsart's font catalog, in-house faces and Google Fonts. Use this before authoring any text layer so `font.family` resolves to a real font. 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. `fonts` is the built-in catalog, paged: at most `pageSize` entries (default 50, max 200) plus `total`, `page`, `pageSize` and `hasNext` -- pass `page` to read on. Each has a stable `key`, passable directly as a text layer's `font.family`, and a resolved `.otf`/`.ttf` URL. `live.fonts` holds the faces the live search found that the catalog does not already list: each carries a ready-made `asset` -- add it to the scene's `assets[]` with an `id` and put that id in `font.family` (an entry that also has a `key` can use the key instead). `live.status` is `unavailable` when the search failed; the catalog page still stands. No face is listed twice, within or across the two lists. Every entry has a `source` (`catalog`, `picsart` or `google`) and may carry a `licenseType` (`commercial` or `personal`) for usage-rights filtering. Live entries also carry `paid` (a Picsart subscription face); those are listed only to a signed-in caller -- for an anonymous one they are left out of `live.fonts`, and `live.paidHidden` is `true` when any were. Built-in catalog entries carry no `paid` flag and are listed to every caller: their `licenseType` is the usage-rights signal. Agents may also pass a direct font URL matching `accepted_url_pattern`. Narrow with `query` (substring of key or display name), `family` (e.g. "Roboto" for all its variants) and `licenseType` instead of paging through the whole catalog.

picsart_media_list_fonts

Shows the Picsart model catalog, across ALL modes (image / video / audio / text), in the Picsart Studio model-picker widget so the USER can browse, compare, and pick the `model` for `picsart_generate`. Each item carries `id`, `name`, `mode`, `inputType`, `purpose`, `supportedAspectRatios`/`supportedResolutions` (when the model declares an enum for that param) (and `provider`, `badges`, `description` when `verbose` is true). Every item carries `purpose`: `generate` (makes a new asset from a prompt), `edit` (changes an existing asset of the same medium) or `utility` (a fixed transform of an input asset). Filter on `purpose: "generate"` whenever the user wants something made; results are sorted with `generate` models first. Supports user-requested catalog browsing, cross-mode searches, and inspecting model forms. `picsart_model_catalog` returns catalog data without a widget; `picsart_model_choice` presents a shortlist of candidates for the user to choose from. Pass `mode` (image/video/audio/text) to show one output medium. Ratio/resolution constraints ride along in `supportedAspectRatios`/`supportedResolutions`, so you rarely need `picsart_model_params` just to check whether a model supports a given aspect ratio or resolution. Inputs (all optional): `mode` (filter to image/video/audio/text — text = LLM models that return generated text), `purpose` (generate/edit/utility — see below; PASS `generate` for any "make me a…" ask), `provider` (case-insensitive substring like "flux", "kling", "google"), `acceptsImage` (true → only models that take an image input), `acceptsVideo` (true → only models that take a video input), `acceptsAudio` (true → only models that take an audio input), `inputType` (exact match on a model's input→output media code), `limit` (1–100, default 20), `verbose` (default false; when true each item adds provider/badges/description). 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.

picsart_list_models

Enumerate the curated 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.

picsart_media_list_scene_templates

Returns the Picsart model catalog as plain data — renders NO widget or UI. Use it to choose the `model` for `picsart_generate`, answer catalog questions, and compare Picsart model capabilities. `picsart_list_models` shows the same catalog in the Studio widget. Same filters and result shape as `picsart_list_models`, but every item is rich by default: `id`, `name`, `mode`, `inputType`, `purpose`, `provider`, `badges`, `description`, plus `supportedAspectRatios`/`supportedResolutions` when the model declares an enum for that param — enough to answer "which models support 16:9" without `picsart_model_params`. Every item carries `purpose`: `generate` (makes a new asset from a prompt), `edit` (changes an existing asset of the same medium) or `utility` (a fixed transform of an input asset). Filter on `purpose: "generate"` whenever the user wants something made; results are sorted with `generate` models first. Inputs (all optional): `mode` (filter to image/video/audio/text — text = LLM models that return generated text), `purpose` (generate/edit/utility — see below; PASS `generate` for any "make me a…" ask), `provider` (case-insensitive substring like "flux", "kling", "google"), `acceptsImage` (true → only models that take an image input), `acceptsVideo` (true → only models that take a video input), `acceptsAudio` (true → only models that take an audio input), `inputType` (exact match on a model's input→output media code), `limit` (1–100, default 20), `concise` (default false; when true items carry only id/name/mode/inputType/purpose plus the ratio/resolution fields, to save tokens). 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.

picsart_model_catalog

Shows the user a Model Choice board for picking the `model` a later `picsart_generate` call uses: a short list of candidate models as cards, each with what it is best for and its key limits (max clip length, resolutions, aspect ratios, audio, cost note). The user taps one and their pick arrives as widget context; the board itself runs no model. Use it to present a project-specific shortlist when the user wants to choose among models with different duration, resolution, audio, or cost trade-offs. Candidate details can come from picsart_model_catalog. Pass 2 or 3 candidates (up to 4), describe each candidate's fit for the project in bestFor, and mark exactly one as recommended. The board returns the selected model id. Returns the normalised board payload the widget renders. Read-only; spends no credits and works without authentication. HOW THE DECISION ARRIVES: when the user presses the board's button, their decision is delivered as WIDGET CONTEXT, not inside their chat message — the chat shows only a one-line user sentence announcing it. On that turn, BEFORE replying, read the widget context: call the host's widget-context tool, if it has one, and act on its result; where a host attaches the context to the turn instead, read that. Only when both are empty may you say the payload is missing. Never ask the user to repeat, describe, press again or paste it.

picsart_model_choice

Lists the settings one Picsart model supports in `picsart_generate` — a map of setting name to descriptor ({ type, required, default, enum, min, max, step, label, accept }) — so a `picsart_generate` call (its declared fields plus `extra`) uses only values that model accepts. 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.

picsart_model_params

Opens the Picsart Motion Setup console for a motion-design video built from a storyboard of design frames (e.g. a Figma flow): output ratio (one of the five supported ratios — 9:16, 16:9, 1:1, 4:3, 3:4), fps (24/30/60), motion energy (calm/standard/energetic), the default seam and hold, and whether total length is DERIVED from the motion (the default) or targets a soft budget. The widget compiles the picks client-side and the user's decision comes back as a JSON message in the conversation (motion_setup_feedback: selections, summary, verdict locked). Call it once at the start of a motion-design project, prefilled: infer the ratio from the frames' aspect and the energy from the design and pass them in `suggested` so the console opens pre-selected for confirmation. Do NOT ask the running order (take the design's own) and do NOT ask a total duration (it derives from the motion). Store the returned selections as the project's output target (ratio -> width/height, fps) and as the seam/hold defaults; quote `summary` verbatim. Frame URLs must be Picsart-hosted: save frames from anywhere else with `picsart_drive_upload` first. Returns the normalised console payload the widget renders. Read-only; spends no credits and works without authentication.

picsart_motion_setup

Moves files or folders within the authenticated user's Picsart Drive. Requires `itemUids`; `targetFolderUid` = destination (omit = root). `result.moved` reports each item and whether its move failed. Returns the destination folder's listing plus `result`. If the re-list itself fails, the listing is empty and `result.staleListing` is true -- that does not mean the change failed. Requires an authenticated Picsart session (per-user Drive content).

picsart_drive_move

Edit a scene with a batch of ID-anchored ops and get the patched scene back inline as `scene`. Atomic, validated inside. Verbs: `set` (create-or-replace, last-write-wins, idempotent; `replace` is an alias); `remove` (a field or array element, or the whole anchored entity when no `path` is given); `add`, either ANCHORLESS (a whole new entity: `kind` plus a `value` carrying its `id`) or ANCHORED (ONE element into an array inside an entity: anchor + `path` to the array, no `kind`) — `{op:"add",layer:"reel",path:"content/clips",value:{…},after:"clip_a"}` adds one clip without re-sending the rest. Address the target with exactly one anchor + id, `layer` or `asset` (a sound is a layer, `content.kind:"audio"`), never a root index path: `{op:"set",path:"layers/3/..."}` is rejected with `use_id_anchor` and the corrected anchored form in the message. Omit the anchor only for document-root fields (`composition/*`, `version`). A sub-scene is an asset: create it with an anchorless `add` of `kind:"asset"` and a `type:"scene"` value, remove it on its `asset` anchor, edit inside it with `scope`. `path` is a slash-separated RFC-6901 pointer relative to the anchored entity (`content/text`, `effects/0/params/amount`); a dot-separated path fails with a slash-form hint. Ops apply in order to one clone, later ops seeing earlier results; the first failing op aborts the WHOLE batch with a typed error (`code`, `opIndex`) and no partial result, and the input is never mutated. The result runs the full picsart_media_validate_scene pipeline (schema, semantic rules, the font-metric text-fit lint), and an error the patch introduces fails the batch; one the input already held comes back as `valid:false`, so a scene is repaired patch by patch. A `valid:true` success needs no picsart_media_validate_scene after it. Validation proves the scene contract, not that remote assets or scene_refs are fetchable.

picsart_media_patch_scene

The Picsart Drive client that Picsart widgets call; it is app-only and hidden from the model. Each call performs exactly one of the six actions in `action`, and every action is also exposed as its own tool with its own input schema and annotations: `list` is picsart_drive_list (read-only), `create_folder` is picsart_drive_create_folder, `upload` is picsart_drive_upload, `move` is picsart_drive_move, `update` is picsart_drive_update and `delete` is picsart_drive_delete. To work with the user's Drive, call those tools. Requires an authenticated Picsart session (per-user Drive content).

picsart_drive

Checks a planned `picsart_generate` request without running it: in ONE call it (1) validates the request's settings against what the selected model accepts, including the constraints between settings, and (2) attempts a best-effort credit estimate. Nothing is generated and nothing is charged. Use this after assembling params (user input, derived defaults, model swaps) and before generating, to surface bad arguments and show estimated cost when available. 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 `params` — the planned `picsart_generate` inputs (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. It also probes every image input — every param the model declares as an image file (`imageUrls`, `startFrame`, `endFrame`, or a single `imageUrl` on an edit model): each Picsart-hosted picture's pixel size and bytes are read from its header, and a picture a video model would reject makes the call invalid with the fix in `errors`. The floor is 300 px on BOTH sides and the ceiling 6000 px on the long side, so a 252×508 panel cut off a character sheet is refused for its width just as a 480×270 contact-sheet thumbnail is refused for its height — the fix is to cut the panel again at a bigger scale, or to export the frame at full size with `picsart_media_export` (`mediaType: "png"`, `startTime`). `images[]` lists what was found per picture, measured, whether or not it passed; `warnings[]` carries the soft findings (a picture over 4096 px, more than 15 MB of inputs in total). A `startFrame`/`endFrame` on a video model that also takes `imageUrls` is checked as a mode: mixed with reference media it is invalid on Seedance (the provider rejects the mix after the wait), and sent alone it earns a warning — only the people visible in that frame have a picture; put the frame first in `imageUrls` and say "IMAGE 1 — START FRAME" in the prompt to keep the references. A model-specific `extra` bag inside `params` is flattened before the checks. A param the model does not declare earns a warning. The quote depends on the inputs, so pass the same image/video inputs, duration and resolution you will send to `picsart_generate` (an image-to-video call quotes higher than text-to-video).

picsart_preflight

Returns a remote media URL's metadata using bounded network reads: `kind` (image/video/audio), as-displayed `width`/`height` (EXIF orientation applied, plus the raw `orientation`), `durationSeconds` (mp4/mov/m4a), `contentType`, and total `bytes` — using ranged reads where supported, with response-size and time limits; fragmented MP4s can require additional reads. Provides source dimensions and duration for sizing compositions, choosing `fit`, setting clip windows, and checking whether an asset matches the scene requirements. 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. Skip this call if you already know the asset's exact width/height/duration from a prior tool result (e.g. a generation tool's own response) — this is a cost-saving lookup, not a required gate. A missing `durationSeconds` means the duration is unknown — it is never emitted as 0 for a real zero-length clip. Fragmented MP4 / streaming uploads carry no duration in their container header, but this tool now recovers it for most of them by walking the file's fragment timeline, so a duration usually comes back anyway; when the field is still absent it genuinely could not be determined. That pass costs a few more small ranged reads — still bounded and free. Do not assume 0; resolve it another way before computing trims. The response may also carry `fps`, `videoCodec`, `audioCodec` and `hasAudio` when they are derivable from the container — these are best-effort extras and are omitted rather than guessed.

picsart_media_probe_media

CAN BE UNAVAILABLE: if layout resolution is unavailable, the call fails, and retrying with a different `engine` does not help. A rendered frame (`picsart_media_contact_sheet`) still answers whether content is there and looks right, and the authored positions are in the scene itself. Resolves each layer's geometry in the root composition at a given time without rendering pixels: root-space `box {x,y,width,height}` (top-left pixels), `center`, `rotationDeg`, paint-order `zIndex`, `visible`/`active`, `onCanvas`, timing and hierarchy. Use it before checking a rendered frame (`picsart_media_contact_sheet`) to verify placement, overlap, canvas coverage and stacking. Coordinates are top-left pixels in root space for every `engine` value; `engine` never changes the convention. Nested children are namespaced and returned individually; inactive layers have `active:false` and no box. `verbose:true` adds raw matrices and transform components. Limitations: (1) boxes are resolved LAYER GEOMETRY, not painted pixels — shape bounds are conservative and can include transparent or animated branches; check a rendered frame (`picsart_media_contact_sheet`) when the visible extent matters. (2) On `v3` text reports a real font-metric box; on `jet` text is not measured — the layer is listed (id, timing, hierarchy, `zIndex`, `active`) with no `box`/`center`/`onCanvas` and a `notes[]` entry, because the only box available for text there is a composition-sized placeholder, whose every number would look plausible and mean nothing. Any other degenerate box (a failed text measurement, collapsed auto-sized content) is flagged in `notes[]` too. (3) The query returns an inline report without saving a report file, and may fetch referenced scenes, fonts, and caption transcripts through guarded public-URL reads. (4) GEOMETRY ONLY, not a render/export gate: effects, assets, codecs and engine render support are not evaluated; only a pixel render proves visible output. Every report repeats these caveats in `scope`.

picsart_media_query_layout

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 picsart_media_* tool-call sequences. Omit `recipe` for the index.

picsart_media_quickstart

Without `scene`, replies with a media job receipt by default, not the reframed scene: pass the receipt's `job` object verbatim to the status tool named in its `tools.jobStatus`, which reports progress and, once the job finishes, the same result this tool returns with async:false. With `scene` + `layer_id` it always waits and replies with the reframed scene itself. Reframe a video to a different aspect ratio, tracking the subject with an animated pan/zoom rather than a fixed centered crop. Returns a scene ready to render with `picsart_media_export` — pass `scene` + `layer_id` to attach the reframe to an existing scene's layer instead of synthesizing a new one, e.g. after `picsart_media_upload` — that layer's media asset, content bounds/fit, and transform anchor are all normalized to (and, for the asset, reassigned to) `url` itself in the process, so the layer is guaranteed to show the exact video the crop track was computed against, noted in the response when anything actually changed. Inspect the result with `picsart_media_validate_scene` before exporting. It reframes by moving and scaling the existing footage; it never generates new pixels to fill a wider frame, so the output resolution is limited to what the source actually contains at the target aspect.

picsart_media_reframe_video