add_sound_effects
ChatGPTAdd synced sound effects (foley, ambience) to a video generated from its visuals. Find the model via list_models({ capability: "sound-effects" }) and pass its params (video URL; optional text prompt for the sound character). Returns a job id to poll.
ai_app
ChatGPTRun a Pixara AI App - the long-tail drawer of one-shot image edits: professional headshot, text/watermark removal, creative image filters, image avatars from a face photo. Find one via list_models({ capability: "ai-apps" }) and pass its params (usually an input image URL). Prefer a NAMED tool when one exists for the intent. Returns a job id to poll.
assemble_video
ChatGPTAssemble finished media into ONE final video on a multi-track timeline: cut clips in order, overlay text titles and logo images, lay narration over the cut, duck a music bed under it - a single render, a single deliverable. Call get_assembly_guide FIRST for the timeline grammar, composition rules, and recipes (narrated video, slideshow, social cut); describe_model("pixara/assemble-video") has the full JSON schema. Model is "pixara/assemble-video"; params = { output: { aspect, resolution? }, timeline: { tracks: [...] } }. Asset references are platform asset KEYS from your earlier generations (each job result lists its assets’ keys), never URLs; call get_media_metadata(key) for exact source durations before sizing clips - listed durations are rounded. A rejected timeline names the exact clip path and numbers - fix that and retry. Generate the ingredient assets first, then assemble; never deliver loose clips when a finished piece was asked for. Returns a job id to poll.
avatar
ChatGPTAnimate a talking avatar from an image and audio. Pass an avatar model id (find them via list_models({ capability: "ai-avatar" })) and params (imageUrl and audioUrl). Only animate a face the user owns or has permission to use; decline requests to make a real person appear to say something they did not, or to deceive. Returns a job id to poll.
change_camera_angle
ChatGPTRe-render an IMAGE from a different camera angle (low angle, side view, from behind). Find the model via list_models({ capability: "camera-angle" }) and pass its params (image URL + the desired angle in the prompt). Returns a job id to poll.
clone_voice
ChatGPTGenerate speech in a cloned voice from a reference sample. Pass a clone-capable voiceover model (find them via list_models({ capability: "voice-clone" })), the text to speak, and the URL of a voice sample to clone (use upload_asset to ingest a local sample first). Only clone a voice the user owns or has the speaker’s permission to use; decline requests to imitate a real person without their consent or to make anyone appear to say something deceptive. Returns a job id to poll.
describe_model
ChatGPTGet the full input schema, asset-input fields, and pricing for a single Pixara model. Call this before generating to learn the required parameters.
diagnose_run
ChatGPTDiagnose a workflow run in one call: verdict (succeeded / failed / in_progress / partially_completed), the failed node with its error, the last successful node, per-step states, and a suggested action. This is also the poll - call it repeatedly until the verdict is terminal, then surface suggestedAction. Pass stepId to focus on a single node.
dubbing
ChatGPTDub or translate the spoken audio in a video into another language while keeping the visuals (lip-synced where the model supports it). Find a model via list_models({ capability: "video-translate" }) and pass its params (a video URL and target language). Returns a job id to poll.
estimate_cost
ChatGPTEstimate the credit cost of a generation before running it. Pass the same params you would pass to a generate or edit tool, including the model id. Returns the estimated credits, or indicates the cost can only be known once the job runs.
finalize_upload
ChatGPTComplete a local-file upload started with request_upload, after the PUT to the presigned uploadUrl succeeded. Registers the file and returns the asset: a fresh URL (input to generation/edit tools) plus its asset key (for assemble_video).
generate_batch
ChatGPTQueue several independent generations in one call (up to 12) - a shot list of clips, a set of image variants, the lines of a voiceover. Each job takes the same { model, params } you would give generate_image / generate_video / generate_voiceover / generate_music, and jobs may mix models and media types. Every job is queued and billed on its own, so one failing does not stop the others. Returns the jobId per index; then call wait_for_jobs with all the ids to wait for the whole batch at once. Prefer this over N separate generate_* calls whenever the jobs do not depend on each other.
generate_image
ChatGPTGenerate an image. Pass a model id (from list_models with service "image-generation") and its params (use describe_model for the schema; prompt is usually required). Returns a job id to poll.
generate_music
ChatGPTGenerate music. Pass a model id (service "music-generation") and params (prompt required). Returns a job id to poll.
generate_video
ChatGPTGenerate a video. Pass a model id (service "generative-video") and its params (prompt usually required; some models need an input image URL). Returns a job id to poll.
generate_voiceover
ChatGPTGenerate speech/voiceover. Pass a model id (service "voiceover-generation") and params (text required; voiceId or a reference audio URL depending on the model). Returns a job id to poll.
get_assembly_guide
ChatGPTThe video-assembly playbook for assemble_video: the pixara-timeline grammar, composition rules, and the recipe patterns (narrated video, slideshow, social cut). Call this BEFORE authoring your first timeline in a session - it is static reference, free, and makes the difference between a torn spec and a clean render.
get_asset
ChatGPTShow one of the user’s assets again: renders it inline (image, video or audio) and returns a fresh URL. Use it when the user asks to see an asset. For a silent lookup of a reference the user just picked or uploaded (fresh URL, key and a preview, no widget) use resolve_asset instead. Takes a numeric id, "asset-<id>" for generations, or "upload-<id>" for files the user uploaded.
get_credits
ChatGPTCheck the user’s current Pixara credit balance. Use this to confirm there are enough credits before starting a generation.
get_job
ChatGPTCheck a Pixara job once. Returns its status, and if finished, the resulting asset(s) rendered inline.
get_media_metadata
ChatGPTExact media metadata for one of the user’s assets: precise fractional duration in seconds, dimensions, fps, and mime type, probed from the file itself. Pass the asset KEY (e.g. "videos/<uuid>.mp4") or a reference ("asset-123", "upload-45", or a bare number) - both appear in results. Asset listings round durations to whole seconds - ALWAYS use this before assemble_video so trims and clip lengths fit the real source.
get_node_result
ChatGPTRead a completed workflow step’s output, in the exact shape pinnedContext accepts - use it to fetch finished work before a rerun-from, or to hand the user a specific step’s result. Asset outputs carry platform asset keys, and media outputs render inline.
get_skill
ChatGPTThe full text of one Pixara recipe by name (from list_skills): its rules, the questions worth asking, the phases, the verified models with their limits, the prompt shapes and the assembly steps. Read it once per piece and follow it; it is static reference and costs nothing.
get_workflow_definition
ChatGPTFetch a workflow’s agent-facing definition: a textual digest of its steps and wiring plus the input descriptor ({ nodeId, label, type } per input node). ALWAYS call this before run_workflow - it shows the real input labels to ask the user about. Surface the workflow’s purpose and inputs, then offer to run it.
lip_sync
ChatGPTLip-sync a video to an audio track. Pass a lip-sync model id (find them via list_models({ capability: "lip-sync" })) and params (video and audio URLs). Only use footage and voices the user owns or has permission to use; decline requests to make a real person appear to say something they did not, or to deceive. Returns a job id to poll.
list_caption_styles
ChatGPTList the caption styles of a caption model (find them via list_models({ capability: "subtitles" })), rendered as cards with a looping preview of each style and a "Use" button that drops the style and its model into the user’s chat box. Returns each style’s preset with its name, categories and price per minute; the preset goes in the model’s preset field on the subtitles tool. Call this when the user wants to see or choose a caption look. Filter with category (basic, highlighted, animated) or search by name.
list_generations
ChatGPTBrowse the user’s existing Pixara assets (their past generations and uploads), most recent first, rendered as an inline library widget: a paged thumbnail grid where a click previews a tile and a hover shows a "Use" button that drops the asset’s reference (asset-<id> or upload-<id>) into the user’s chat box. A follow-up message shaped like "Use this image as the input for my next generation … Reference image: asset-123 … Prompt: …" came from that button: resolve the reference with resolve_asset (or the URL already in context) and pass the URL to the tool. Each asset has a durable assetId and a fresh URL, usable as inputs to other tools. Optionally filter by category ("images", "videos", or "audio"). Returns a cursor for the next page. To re-open a known assetId later whose URL has expired, use get_asset.
list_models
ChatGPTList the Pixara models available for a service, with their pricing and capabilities. Optionally filter to a single capability (e.g. "lip-sync", "voice-clone", "upscale-image", "video-edit"). Deprecated models are excluded. To pick the best model for a described goal, prefer recommend_model; use this to browse or narrow the full catalog.
list_runs
ChatGPTThe user's recent workflow runs, newest first: run id, status, progress, when it ran, and the owning workflow. Optionally filter by a workflow's projectId (from list_workflows). Run ids feed diagnose_run and get_node_result - use this to find a past run instead of asking the user for an id.
list_skills
ChatGPTThe Pixara recipes: one per made-to-brief piece (presenter video, product reel, avatar video, faceless explainer, animated story, cinematic trailer, product photoshoot, Amazon listing, ad creative, social graphics, thumbnail, character sheet), each with when it applies and what it is not for. Call this before starting any multi-step piece, then get_skill for the one that fits. Static and free.
list_voices
ChatGPTList the preset voices for a voiceover model that needs a voiceId (describe_model shows whether a model takes one), rendered as cards with a sample player and a "Use" button that drops the voice and its model into the user’s chat box. Returns each voiceId with its name/gender/language so you can pass a voiceId to generate_voiceover. Optionally filter by language, gender, or a name search. Models that clone from a sample (list_models({ capability: "voice-clone" })) have no preset voices - use clone_voice for those.
list_workflows
ChatGPTList the user’s saved Pixara workflows - multi-step machines they built on the canvas. Each entry carries the projectId used by get_workflow_definition and run_workflow. Use when the user wants to find, list, or pick one of their workflows.
media_utility
ChatGPTMechanical media operations: trim a video, merge videos, merge audio onto video, merge audio tracks, extract a video frame. Find a model via list_models({ capability: "media-utility" }) - each operation is its own model, and some operations have more than one - then describe_model for its exact params and constraints. Returns a job id to poll.
motion_control
ChatGPTTransfer motion from a driving video onto an image/character. Pass a motion-control model id (find them via list_models({ capability: "motion-control" })) and params (image and video). Only animate a person the user owns or has permission to use; decline requests to put a real person in footage they did not take part in, or to deceive. Returns a job id to poll.
recommend_model
ChatGPTRecommend the best Pixara models for a described goal. Pass a natural-language goal (e.g. "lip-sync a talking-head video to an audio track", or "photorealistic product photo with legible text") plus optional service or capability filters. Returns a short ranked shortlist matched on each model's tags, capabilities, and description, with pricing. Then call describe_model on your pick for its exact params.
reframe
ChatGPTChange the aspect ratio of an image or a video with content-aware outpainting (e.g. 16:9 to 9:16). Find a model via list_models({ capability: "reframe" }) - image and video models are distinct; check the model constraints for source-length caps - and pass its params. Returns a job id to poll.
remove_background
ChatGPTRemove the background from an image or a video (subject/product cutout; video models support green-screen output). Find a model via list_models({ capability: "background-removal" }) - image and video models are distinct - and pass its params (an image or video URL). Returns a job id to poll.
request_upload
ChatGPTStart uploading a LOCAL file from the user’s machine into their Pixara assets. Returns a presigned uploadUrl - HTTP PUT the raw file bytes to it yourself (e.g. curl -T file, or PowerShell Invoke-RestMethod -Method Put -InFile), with the same Content-Type you declared - plus the storage key. After the PUT succeeds, call finalize_upload with that key. Only image, video, or audio files. For a file already on the web, use upload_asset with its URL instead.
resolve_asset
ChatGPTSilently look up an asset the user referenced as "asset-<id>" or "upload-<id>" (the library widget and the uploader write these into the chat): returns a fresh URL, the key, its size and a small preview so you can see it. Renders nothing. Use this instead of get_asset after the user presses Use or uploads a file; call get_asset only when the user asks to see the asset again.
run_workflow
ChatGPTRun one of the user’s workflows server-side; every step bills like a normal generation. Qualify intent BEFORE running: call get_workflow_definition first, then ask the user for each required input BY ITS REAL LABEL - never re-ask anything they already said. inputs is a flat object keyed by input node id or display label (case-insensitive); an unknown key returns an error listing the workflow’s known inputs and the run does not start. Asset inputs take platform asset KEYS (from job results or upload_asset), never URLs. Omit targetNodeIds to run the whole workflow. To rerun from partway - reusing finished work instead of re-paying for it - pass pinnedContext (node id → that node’s output, from get_node_result), optionally with targetNodeIds to limit what runs. Returns a run id immediately; poll with diagnose_run until the verdict is terminal.
subtitles
ChatGPTBurn styled, auto-transcribed captions into a video. Find a caption model via list_models({ capability: "subtitles" }) and pass its params (video URL; the style goes in preset). Caption styles with their previews come from list_caption_styles, because some models take a style id their schema cannot list; describe_model shows which models also accept authored caption text for a piece with no speech. If one model refuses a video or its job fails, another can be used. Returns a job id to poll.
upload_asset
ChatGPTIngest an external media URL into the user’s Pixara assets and return a Pixara asset URL (input to generation/edit tools) plus its asset key (for assemble_video). Images are compressed to <= 2MP / <= 10MB. URL ingestion ONLY - for a LOCAL file on the user’s machine, use request_upload + finalize_upload instead (upload the bytes yourself via the presigned URL).
upload_widget
ChatGPTOpen the Pixara upload widget for a LOCAL image, video, or audio file on the user’s device. Set maxFiles to 1 for a single file (the widget continues on its own once it lands) and minFiles when a recipe needs several (Continue stays off until that many are in). Call this immediately when the user has local media to use as input and the client can render Apps UI - do NOT ask them to attach the file in chat; remote MCP tools cannot read chat attachments. The user picks files in the widget, the browser uploads them directly, and the confirmed assets are reported back for the next tool call. Agents with a shell should use request_upload + finalize_upload instead.
upscale
ChatGPTUpscale an image or video to higher resolution. Pass an upscale model id (find them via list_models({ capability: "upscale-image" }) or "upscale-video") and params (imageUrl or videoUrl). Returns a job id to poll.
vectorize
ChatGPTConvert a raster image (logo, icon, flat artwork) into a vector SVG. Find the model via list_models({ capability: "vectorize" }) and pass its params (image URL). Returns a job id to poll.
wait_for_job
ChatGPTWait for a Pixara job to finish (polls for up to ~45 seconds), then return the resulting asset(s) rendered inline. If it is not done yet, returns the current status - call wait_for_job again to keep waiting.
wait_for_jobs
ChatGPTWait for several Pixara jobs at once (polls all of them for up to ~45 seconds) and return every finished asset rendered inline in one gallery. Pass all the jobIds from generate_batch (or from separate generate_* calls). Finished jobs come back with their assets, failed jobs with their error; if some are still running when time runs out the result names them - call wait_for_jobs again with just those ids to keep waiting. Use this instead of one wait_for_job per id.
