_create_ui_stream_token
ChatGPTApp-only. Issue a five-minute UI access token for the authenticated user and selected workspace, returned only in widget metadata. Reuse instance_id on reconnect; resources declares event and HTTP read consumers such as Soul Feed. Including ui://higgsfield/ai-influencer-motion explicitly requests Motion HTTP quote/submit authorization on the same token and requires openai:mcp:write in addition to read access. Ordinary read tokens never authorize generation. This tool does not start jobs or spend credits; submit through the widget only after the user clicks Generate with a displayed price.
ad_multiplier_cancel
ChatGPTCancel an owned pending Ad Multiplier v2 generation from the app's Cancel action.
ad_multiplier_quote
ChatGPTQuote an Ad Multiplier v2 recreation or the maximum credit reservation for Hook/CTA replacement in the app.
ad_multiplier_submit
ChatGPTSubmit one paid Ad Multiplier v2 video from the app's Generate action. Images are optional; all creative instructions belong in the prompt. Free and unlimited generations are unavailable.
ad_multiplier_video_upload
ChatGPTPrepare a user-selected video upload or confirm its chosen 4–30 second segment after the presigned PUT succeeds. Uses the web video upload pipeline; does not generate a video.
ads_studio_add_product
ChatGPTAdd a product to Ads Studio - under a brand, or with no brand at all - from its page link and/or a pasted description. Answers as soon as the row is queued - Ads Studio reads the page in the background. Do not poll and do not list products to check. Read ads_studio_get_product when the user asks about it. Use this when the research missed a product or the user names a new one. To refresh an existing product from its page, pass its id in overwrite instead of adding a second row.
ads_studio_cancel_run
ChatGPTCancel a queued or running Ads Studio generation. Pictures already rendered stay; a run too far along to stop answers that it can no longer be canceled. Only cancel when the user asks.
ads_studio_card
ChatGPTWhat the Ads Studio card shows: brands, one brand, products or one product. Used by the card.
ads_studio_create_brand
ChatGPTResearch a brand from its website and build its Ads Studio brand profile: products, palette, logo, tone and audience, read from the live site. Pass the website when you have it - with a URL the research starts at once and takes a few minutes; with only a name Ads Studio answers with the site it thinks was meant and starts nothing, so confirm that with the user and call again with the URL. This reads the brand's own public website. It does not design logos or brand assets (that is the brand-asset-creation workflow) and it is not the Marketing Studio brand-kit record (marketing_create_brand_kit). Before the first Ads Studio call in a conversation, load the Ads Studio instructions with get_preset_instructions and preset 'ads-studio'.
ads_studio_delete_brand
ChatGPTDelete the brand and its research/products after the app's explicit confirmation. Requires the fresh, one-use widget token from ads_studio_prepare_delete. UUID-only calls never delete. Does not use chat.
ads_studio_delete_product
ChatGPTDelete one product after explicit confirmation in the details window. Requires the fresh, one-use widget token from ads_studio_prepare_delete. UUID-only calls never delete. Does not use chat or generate ads.
ads_studio_generate
ChatGPTGenerate ad creatives in Ads Studio: for a brand, for products of any brand or of none, or from a prompt and the user's pictures alone, with or without the brand kit. Ads Studio writes the concepts and renders the pictures. This spends Higgsfield credits, so quote with ads_studio_quote and get explicit approval of the exact allocation and credit cost first. An approval from the Ads Studio app allocation is NOT approval. When allocation is supplied, this tool quotes the whole allocation and requests native MCP form confirmation when supported. Otherwise it returns approval_required and credits: show the exact counts and cost, ask for explicit chat approval and stop. Only after approval, repeat the unchanged allocation with expected_credits. Never split the allocation or bypass a supported native form. Answers as soon as the runs are accepted, with a run id each - report those and stop; read ads_studio_get_run when the user asks, never in a loop. Generation takes a few minutes.
ads_studio_get_brand
ChatGPTRead one Ads Studio brand: how far its research got through the five stages (gather, synthesis, enrichment, products, assets) and what is already usable. Use this to answer "is the research done?" - status done means the brand and its products are ready. Call it when the user asks, not on a timer, and never in a loop: research can take several minutes. Follow next_step: a finished research is offered for ads, never generated on its own.
ads_studio_get_product
ChatGPTRead one Ads Studio product and open it as a card: whether Ads Studio has finished reading its page (status queued, in_progress, completed or failed, with fail_reason when it failed) and what it knows - name, price, page, description, selling points. Use this to answer "is the product ready?" after ads_studio_add_product, when the user asks - not on a timer and never in a loop.
ads_studio_get_run
ChatGPTRead one Ads Studio generation run: its status and every concept in it, with the ad copy. Opens the generation card, which shows the pictures - there is no image link in the result and none to ask for. Call it when the user asks about a run - never on your own initiative and never in a loop. A run can read done while its pictures are still rendering, so check still_rendering before telling the user the ads are ready. A queued run carries its place in line; a canceled run stays canceled and is not a failure. Name a creative by its concept_id. These pictures are not ordinary generations: do not pass Ads Studio ids to show_generation_by_ids or jobs_wait.
ads_studio_list_brands
ChatGPTList the brands in this account's Higgsfield Ads Studio, with each one's research status and how many products it has, and open them as a card the user can browse. Call this when the user talks about advertising an existing brand, so later tools get a real brand_id; when the list is already in this conversation, reuse its ids instead of listing again. This is Ads Studio, the ad-creative workspace: it is not the Marketing Studio brand-kit record (marketing_list_brand_kits) and it does not create or design brand assets. Before the first Ads Studio call in a conversation, load the Ads Studio instructions with get_preset_instructions and preset 'ads-studio': it carries the frames, objectives and the research-then-offer flow.
ads_studio_list_products
ChatGPTList Ads Studio products and open them as a card the user can browse: name, price, page, how many pictures it has, whether the brand page shows it (picked_for_ads) and whether its ad copy is ready. With brand_id: that brand's products. Without it: every product the user has - of any brand or of none - a page at a time. Use product_id in ads_studio_quote and ads_studio_generate: a generation advertises exactly the products named there, whatever picked_for_ads says. texts_ready=false means the copy is still being written and ads made from it come out weaker.
ads_studio_list_runs
ChatGPTList recent Ads Studio generation runs, newest first, optionally for one brand. Use it to find a run whose id was lost, or to check what is already in flight before starting another batch.
ads_studio_prepare_delete
ChatGPTINTERNAL — confirmation widget only, after an explicit user Confirm click. Checks access without deleting and returns a 120-second, caller/workspace/resource-bound one-use token in widget-only metadata. Never call from chat or treat app visibility as authorization.
ads_studio_quote
ChatGPTGet the cost without starting a generation, reserving credits or spending credits. A user request to create ads, including an exact allocation submitted from the Ads Studio app, authorizes this read-only quote: do not ask for separate permission to quote. Takes the same arguments as ads_studio_generate so the quote matches the run. After quoting a requested generation, show the exact allocation and total credits; use ask_user_input (or ask_user_input_v3) only when that exact host tool is available, otherwise ask one concise chat question. Never invent a host tool or generate before explicit approval of this allocation and cost. A price-only request needs only the quote, not a spending-approval question.
ads_studio_run_progress
ChatGPTProgress of one Ads Studio generation run. Used by the generation card.
ads_studio_save_brand
ChatGPTSave user-edited brand kit fields from the app, or create a manual brand kit. Never researches or generates ads.
ads_studio_update_product
ChatGPTChange one Ads Studio product, or hide it from the brand page. picked_for_ads=false hides it and true shows it again; neither deletes anything, and a generation still advertises exactly the products it names. Every other field is a merge patch: what you leave out is left alone. Use the user's own words for the copy fields; do not invent selling points they did not say.
ai_influencer_builder
ChatGPTQuote or generate a batch of one to four character sheets from the builder, or check a job. Free generations always submit one sheet. Returns job_id for the first accepted job and job_ids for a batch; track every returned job. Submit only after the user clicks Generate with a displayed price. Free generations require the builder’s explicit Use free gens toggle; never retry a rejected free request on credits automatically. The Motion tab quotes and submits influencer Genjutsu jobs using motion_quote/motion_submit, with the dedicated ai_influencer job types.
ai_influencer_character_sheet_presets
ChatGPTApp-only: load a page of AI Influencer character sheet presets with preview media and recreate parameters.
ai_influencer_generate
ChatGPTGenerate and save one to four AI Influencer character sheets in the selected Higgsfield workspace from exact params returned by ai_influencer_prepare. Does not train a Soul or generate video. Rechecks price before submission and rejects paid prices above max_credits. Paid generation spends existing credits; it does not purchase credits or subscriptions. use_free_gens=true requires explicit user intent and backend eligibility, with max_credits=0 for free-only requests; never falls back to paid generation. Returns job_id for the first accepted job and job_ids for a batch before completion; wait for every returned job. Free generations always submit one sheet. Repeating this call can create another job and spend credits again; never automatically retry an uncertain submission. An auto-updating generation widget shows every accepted sheet and its progress. Wait with jobs_wait (timeout_seconds <= 15); do not call show_generation_by_ids or job_display again unless the user requests a separate display. After completion, offer Genjutsu animation and wait for agreement before opening motion presets.
ai_influencer_get_options
ChatGPTList available AI Influencer character traits for human and animal tiers. Optionally filter by tier; returns option IDs and tier constraints for ai_influencer_prepare. Does not randomize, quote, create or save a character.
ai_influencer_get_settings
ChatGPTRead reusable settings from an existing AI Influencer sheet using its job_id. Returns human or animal traits, identity and Style references, body color and saved appearance variants when present. Does not replay the original batch count, quote, save or generate an image. Pass returned params to ai_influencer_prepare with randomize=false to preserve the design.
ai_influencer_list_presets
ChatGPTBrowse AI Influencer character-sheet presets with previews and reusable settings. Does not generate a sheet. Pass selected preset settings to ai_influencer_prepare with randomize=false.
ai_influencer_prepare
ChatGPTPrepare an AI Influencer character design and quote the total credit cost for batch_size (one to four sheets, default one) without creating a job or spending credits. Accepts human or animal tiers, traits, brief, seed, at most one confirmed identity image in medias and up to three Style references in item_medias. Preserves animal-v3 look and animal trait choices from saved settings; FNF validates variant IDs against the current catalog. Default randomize=true fills unspecified traits using builder shuffle rules; reference identity traits stay unset unless explicitly selected. randomize=false preserves explicit settings and defaults tier to freak (Bold). Returns exact params, credits and free_gens_remaining when known. For generation, pass these params unchanged to ai_influencer_generate; preview-only requests stop here. Repeating preparation may produce a different random design.
archive_project
ChatGPTArchive one project reversibly. Inspect get_project capabilities first when permissions are unclear. Restore it with unarchive_project.
assets_picker_list
ChatGPTList existing uploaded, generated, or liked image/video assets for an app picker. Invoked only by the app; never uploads, generates, or modifies assets. Generations and liked assets support combined image/video kinds and an accessible project or exact folder scope. Sort generations by creation time, project assets by time added, and liked assets by time liked. Uploads also support last-used. Available sorts depend on source and scope.
attach_project_asset
ChatGPTAttach an existing accessible typed source ID to folder_id. Upload and confirm a new file using media_upload/media_confirm with source_type=file_input first. Reattaching the same source to the same folder reuses its placement. Inspect assets after an uncertain receipt; never blindly repeat mutations.
balance
ChatGPTRead-only balance: credits, workspace plan, free generations (free_gens — Genjutsu on generate_video, Viral on execute_preset, and AI Influencer Builder via its Use free gens toggle), and free-trial state (free_trial.unlim_available says whether unlimited generations can be spent). Call it for credits / plan / trial questions or after an out-of-credits error. Report the current balance and entitlement state, and explain any insufficient-credit limitation. Do not provide pricing links, purchase or upgrade directions, or trial-start instructions.
cancel_project_publication_review
ChatGPTCancel the CURRENT open publication review after explicit user approval. No review-ID binding exists. Cancellation does not roll back metadata already saved by preview/update/publish, and does not unpublish an existing publication. Obtain explicit user approval through the MCP host before invoking this tool. The host owns its approval policy; the server cannot independently verify a human decision. Do not invoke based only on inferred intent. After an uncertain response, stop and read get_project_publication to observe current state. There is no per-operation receipt or automatic replay guarantee; do not blindly repeat a publication mutation. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
canvas_add
ChatGPTAdd items to an existing Higgsfield canvas board in the authenticated user's workspace: sticky notes, text, shapes, images, image and video generation nodes, and connections between items. It does not create pages; page_id puts an item on a page that is already on the board. Use it when the user asks to put something on a board; canvas_update changes existing items and canvas_remove deletes them. Added items are saved to the board and appear live for everyone viewing it, including an open_canvas view already shown: do not call open_canvas again to refresh it. A generation item saves its model, prompt and settings only: this tool does not start generation or charge generation credits; canvas_run does. Give a generation item only the settings the user asked for: the others stay the model's defaults, and the result lists the settings each generation node got and any value the model did not take. An image item imports a Higgsfield generation or upload image URL into the user's Higgsfield media; unsupported URL origins are rejected before the board changes, and imported media may remain even if adding to the board fails. A connection into a generation node feeds it: the source (an image, a video, another generation node's result, or text for the prompt) fills the node's matching free input (an image fills reference images before a start or end frame; set the connection's input to choose, e.g. start_image for an exact first frame), and canvas_run uses it. That is how to generate from an image on a board, e.g. image to video. Between other items a connection draws an arrow. Give items a key to connect them in the same call; connect to items an earlier call added by the ids it returned. To add more than 5 items, make several calls of up to 5 items each, in the order a person would lay them out (a card or a step at a time), so everyone viewing the board sees it grow, and set final on your last change to the board. Additions can partially apply: inspect applied and rejected before retrying, since repeating an addition creates duplicates. Returns the new items' ids in order, and each connection's id and the input it fills.
canvas_create
ChatGPTCreate a new private canvas board and return its room_id and canvas_url. The board opens for the user and shows later canvas_add, canvas_update and canvas_remove changes and canvas_run results live, so open_canvas is not needed for it. Use the room_id with canvas_read, canvas_add, canvas_update, canvas_remove and canvas_run.
canvas_read
ChatGPTRead a canvas board: every node with its id, type, position, size and text, grouped by page, and the arrows between them. Filter by types, text query or node_ids on big boards. Read before adding so new items do not overlap existing ones, and for the node and edge ids that canvas_update and canvas_remove take.
canvas_remove
ChatGPTDelete items and connections from a Higgsfield canvas board in the authenticated user's workspace. Use it only when the user asks to delete something: pass node ids and edge ids from canvas_read or canvas_add. Deletions are saved to the board and appear live for everyone viewing it, including an open_canvas view already shown. Some deletions can be rejected while others apply: inspect applied and rejected.
canvas_run
ChatGPTRun generation nodes on a canvas board (and the nodes they depend on). Generations cost credits: first call with confirm=false. Nothing starts, and it returns the price of each charged generation and the total. Give the user one answer with what will run, its settings and that total, and only after they agree call again with confirm=true. A generation without a price is named as such: tell the user instead of estimating it. Price board nodes here, not with estimate_image_cost or estimate_video_cost: those name board models differently. Results appear in their nodes on the board live, including an open_canvas view already shown (do not open it again); read them with canvas_read include_results=true. To generate on a board, add generation items and the connections that feed them with canvas_add and run them here: generate_image and generate_video results do not land on a board.
canvas_update
ChatGPTChange existing items on a Higgsfield canvas board in the authenticated user's workspace: move them, resize them, or replace the text of sticky notes, text blocks and shapes. Each change names a node id from canvas_read or canvas_add and gives a new position (x and y), a new size (width and height), new text, or several of these. Use it when the user asks to rearrange, resize or reword items; canvas_add adds items and canvas_remove deletes them. New values overwrite the old ones, are saved to the board and appear live for everyone viewing it, including an open_canvas view already shown. Changes can partially apply: inspect applied and rejected before retrying.
confirm_project_publication_review
ChatGPTSeparately approve publishing with flagged media HIDDEN for the CURRENT awaiting-confirm review. First show the complete current flagged list and visibility and obtain a NEW explicit user decision to proceed with those items hidden. Never automatically invoke after publish/update/preview. No exact review-ID or frozen snapshot binding exists; incomplete lists require Higgsfield web. Obtain explicit user approval through the MCP host before invoking this tool. The host owns its approval policy; the server cannot independently verify a human decision. Do not invoke based only on inferred intent. After an uncertain response, stop and read get_project_publication to observe current state. There is no per-operation receipt or automatic replay guarantee; do not blindly repeat a publication mutation. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
copy_project_asset
ChatGPTCopy source_placement_id into target_folder_id, optionally in target_project_id. Omit target_project_id for this project. Creates another placement, not a new uploaded source. Creation is not idempotent: do not repeat an uncertain copy automatically.
create_folder
ChatGPTCreate one subfolder in an existing Higgsfield media project. Use project_id returned by create_project in this conversation or explicitly supplied by the user. Omit parent_folder_id to create directly under the root. Keep using the project's default_folder_id for generation unless the user wants outputs in this subfolder; then pass its folder_id. This does not create a project or a local filesystem folder. Creation is not idempotent: do not automatically retry after a timeout or uncertain result.
create_or_update_canvas_token
ChatGPTApp-only canvas access. Without room_id, create a private FNF project and its canvas using workspace_id and idempotency_key; retain the same workspace, key and name on uncertain retries within 15 minutes. With room_id, check access and issue a fresh token for the same canvas. Tokens last at most 5 minutes and are returned only in _meta.token. Refresh before expires_at (Unix seconds). The token authorizes this room's graph, generation, version and WebSocket-ticket endpoints; it is not a user-wide FNF token. Existing WebSockets stay open; reconnect requires a new single-use ticket. No generation is started by this tool.
create_project
ChatGPTCreate a private Higgsfield media project for this conversation. Create only on an explicit user request or when get_preferences returns auto_create_project=true and this conversation has no destination. The default is no automatic project. An explicit existing destination or request to work without a project wins. Creating a project does not change the saved preference. Call once, then retain project_id, workspace_id and default_folder_id in this conversation and pass folder_id on subsequent generate_* calls. Reuse the existing project on later turns; never create one per generation or reuse another conversation's project. This does not create a chat, website or 3D scene. No starter/brief subfolder is created. Resolve workspace_id before the first call using list_workspaces (full) or workspace_list (OpenAI); use the selected workspace or ask the user when ambiguous. Repeat an uncertain request only with the original workspace_id, name, surface and idempotency_key, even if the selected workspace changes; backend replay lasts 15 minutes, not the lifetime of the chat.
create_reference_element
ChatGPTCreate one reusable character, environment or prop in the selected workspace from confirmed images. Upload first via media_upload_and_confirm. Omit name to derive it from media; category defaults to auto. Returns the created element and refreshes the gallery. USAGE IN GENERATION (implementation detail): Embed <<<element_id>>> inside params.prompt of generate_image / generate_video. Backend auto-injects the image and rewrites to @element_name. Multiple placeholders per prompt OK. Example: "Cinematic portrait of <<<UUID>>> on a rooftop", "<<<A>>> handing coffee to <<<B>>> in a Paris cafe". SUPPORTED MODELS (params.model = machine name, friendly in parens): - Image: nano_banana_pro (Nano Banana Pro), nano_banana_2 (Nano Banana 2), gpt_image_2 (GPT Image 2), seedream_v4_5 (Seedream 4.5), seedream_v5_lite (Seedream 5.0 lite), cinematic_studio_2_5 (Cinema Studio Image 2.5). - Video: cinematic_studio_video_v2 (Cinema Studio Video 2), cinematic_studio_3_0 (Cinema Studio Video 3.0), seedance_2_0 (Seedance 2.0), kling3_0 (Kling 3.0 — REQUIRES a start_image in params.medias; element placeholder alone won't trigger reference usage). Map friendly names to model ids. Other models ignore the placeholder. USER-FACING STYLE: prefer friendly model names and element names for readability. GUARDS: - @name form does NOT work in tool calls — only <<<UUID>>> in params.prompt. - Do NOT put element ids in params.medias / params.input_images — placeholder handles injection. - kling3_0 only honors reference elements when an explicit start_image is provided in params.medias. If the user wants Kling 3.0 with an element but hasn't supplied a start frame, ask for one (upload via media_upload_and_confirm, or pick a prior generation) before calling generate_video. Without a start_image, pick another video model from the list. - Only status: completed elements are usable; skip processing / ip_checking / failed / kling_failed / nsfw.
create_website
ChatGPTStart a new full-stack website. Creates the website and a git repo: a React 19 + TanStack Start app, server-rendered, in ONE Cloudflare Worker, with D1 / R2 / KV / Durable Objects / Containers available (all DISABLED by default). Returns a website_id — pass it to every later website tool. The 'type' param is REQUIRED and is the USER'S choice, not yours: unless the user has already made it unambiguous, ASK the user whether they want a plain website (no Higgsfield integration) or a Higgsfield-integrated app (Sign in with Higgsfield + AI image/video generation via the Higgsfield SDK) BEFORE calling this tool. Apps are scaffolded from a v2 starter template and REQUIRE the 'template' param — pick the closest of studio / preset / app-detail per the template param's guide ('custom' is ONLY for when the user explicitly says "use custom template" — never pick it yourself). The chosen layout ships as real code already wired as the home page; you ADAPT IT IN PLACE, never rebuild it. Websites take an OPTIONAL template: pass 'scroll-scrub' for an animated website (its scrub engine ships pre-built) and omit it for a non-animated one. App and website templates are not interchangeable — a cross-kind name is rejected. Workflow: (0) use the installed website-builder skill and its bundled references FIRST to load the stack, design contract, and hard rules (REQUIRED before building or editing); (1) create_website; (2) call website_repo_access with checkout, edit/commit using sandbox_exec, then website_repo_access with push (for apps, read app/src/layouts/AGENTS.md + app/src/components/AGENTS.md right after cloning); (3) deploy_website to ship it live — and deploy again after ANY later change (publish_website only lists what is already live; it does not deploy).
delete_folder
ChatGPTDelete one folder with explicit confirm_delete=true. cascade defaults to false; folders with children may be rejected. Deleting placements does not physically delete their uploaded sources. Do not retry uncertain outcomes automatically.
delete_project
ChatGPTPermanently delete one project and cascade through its contents. Requires explicit user authorization and confirm_delete=true. Do not automatically retry an uncertain outcome; inspect the project first. Underlying uploaded sources are not promised to be physically purged.
deploy_website
ChatGPTBuild and deploy the website via CI, then return its live URL. Every deploy ships the live site at the website's public URL (there is no separate preview stage). IMPORTANT: commit and git push ALL your changes BEFORE calling this — the build runs from the pushed repo. Deploy again after ANY later change: publish_website does NOT deploy (it only lists the already-live build on the community feed), so this tool is the only way changes ship. A failed build returns the log; a still-running build returns status 'pending' — call website_status to check.
estimate_image_cost
ChatGPTEstimate image generation credit cost without submitting a job. HTTPS image references are fetched, uploaded, and confirmed in your Higgsfield media library; repeated calls can create new uploads. Requires write access. Takes the same params object as generate_image: params.model is required; prompt may be omitted for a cost-only estimate.
estimate_video_cost
ChatGPTEstimate video generation credit cost without submitting a job. HTTPS image references are fetched, uploaded, and confirmed in your Higgsfield media library; repeated calls can create new uploads. Requires write access. Takes the same params object as generate_video: params.model is required; prompt and duration may be omitted (model defaults apply). For a Genjutsu recreation, preserve supplied reference images with role image and the confirmed driving/source video with role video in params.medias. Copying actions or camera movement uses hf_mult_motion_control; replacing a subject uses hf_mult_replace_object. A video-only price quote does not establish that all inputs for the requested recreation are ready. For custom follow-ups to a Genjutsu catalog video, resolve get_preset_instructions({preset:"genjutsu"}) before preflight; the current request determines the model, not the catalog recipe. Price-only requests may omit reference images and must respect any no-upload instruction. Preparing a complete request requires the supplied images and one confirmed video; ask about conflicting upload instructions. Read input_check for missing roles and reuse prepared_params with resolved UUIDs. A successful quote never validates generation readiness.
execute_preset
ChatGPTRequest execution of one published preset from the Viral, Marketing Studio or Genjutsu gallery, including a Genjutsu Style (genjutsu-style: preset_id) that restyles the user's own video. A bare preset slash command or a request to open, preview, or browse a preset only opens its widget. For supplied attachments, use input_schema from get_preset_instructions to map and upload the relevant files before opening any widget. Call get_presets exactly once with source, preset_id and initial_inputs in the exact schema fields. Do not call get_presets just to inspect the schema. Leave omitted settings to schema defaults; never reopen the detail merely to repeat default selections. Never assume one photo satisfies all requirements or guess ambiguous slot assignments. Leave missing fields in the prefilled widget for the user. Stop after opening the detail and let the user interact with it. Do not call execute_preset unless the user explicitly asks to generate, or submits with Recreate in the widget. Check execution.readiness for the supplied inputs before execution; collect missing or invalid fields instead of submitting. execution.available indicates capability, not permission; optional inputs and built-in media do not authorize generation. Readiness checks input structure, not media ownership or upload confirmation; use only confirmed media IDs. If the widget reports submitted job IDs, display and wait for those jobs without executing again. Check execution.available in the preset detail before calling. Unavailable execution returns an error without submitting a job. Use get_presets to obtain the published preset_id and source; do not invent either value. A successful submission returns final job_ids; a preset may produce multiple outputs. Use job_display for one job, jobs_wait and show_generation_by_ids for multiple jobs. Preset-specific inputs are a free-form object; their requirements are defined by the selected preset, not by this tool schema.
generate_audio
ChatGPTGenerate speech/voice audio (text-to-speech). A successful submission returns job IDs; cost preflight and unlim_choice submit no job. Call it directly with the default model seed_audio (Seed Audio 1.0 by ByteDance) unless the user or an active skill requires a different engine. seed_audio needs an exact voice_id + voice_type pair ('preset' for a built-in voice, 'element' for one of the user's own). If either value is missing, call list_voices as the only tool in that turn so the user can choose. The picker returns the selected pair in a new user turn; continue the pending narration immediately with this tool using that pair. Never invent a voice_id. Optional tuning: format, sample_rate, speech_rate (-50..100), loudness_rate (-50..100), pitch_rate (-12..12). To use a specific named engine instead, set model:'text2speech_v2' and pass variant (one of elevenlabs|minimax|seed_speech|vibe_voice|cozy_voice) together with voice_type + voice_id. Use models_get / models_search to inspect a model's parameters. This tool only generates speech: it cannot generate music or sound effects — decline general music or sound-effect requests rather than substituting a speech model. All arguments go inside the single params object; params.model and params.prompt are required. get_cost:true returns the credit cost without submitting a job. This tool already displays its submitted jobs in an auto-updating generation widget, including while pending or in progress. Do not follow it with job_display, show_generations, or show_generation_by_ids merely to show or refresh the same results, before or after completion. To await completion, use jobs_wait with timeout_seconds <= 15; it does not open another widget. Use a separate display only when the user explicitly requests one or the workflow requires a distinct preview or approval. Headless generate_*_batch and execute_preset workflows follow their own display instructions. Submitted audio requests can send text and reference inputs to external audio model providers through Higgsfield and consume credits. On a transport timeout the submission outcome may be unknown: do not automatically resubmit. Reuse returned job IDs and retry only after the original outcome is known.
generate_audio_batch
ChatGPTSubmit 1-6 independent audio generations in parallel without opening a widget. Requests can send text and reference inputs to external audio model providers through Higgsfield and consume credits. Each requests[] item accepts generation params with count fixed to 1 and no get_cost, creates one job on successful submission, and keeps its caller-provided index in the response. Use for multiple distinct prompts or inputs; use generate_audio for one user-facing generation. Poll returned job IDs with jobs_wait in agent-chosen groups of at most 8. For larger sets, collect indexed jobs across submission batches. After every job in the user's set is terminal, pass the collected jobs to exactly one show_generation_by_ids call for up to 24 jobs; never use show_generations or call job_display once per job. A partial failure or timeout does not make the whole batch safe to retry: keep returned job IDs and resolve unknown submission outcomes before retrying affected items.
generate_image
ChatGPTGenerate an image. A successful submission returns job IDs; a choice or rejected request submits no job. For credit preflight use estimate_image_cost first; HTTPS image references are imported into your media library. Call this directly as the first tool call of the turn with the default model gpt_image_2_5 for ordinary generation, photorealistic images, typography, and reference-based editing. Consult models_recommend, models_search, models_list, or models_get only when the user asks to pick or compare models, or you need aspect_ratios, parameters, or medias[].roles for reference inputs. Reference media can be uploaded media UUIDs from media_upload_and_confirm, completed generation job UUIDs, or authorized HTTPS image URLs such as user-provided file download URLs; the server imports HTTPS images into Higgsfield and confirms them automatically. For a specific already-trained Soul character, first call soul_list with the matching type and status='ready', then pass its returned soul_id with the matching Soul model. Reference Element IDs are not Soul IDs. If the required character cannot be resolved or generation rejects it, stop; never omit soul_id or substitute another identity without the user's agreement. For other character/avatar requests use image generation directly; there is no reusable character-training flow here. All arguments go inside the single params object — params.model is required, params.prompt holds the text description, and model-specific parameters are additional keys of params. Server returns adjustments for fallbacks; invalid declared-param values return a structured error. This tool already displays its submitted jobs in an auto-updating generation widget, including while pending or in progress. Do not follow it with job_display, show_generations, or show_generation_by_ids merely to show or refresh the same results, before or after completion. To await completion, use jobs_wait with timeout_seconds <= 15; it does not open another widget. Use a separate display only when the user explicitly requests one or the workflow requires a distinct preview or approval. Headless generate_*_batch and execute_preset workflows follow their own display instructions. On a transport timeout the submission outcome may be unknown: do not automatically resubmit. Reuse returned job IDs and retry only after the original outcome is known.
generate_image_batch
ChatGPTSubmit 1-6 independent image generations in parallel without opening a widget. Each requests[] item accepts generation params with count fixed to 1 and no get_cost, creates one job on successful submission, and keeps its caller-provided index in the response. Use for multiple distinct prompts or inputs; use generate_image for one user-facing generation. Poll returned job IDs with jobs_wait in agent-chosen groups of at most 8. For larger sets, collect indexed jobs across submission batches. After every job in the user's set is terminal, pass the collected jobs to exactly one show_generation_by_ids call for up to 24 jobs; never use show_generations or call job_display once per job. A partial failure or timeout does not make the whole batch safe to retry: keep returned job IDs and resolve unknown submission outcomes before retrying affected items.
generate_video
ChatGPTGenerate a video; this submits a job. For credit preflight use estimate_video_cost; HTTPS image references are imported into your media library. GENJUTSU TRIGGERS: route Higgsfield Genjutsu by intent. Copy, repeat, reproduce, mimic, or transfer motion, movement, actions, gestures, dance, or camera motion from one driving video to reference-image subjects -> hf_mult_motion_control. Replace, change, or swap an object, product, garment, or character in one source video from reference images -> hf_mult_replace_object. These are direct generate_video models; reserve ad-multiplier for explicitly requested independent edited variants. Pass images with role image and exactly one source/driving video with role video. For an explicitly selected /ad-multiplier workflow, follow its resolved instructions before generating. Ordinary requests to multiply an ad do not select that workflow: offer /ad-multiplier instead of silently starting its multi-stage pipeline. Defaults: seedance_2_5 for general video, kling3_0 for multi-shot, audio, or motion transfer, and minimax_h3 for 2K keyframes or mixed references. Call model discovery only to compare models or inspect parameters/media roles. References may be uploaded media UUIDs, completed job UUIDs, or authorized HTTPS image URLs. For image-to-video use the model's image role, usually start_image or image, not video. Use Marketing Studio product tools for product IDs and list hooks/settings before using their IDs. Put everything in params; params.model is required and params.prompt contains the brief. Apply returned adjustments; invalid values return a structured error. FREE GENJUTSU RUN: balance / models_list report free_gens; when the user asks to use a free generation on a Genjutsu model, pass use_free_gens:true (480p/720p, one output) — it is refused, never billed, when it does not apply. This tool already displays its submitted jobs in an auto-updating generation widget, including while pending or in progress. Do not follow it with job_display, show_generations, or show_generation_by_ids merely to show or refresh the same results, before or after completion. To await completion, use jobs_wait with timeout_seconds <= 15; it does not open another widget. Use a separate display only when the user explicitly requests one or the workflow requires a distinct preview or approval. Headless generate_*_batch and execute_preset workflows follow their own display instructions. On a transport timeout the submission outcome may be unknown: do not automatically resubmit. Reuse returned job IDs and retry only after the original outcome is known.
generate_video_batch
ChatGPTSubmit 1-6 independent video generations in parallel without opening a widget. Each requests[] item accepts generation params with count fixed to 1 and no get_cost, creates one job on successful submission, and keeps its caller-provided index in the response. Use for multiple distinct prompts or inputs; use generate_video for one user-facing generation. Poll returned job IDs with jobs_wait in agent-chosen groups of at most 8. For larger sets, collect indexed jobs across submission batches. After every job in the user's set is terminal, pass the collected jobs to exactly one show_generation_by_ids call for up to 24 jobs; never use show_generations or call job_display once per job. A partial failure or timeout does not make the whole batch safe to retry: keep returned job IDs and resolve unknown submission outcomes before retrying affected items.
genjutsu_motion_library
ChatGPTLoad one page of Higgsfield Genjutsu Motion Library examples for the Genjutsu app.
genjutsu_restyle
ChatGPTGenjutsu Apply style for the Genjutsu app: list Higgsfield and custom styles, manage custom styles, quote and submit a Restyle of the source video.
genjutsu_upload
ChatGPTPrepare or confirm an image, video, audio or file chosen in the Higgsfield UI, including Genjutsu inputs and files dropped into composer references, or resolve a recreated source video's URL. Confirm only after its presigned PUT succeeds. Documents return file context and cannot be used as generation inputs.
get_account_overview
ChatGPTRetrieve the authenticated user's available free-trial offer and account URL for display in the app. Fetching the offer may create a checkout session, but does not start a trial or charge a payment method. Invoked only by the app.
get_faceless_channel_presets
ChatGPTShow the faceless channel presets (CMS-managed catalog). Returns preset ids, names, and preview media. When the user picks one, resolve it with resolve_faceless_channel_preset to get the style reference media_id for generations.
get_folder
ChatGPTRead exactly one existing folder_id inside project_id. Does not list children or create a folder.
get_katana_preset_submission
ChatGPTCheck whether the authenticated user has submitted an uploaded video as a Katana community preset in their selected workspace. Returns the saved receipt, prompt and reference IDs, or submitted=false when no submission exists. Submission does not imply delivery, approval or public availability. Invoked only by the app.
get_preferences
ChatGPTRead the user's saved MCP project preference before the first generation in a conversation without a destination. auto_create_project defaults to false: omit folder_id and generate without creating a project. When true, create one project on first generation and reuse its destination for this conversation. An explicit existing project or request to work without a project takes priority. A one-off request to create a project is allowed regardless of this flag and does not change it. Never infer another chat's destination. If reading fails, do not auto-create a project.
get_preset_instructions
ChatGPTResolve a named Higgsfield preset or command and read its instructions without executing it. For every Katana preset run, read all instruction parts and collect required inputs, then call get_katana_config to register the session, whether the run is paid or free. Set free_generation: false for a paid run, or true only when the user explicitly requests a free run. Forward its preset_session_id in every generation, cost estimate and batch item. Add use_free_gens: true only when the user explicitly asks for free generations. Reading instructions, browsing or asking about free balance alone must not create a session. Entries include image/video recipes, explicit-only production commands /ugc-video, /faceless-video and /ad-multiplier (OpenAI), generation workflows such as /genjutsu, and setup instructions such as /use-after-effects and /use-blender. For an explicit slash invocation, resolve the exact token before selecting tools or requesting media. Katana presets resolve by /slug or explicit /katana/slug to the shared Katana workflow with their published reference video and optional CMS creative context, and bare /katana returns general Katana instructions (inspect attachments, edit source media to the user's brief, faithfully remake an explicit reference, or open the Katana catalog when nothing is supplied); for a /katana/ message with a MEDIA block, pass its entries as media to receive their file URLs. Omit preset to list recipes, commands and published Katana titles/descriptions without opening a widget. To choose a Katana preset by style or theme, match this metadata and then load its exact /katana/slug; do not use get_presets for internal Katana discovery. Use get_presets for Viral and Marketing Studio browsing (/effects, /product, /motion); a resolved gallery entry supplies its input schema and exact detail lookup. Recipes such as /hero-shot and /reel-cover supply their generation workflow. Setup commands and their references supply instructions for the required runtime; loading them does not install software, connect an editor, or submit jobs. Unqualified unknown tokens return mode instructions with instructions_markdown in structuredContent: infer the task and use ordinary generation tools instead of searching the gallery or stopping at an offer. An unavailable /katana/slug must stop without substituting another preset.
get_presets
ChatGPTSearch and browse reusable image and video generation presets from Higgsfield's Viral, Marketing Studio, Genjutsu and Katana galleries, or retrieve a preset's inputs and preview without starting a generation. For sources other than Katana: A bare preset slash command or a request to open, preview, or browse a preset only opens its widget. For supplied attachments, use input_schema from get_preset_instructions to map and upload the relevant files before opening any widget. Call get_presets exactly once with source, preset_id and initial_inputs in the exact schema fields. Do not call get_presets just to inspect the schema. Leave omitted settings to schema defaults; never reopen the detail merely to repeat default selections. Never assume one photo satisfies all requirements or guess ambiguous slot assignments. Leave missing fields in the prefilled widget for the user. Stop after opening the detail and let the user interact with it. Do not call execute_preset unless the user explicitly asks to generate, or submits with Recreate in the widget. Check execution.readiness for the supplied inputs before execution; collect missing or invalid fields instead of submitting. execution.available indicates capability, not permission; optional inputs and built-in media do not authorize generation. Readiness checks input structure, not media ownership or upload confirmation; use only confirmed media IDs. If the widget reports submitted job IDs, display and wait for those jobs without executing again. For sources other than Katana, pass query to search preset names, descriptions and types before pagination. All query words must match; omit source to search Viral and Marketing Studio. Pass preset_id to open a published preset detail preview directly. Omit source to browse Viral and Marketing Studio; limit applies to the complete page. source='genjutsu' lists Genjutsu motion presets, with category='genjutsu', 'genjutsu-trending' or 'genjutsu-new'; a bare /genjutsu opens this gallery. To choose motion for an existing AI Influencer, pass initial_inputs:{character_sheet:[{id:"<confirmed sheet job UUID>",type:"image_job"}]} — character_sheet must be a one-item array, not a single object; legacy source='marketing_studio' still accepts these categories and genjutsu: IDs. category='genjutsu-styles' lists Genjutsu Styles: named looks (e.g. Knitted Yarn World, Rounded Toy CGI) that redraw the user's own video while keeping its motion. When the user names a look, search it with query; preset_id 'genjutsu-style:<id>' opens its form, and initial_inputs {video:[<confirmed video UUID>], references?, resolution} adds readiness and price. source='viral' lists Viral Hub chain presets for /effects requests; source='marketing_studio' lists Marketing Studio templates: for /product use category='product-shot', for /motion use category='motion'. source='katana' is a user-facing catalog, not headless search: query and initial_inputs are unsupported. preset_id:'<slug>' opens one Katana preset's input form directly; use it only as the loaded /katana/slug instructions direct, when the user asked to run that preset and its inputs are missing. To find or choose a Katana preset for a task, call get_preset_instructions with preset omitted, match the returned titles/descriptions, then load its exact /katana/slug. Do not open this gallery merely to choose a preset for supplied media. Explicit catalog browsing opens the Katana catalog without default filters; category supports personalized_edits, style_transfer and motion_transfer, katana_source supports community or higgsfield. Katana uses opaque string cursors and backend-default page sizes (explicit limit maximum 20). Recreate selections resolve exact /katana/slug instructions with get_preset_instructions. Katana browsing does not execute a preset. Use category slugs returned by this tool and pass next_cursor only when the user asks for another page.
get_profile
ChatGPTReturn the Higgsfield account represented by this connection's authenticated credentials. Reads optional display labels from the configured Clerk OAuth UserInfo service using the caller's token. The opaque id stays the same across token refresh, reconnection, scope upgrades, and changes to email or selected workspace. Does not select or switch accounts.
get_project
ChatGPTRead metadata and current capabilities for one existing project root by ID. Returns only shared project metadata and access capabilities; it does not expose Supercomputer instructions, knowledge sources, connectors, or skills. Requires the project_id and an explicit workspace_id request context. Does not change workspace selection or chat destination.
get_project_asset_prompt
ChatGPTRead only the prompt details for one accessible placement_id in this project. Does not list other assets or read source download metadata.
get_project_asset_source
ChatGPTRead only source details for one accessible placement_id in this project. For confirmed files includes download URL and file metadata. Does not generate or upload media or return prompt details.
get_project_publication
ChatGPTRead current Cinema publication settings, effective prompts/canvas/discovery visibility, snapshot and moderation state without changing anything. Show the user current settings, content exposure and flagged items before seeking host approval for a separate mutation. Backend visibility defaults are true; discovery disabled leaves a public link public. After an uncertain write this observes current state only, not a per-operation receipt. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
home_usecases
ChatGPTLoad the home page's use-case cards, prompts, and reference media.
job_display
ChatGPTShow one specific previous generation in a new single-result UI widget by job ID. This opens an additional widget; it does not refresh an existing one. Ordinary generate_image, generate_video, and generate_audio calls already display auto-updating widgets. Do not call this tool as their automatic follow-up, even while pending or in progress or after completion; use jobs_wait with timeout_seconds <= 15 to await completion without another widget. Use when the user wants to inspect or re-display that individual result, including workflows that require separate approval of named candidates or individual previews before finalization. Do not call job_display once per job merely to reproduce an ordinary completed batch; use one show_generation_by_ids call for ordinary batch results instead.
job_status
ChatGPTCheck the status and results of an async job. Returns instantly. For non-terminal jobs the response includes poll_after_seconds — wait that many seconds before calling again. Typical total times: image ~10-20s, video ~60-180s.
jobs_wait
ChatGPTLong-poll 1-8 generation jobs together without opening a widget. Waits up to timeout_seconds (default 15, max 15) for every job to reach a terminal state, then returns compact indexed statuses and result URLs. Use job IDs returned by generate_image_batch, generate_video_batch, or generate_audio_batch. For larger sets, choose groups of at most 8 and wait for each group. Permanent lookup failures are returned once without blocking the other jobs; transient lookup failures are retried within the timeout. When all_terminal is false, wait poll_after_seconds before calling again. After every wait group in the user's generation set is terminal, collect their indexed jobs and display them with one show_generation_by_ids call when within that tool's limit. Never use show_generations or call job_display once per batch job.
katana_compose_message
ChatGPTValidate a filled Katana preset form and return the chat message that starts the preset.
list_canvases
ChatGPTApp-only canvas browser. Lists existing canvases among the caller's accessible FNF folders; projects without a canvas are excluded. Uses FNF pagination order. Continue with cursor while has_more is true, even if items is empty; retain workspace_id, tab and search between pages. Does not create boards or issue tokens. Open a selected item with create_or_update_canvas_token using its room_id and workspace_id.
list_folders
ChatGPTList direct subfolders of a Higgsfield media project or an explicit parent_folder_id. Use a project_id from list_projects, create_project or the user. Search matches child names under that parent, not the entire tree. Returns folder_id values for subsequent generation destinations and the actual project workspace even for an empty page. Does not list local directories or create folders. Continue with cursor and the same original workspace, project, parent and search; use has_more, not item count, to detect completion.
list_project_assets
ChatGPTList generations and uploaded media/files placed in a Higgsfield media project, newest first. Omit folder_id for all accessible ordinary folders in the project; supply it for exactly that folder without descendants. Filter by source_types or output_kinds. Returns metadata and IDs, not prompts, playable URLs or previews. placement_id identifies the folder placement; item_id identifies the original job or upload. For type=job use item_id with job_status or job_display and pass the item's folder_id as folder context to inspect the generation, including shared folders. This is not the global generation gallery and does not generate media. Continue with cursor and the same original workspace, project, folder and filters; use has_more, not item count, to detect completion.
list_projects
ChatGPTList or find existing accessible Higgsfield media projects before choosing a generation destination. Returns project_id, default_folder_id and each project's actual workspace_id. Includes accessible shared projects across workspaces; workspace_id sets authenticated request context, not a filter. Does not list websites, 3D scenes or local directories and never creates a project. Read one page at a time; pass cursor with the same workspace and search to continue. An empty page with has_more=true is not the end.
list_voices
ChatGPTList available voices for speech and voice tools. Returns built-in preset voices plus the user's own custom voices. Each voice has a voice_id and a voice_type ('preset' or 'element'); pass that exact pair to the audio models (via generate_audio — seed_audio or text2speech_v2) and to the voice_change tool to select the speaking voice. Use the preview_url to hear a sample. Paginate with the returned next_cursor. Call this as the only tool in the turn when the voice pair is missing. The picker returns the selected pair in a new user turn so the pending narration can continue immediately.
list_website_categories
ChatGPTList the content categories a website can be filed under — each with a slug, label, description, and display position. create_website REQUIRES a category; call this first to get the valid slugs, then pass the closest one ('other' when nothing fits).
list_websites
ChatGPTList the websites you own — each with its id, name, slug, and live URL. Use this to find the id of a website you created earlier so you can edit, deploy, or check its status.
list_workspaces
ChatGPTRead-only list of every workspace the user can access. The is_selected field marks which workspace MCP operations currently target.
marketing_create_brand_kit
ChatGPTCreate a brand kit from user-provided brand data only. This does not scrape websites, fetch third-party URLs, or create checkout/purchase flows.
marketing_create_product_from_media
ChatGPTCreate a Marketing Studio product from user-provided uploaded media IDs and manual metadata. This does not scrape external websites or fetch third-party URLs.
marketing_delete_brand_kit
ChatGPTDelete an existing brand kit by id. This permanently removes that brand kit from Marketing Studio.
marketing_get_brand_kit
ChatGPTRead-only fetch of one existing brand kit by id. Does not create, update, delete, or scrape websites.
marketing_list_ad_formats
ChatGPTRead-only list of DTC Ads image ad-format presets. Does not create or modify image styles.
marketing_list_avatars
ChatGPTRead-only list of user and preset Marketing Studio avatars. Does not create or modify avatars.
marketing_list_brand_kits
ChatGPTRead-only list of Marketing Studio brand kits. Does not scrape websites, create kits, update kits, or delete kits.
marketing_list_hooks
ChatGPTRead-only list of existing Marketing Studio setup hooks. Use returned ids as hook_id in generate_video. Does not create, update, or delete hooks.
marketing_list_products
ChatGPTRead-only list of Marketing Studio products. Does not fetch websites, create products, or modify products.
marketing_list_settings
ChatGPTRead-only list of existing Marketing Studio setup settings. Use returned ids as setting_id in generate_video. Does not create, update, or delete settings.
marketing_list_video_presets
ChatGPTRead-only list of Marketing Studio video modes (formats) and their example presets. Each format has a slug (pass as generate_video params.mode) plus example presets carrying ready-to-reuse params. Let the user pick a format before generating — or choose the best fit yourself if they asked you to decide. Does not create or modify marketing assets.
marketing_list_webproducts
ChatGPTRead-only list of Marketing Studio webproducts. Does not fetch websites, create webproducts, or modify webproducts.
marketing_update_brand_kit
ChatGPTOverwrite an existing brand kit's data with the supplied complete brand kit payload. This replaces the previous brand-kit data wholesale.
media_confirm
ChatGPTConfirm file uploads after using media_upload's upload_url method. Call this only after every curl PUT returned HTTP 200. Supports confirming multiple uploads at once via media_ids. OpenAI routing: use this for sandbox-created files uploaded through media_upload + sandbox_exec. Do not call it after media_upload_and_confirm; ChatGPT attachments handled by that tool are already confirmed.
media_upload
ChatGPTUpload media for use in generation, or general files (documents, archives, code) for sharing. Returns presigned URLs for clients that can upload bytes themselves; run the generated curl commands or PUT the bytes to each upload_url, then call media_confirm. The media type is inferred from the filename extension: image/video/audio extensions become generation inputs; other whitelisted extensions (pdf, zip, tar, docx, csv, code files, …) are uploaded as general files and return a permanent URL, but cannot be used as generation inputs. General files are the agent's own upload path — the widget does not accept them, so upload the bytes to upload_url yourself (e.g. from a code execution environment). Supports batch uploads via files[]. OpenAI routing: use this only for files created inside sandbox_exec. Call media_upload BEFORE the sandbox command that creates the file, then append curl -f -X PUT --upload-file <sandbox-path> '<upload_url>' to that SAME command so the ephemeral file is uploaded before it exits; call media_confirm only after HTTP 200. For a user-provided ChatGPT attachment call media_upload_and_confirm instead. Never pass a sandbox path to media_upload_and_confirm.
media_upload_and_confirm
ChatGPTOpenAI attachment-only upload helper. Use this only for a user-provided ChatGPT attachment passed in the file parameter, one attachment per call. This tool downloads the OpenAI file, creates a Higgsfield upload slot, uploads bytes to storage, confirms the upload, and returns a media_id ready for downstream tools. It cannot read a path created inside sandbox_exec: for a sandbox output, call media_upload before the producing command, PUT the file from that same command, then call media_confirm after HTTP 200. Use type 'file' for general attachments (documents, archives, code); those return a permanent URL but cannot be used as generation inputs. Do not call media_confirm after media_upload_and_confirm. Max file size: 100 MiB.
models_get
ChatGPTRead-only fetch of one generation model's constraints, parameters, media roles, aspect ratios, and durations.
models_list
ChatGPTRead-only list of available image, video, audio and 3D generation models. Does not create generation jobs. The top-level free_gens block lists the free generations the caller holds (Higgsfield Genjutsu launch grant) — answer "what free generations do I have" from it; items that can spend one carry supports_free_gens.
models_recommend
ChatGPTRead-only recommendation of generation models for a concrete user goal and input context.
models_search
ChatGPTRead-only search across available generation models by id, description, provider, and tags.
move_folder
ChatGPTMove one folder under target_parent_id inside the same project. Backend checks membership and cycles. Inspect the folder after an uncertain outcome before retrying.
move_project_asset
ChatGPTMove an existing placement_id to target_folder_id, optionally in target_project_id. Does not duplicate the source. Inspect assets after an uncertain receipt before retrying.
open_ads_studio
ChatGPTOpen the Higgsfield Ads Studio page inside the Higgsfield app: brands and ad generations.
open_ai_influencer
ChatGPTOpen the main Higgsfield AI Influencer Builder. For a bare 'ai influencer' request, open the builder immediately: the user chooses the design inside the UI, so no brief or clarification is needed before opening. Also use for the OpenAI /build-ai-influencer entrypoint, or when the user asks to open the builder UI. If current user or host context explicitly says the builder is already open, continue in chat without reopening unless requested. A previous open call does not establish current visibility. For creating described characters, multiple variants or a sheet directly in chat, use ai_influencer_prepare followed by ai_influencer_generate. Opens the existing builder directly, without generating a character sheet or video. Do not use for questions asking only to explain AI influencers.
open_canvas
ChatGPTShow a canvas board to the user in the Higgsfield app. Pass room_id (or the canvas URL) to open that board live: changes made with canvas_add, canvas_update or canvas_remove, and canvas_run results, appear in it as they happen, and the user can select items to give you context. Call it once per board; do not call it again to refresh after edits or runs. Without room_id it shows the user's boards. Does not change the board.
open_genjutsu
ChatGPTOpen the Higgsfield Genjutsu page inside the Higgsfield app: Motion Library examples, video history, and how it works.
open_home
ChatGPTOpen the Higgsfield app from its home screen. Call once when a tool result requests Home onboarding, unless Home was already opened in this conversation or the user asks to keep the app closed, then continue their original request. Records this call for the authenticated account across conversations; it does not track current app visibility. Explicit requests to open Home remain allowed.
open_soul_feed
ChatGPTOpen the generation feed inside the Higgsfield app.
open_visual_effects
ChatGPTOpen the Visual Effects catalog in the app to browse effect presets. Opening the catalog does not submit a generation or spend credits.
participate_in_contest
ChatGPTEnter the website in the current Higgsfield app contest, together with the social-media links promoting it. A website not yet PUBLISHED to the community feed is published automatically by the entry — no need to call publish_website first. The website DOES need a live production deploy (deploy_website), else the entry is rejected. BEFORE entering, make sure the page metadata in app/src/app-meta.json is filled with real values (og_title etc.) — the auto-publish lists the website on the feed and an empty og_title makes it INVISIBLE there. Pass one or more urls, each a social-media link (YouTube, X/Twitter, Instagram, or TikTok); any other host is rejected. There is a single active contest, so no contest id is needed. Calling again for the same website OVERWRITES its urls (use it to fix or add links), it does not create a second entry.
prepare_generation
ChatGPTRead a source generation's original model and complete parameters for the app's Recreate context. Prepares settings for the next user request; does not submit or generate anything.
project_camera_media
ChatGPTSave a confirmed camera recording or shot to its project, or resolve an accessible uploaded draft for playback. Does not generate media.
project_metadata
ChatGPTApp-only project header. Read an accessible project's name and rename capability, or explicitly rename that same project. Changes only its name; no scene edits or media generation.
publish_katana_preset
ChatGPTSubmit an uploaded video as a Katana community preset for the authenticated user in their selected workspace, optionally including the original prompt and up to ten uploaded image or video references. Returns a submission receipt; acceptance does not mean the preset is publicly available. Invoked only by the app. Identical submissions reuse their receipt; changed details for an already submitted video are rejected.
publish_project
ChatGPTSave supplied Cinema metadata and request publication through the existing writer, which may capture current working content asynchronously. Before invocation obtain explicit user publication consent AND confirmation of content rights/permission. Disclose current content exposure and the three explicit visibility settings; discovery disabled leaves a public link public. This is not bound to a prior preview. A flagged review requires a separate user decision; never automatically confirm. Obtain explicit user approval through the MCP host before invoking this tool. The host owns its approval policy; the server cannot independently verify a human decision. Do not invoke based only on inferred intent. After an uncertain response, stop and read get_project_publication to observe current state. There is no per-operation receipt or automatic replay guarantee; do not blindly repeat a publication mutation. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
publish_website
ChatGPTPublish the website: lists the website's CURRENT LIVE production deploy on the Higgsfield community feed ('show in feed'), where other users can discover it. This does NOT deploy — deploy_website (which every build flow already runs) must have shipped the latest changes first; publishing with undeployed changes lists the OLD live build, and re-publishing does not re-deploy. BEFORE publishing, the page metadata in app/src/app-meta.json MUST be filled with real values — og_title, og_description, favicon_url, og_image_url — the feed card renders from them (read fresh from the pushed repo at publish time) and a website with an empty og_title is INVISIBLE on the feed; the live page's own head tags are baked at build time, so deploy AFTER changing them. Also OFFER the user a cover video for the card (og_video_url) — ask their permission first (video generation costs credits), never generate it unprompted. Commit and git push the metadata (and all other changes), then deploy, BEFORE calling this. Publish when the user asks to publish / share / go live on the feed, OR when they opted in to publishing at the start of the build — in that case publish automatically once the site is deployed with its metadata filled, without waiting to be asked again. For a plain deploy without a feed listing use deploy_website instead. EXCEPTION: a website whose production was never deployed (or was taken down by unpublish) falls back to deploying first — that returns status 'pending' while CI runs and the website is listed automatically once the deploy succeeds (check with website_status).
register_katana_result
ChatGPTSave one verified final video from a named Katana preset as a completed job in the selected workspace. Pass preset_id and the confirmed final video media_id, the run preset_session_id from get_katana_config, and optionally folder_id. The final job set is added to that session, including when the session is already closed. This links the existing video without copying files, generating, charging generation credits or publishing to the community. Keep media_upload → PUT → media_confirm for local/sandbox exports; if the final video is already confirmed, reuse its media_id. Never pass URLs, local paths, job IDs, drafts, references or comparison videos. On timeout repeat the same inputs and media_id; one video can register one result. Do not regenerate or reupload to retry. A completed response contains job_id for show_generation_by_ids.
remove_project_asset
ChatGPTRemove only this placement_id from the project. Requires confirm_remove=true and explicit user authorization. Does not delete or physically purge the underlying uploaded file or job. Do not retry uncertain outcomes automatically.
rename_folder
ChatGPTRename one folder inside this project. Does not move or delete its contents.
rename_website
ChatGPTRename the website's SUBDOMAIN (the slug in its public URL). The site is re-deployed under the new subdomain and the OLD subdomain STOPS WORKING — anyone holding the old URL must be given the new one. Storage (database, files, config) and the code repo are KEPT; only the public address changes. Runs a full re-deploy and can take a couple of minutes; returns once the site is live at the new URL. Fails if the new subdomain is already taken or reserved, or if a deploy is already in flight — pick another subdomain and retry.
reset_balance
ChatGPTINTERNAL — claim the displayed reset ONLY after the user clicks Reset balance in the widget. Pass the exact scope and workspace_id from that offer. Never call this tool from the assistant or automatically retry a claim. After a conflict or uncertain result, refresh availability through the widget before another explicit claim.
resolve_faceless_channel_preset
ChatGPTResolve a faceless channel preset (from get_faceless_channel_presets) into a style reference media_id: the backend imports the preset's style image into the user's media storage. Pass the returned media_id as the style reference image in generation calls for every scene of the explainer.
resolve_project_assets
ChatGPTLocate existing project placements for typed sources [{type,id}]. Source ID means the original job/upload ID, not placement_id. Optionally limit to one exact folder. Continue cursor with the same workspace, project, folder and sources; empty items with has_more=true is not completion.
reveal_generation
ChatGPTConfirm the user has rights to the content of an ip_detected generation and flip its status to completed. Backend accepts only seedance-family jobs (cs_3_0, seedance_2_0, ms_video, etc) and only while the job is still in ip_detected state. Returns the updated generation. Used by the job-list widget's Reveal button after the user accepts the rights confirmation modal.
sandbox_exec
ChatGPTExecute a shell command in a remote Higgsfield cloud Linux sandbox — NOT your local machine or the client's own shell. Use it for Higgsfield media workflows and website_repo_access checkouts that require the hosted toolchain. Do not use it to inspect a local repository, install desktop software, or control applications on the user's computer. Preinstalled: ffmpeg/ffprobe, ImageMagick, sox, python3 with Pillow and faster-whisper, node/npm/npx, sharp-cli, Playwright with headless Chromium, caption fonts (Metropolis, Montserrat), zip/unzip, git, curl, jq. Use it for media processing (trim, convert, overlay, concat with ffmpeg), image manipulation, and packaging that dedicated Higgsfield tools do not cover. The sandbox is isolated per user. Existing sessions keep their assigned backend. E2B pauses with process memory; Modal preserves workspace files but not processes or RAM after replacement. Export important files within 24 hours of last use. A result with sandbox_created:true indicates a new sandbox, so files from earlier calls are not present; re-download missing inputs. It has internet access: bring files in with curl from media URLs (media_import_url or generation results). For an output created here, call media_upload BEFORE starting the producing command, then append curl -f -X PUT --upload-file <file> '<upload_url>' to that SAME command so the ephemeral file is uploaded before it exits; call media_confirm only after HTTP 200. Never pass a sandbox path to media_upload_and_confirm: that tool accepts only client attachments. Commands run in /home/user and time out after timeout_seconds (default 60, max 120); for longer work (large renders, installs) set background:true and poll the returned log/status files with later sandbox_exec calls. Background work is bounded to 15 minutes; follow the lifetime and polling guidance in the command result. Set restart:true to discard the sandbox and start clean. For actual visual inspection, pass image_paths (up to 4 PNG/JPEG paths, <=512 KiB total) with a foreground command: images are returned natively to the model, not as text or URLs. With background work, wait for completion then use a foreground poll with image_paths before its lease expires. No upload is needed for inspection. The command limit is 128000 characters including signed URLs; keep upload batches small and use installed scripts. Workflow bundle scripts are already installed in every sandbox under $HF_WORKFLOWS (/home/user/.higgsfield/workflows), laid out as $HF_WORKFLOWS/<workflow>/scripts/... — run them straight from there (they survive restart:true), and never paste script contents into the command.
save_project_publication_preview
ChatGPTSave publication metadata and prepare Cinema preview data. This does not open a rendered preview; only report a link if one is actually returned. This is a MUTATION and may immediately change existing public metadata. First read current settings and disclose the effective resulting prompts/canvas/discovery visibility for user approval. A published project returns its current snapshot, not a private frozen republish draft. Obtain explicit user approval through the MCP host before invoking this tool. The host owns its approval policy; the server cannot independently verify a human decision. Do not invoke based only on inferred intent. After an uncertain response, stop and read get_project_publication to observe current state. There is no per-operation receipt or automatic replay guarantee; do not blindly repeat a publication mutation. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
scene_builder_3d_apply_scene_operations
ChatGPTSubmit a batch of viewport edits with stable operation IDs and inspected scene/entity versions. Widget-only. Acceptance precedes GLB checkpointing. On a conflict or uncertain submission, reconcile through scene_builder_3d_get_collaboration before retrying; never blindly repeat edits under new IDs.
scene_builder_3d_create_project
ChatGPTCreate a new private 3D Jutsu project for the authenticated user. Supply a descriptive name; the service assigns ownership and the project ID. Use this when the user requests a new project or a new standalone scene. For an existing scene, use scene_builder_3d_list_projects instead. Pass the returned projectId explicitly to subsequent tools; creation does not set a global active project. Call scene_builder_3d_get_project, then scene_builder_3d_query_python to inspect the initial scene and obtain guards before scene_builder_3d_run_python or scene_builder_3d_import_asset. Creation alone does not produce a committed GLB: scene_builder_3d_show_scene becomes available after the first successful edit or import. This call is not idempotent. If the response is interrupted or uncertain, use scene_builder_3d_list_projects to find the new project before retrying; repeating creation can create a duplicate. Before building or editing a scene, load get_preset_instructions with { preset: "/3d-jutsu" } once for the full workflow, runtime limits and scene-building references.
scene_builder_3d_generate_angles
ChatGPTGenerate an AI image from a rendered 3D Jutsu scene using 3d_jutsu_angles (Seedream V5 Pro pricing). This spends credits. First render and inspect an image with scene_builder_3d_query_python and scene_builder_3d_get_artifact. Supply that operationId/artifactId; optionally include referenceMediaId for an accessible uploaded photo or uploaded first video frame alongside the scene render. The Runner records the immutable references and shared project history. The scene itself is unchanged. After submission, use scene_builder_3d_get_generation. If the response is lost, look up generationId=requestId or repeat exactly the same requestId and arguments, including the reference; never allocate a fresh ID just to retry. Use a new UUID only for an intentional additional generation.
scene_builder_3d_generate_video
ChatGPTGenerate a paid Seedance 2.5 video in a 3D Jutsu project. Use a prompt alone (t2v), medias with image/start_image/end_image/video/audio roles (omni_reference), one video for video_edit, or videos plus extensionMode for video_extension. References use data:{id,type} from accessible FNF uploads or prior jobs, never URLs. Supports up to 30 images, 10 videos, 10 audio clips, 50 total. Optionally supply operationId/artifactId together to use a published Blender render as start_image; it counts toward the limits and cannot coexist with another start_image or non-omni mode. Omit mode to infer t2v or omni_reference. Supports bitrateMode, draft (480p) and draftJobId (1080p finalization, mutually exclusive with draft). Worker saves all inputs and shared project history. Preserve requestId and identical arguments on retry; poll scene_builder_3d_get_generation. Never allocate a new ID to recover an uncertain submission.
scene_builder_3d_get_artifact
ChatGPTResolve a short-lived download for an image or video that a successful Python operation published through artifacts. Use the artifact ID and operation ID or revision returned by that operation; do not invent IDs or filesystem paths. Query artifacts can be operation-scoped without a new committed revision. This retrieves an existing artifact and does not render one. To create a preview, render and publish it with scene_builder_3d_query_python or scene_builder_3d_run_python. Inspect the returned image using the client's image capability before judging framing, lighting, materials, and geometry. If the client cannot inspect it, describe that limitation rather than claiming a visual check passed.
scene_builder_3d_get_blend
ChatGPTResolve a short-lived download for the current committed editable Blender file, or a specified historical revision. This retrieves the existing scene; it does not create a revision or render a preview. Settle any active mutation with scene_builder_3d_get_operation first when you need its result. Use scene_builder_3d_get_glb for portable model delivery and scene_builder_3d_get_artifact for published images or videos.
scene_builder_3d_get_collaboration
ChatGPTRead the 3D Jutsu editor snapshot, entity versions, World settings and journal after an optional sequence. Widget-only companion to scene_builder_3d_get_project; download the checkpoint with scene_builder_3d_get_glb.
scene_builder_3d_get_generation
ChatGPTRead a generation launched by scene_builder_3d_generate_angles or scene_builder_3d_generate_video. Poll while submitting/running. succeeded and failed are final; submission_unknown requires reconciliation, never an automatic new paid generation. Results contain FNF job IDs and image/video URLs. Do not claim success before succeeded or claim visual quality without inspecting the image.
scene_builder_3d_get_glb
ChatGPTFor an interactive scene preview use scene_builder_3d_show_scene. Resolve a short-lived download for the current committed GLB, or a specified historical revision. This retrieves an existing export; it does not run Blender, render, or create a new export. Settle any active mutation with scene_builder_3d_get_operation first if you need its result. Use GLB for portable scene delivery, and scene_builder_3d_get_blend for the editable Blender source. Procedural shading, world lighting, and some Blender features may differ in GLB. A successful download does not establish that the exported scene looks correct.
scene_builder_3d_get_operation
ChatGPTRead or wait for a submitted Python operation in this project. Only succeeded, failed, timed_out, and expired are terminal; all other statuses require another poll using the same project and operation IDs. An HTTP success or a wait timeout does not mean the operation finished. Do not submit another mutation while one is active. On success, use the returned revision and scene sequence for subsequent work; obtain published images and videos through scene_builder_3d_get_artifact. On failure, inspect the error and re-read project state before deciding to retry. Do not blindly resubmit a failed operation under another ID. Finish each completed scene creation, edit, or import task by calling scene_builder_3d_show_scene once as the final scene inspection/edit call of that review phase, after mutations have settled and verification is complete. Pass the same projectId and the exact committed revision of the final result: revisionAfter from the final successful mutation, or the settled project.revision after an import. Do not guess the revision. Show an unchanged revision only once. Authorized generation and status calls may follow; later feedback or a verified mismatch can reopen scene editing. Verify and show the corrected revision at its next review boundary. This shows the result to the user; a text summary or download link alone does not finish scene delivery.
scene_builder_3d_get_project
ChatGPTRead a 3D Jutsu project's current revision, scene sequence, active operation, and committed artifacts. Obtain projectId from scene_builder_3d_list_projects, scene_builder_3d_create_project, or an explicit user selection. An authorized project with exists: false is a valid empty scene at revision 0. Use scene_builder_3d_query_python to inspect actual objects, dimensions, materials, cameras, and lights before editing. If an operation is active, use scene_builder_3d_get_operation to settle it before another mutation. Scene edits use scene_builder_3d_run_python with the exact revision and scene sequence inspected; never guess these guards. Before building or editing a scene, load get_preset_instructions with { preset: "/3d-jutsu" } once for the full workflow, runtime limits and scene-building references.
scene_builder_3d_get_scene_asset
ChatGPTResolve a signed GET for a scene asset referenced by an object.create.from_glb journal operation from scene_builder_3d_get_collaboration. Widget-only; use the asset ID, not a catalog ID or URL.
scene_builder_3d_import_asset
ChatGPTImport a confirmed catalog GLB from scene_builder_3d_search_assets into the selected project as a collaborative scene entity. Supply the catalog's asset ID, not a URL. The tool runtime resolves and uploads the bytes, reads the project guards, submits the import, and waits for it to appear in the settled scene. Do not import while another mutation is active. After import, inspect dimensions, placement, orientation, contact, and materials with scene_builder_3d_query_python before further edits. Do not repeat the whole import to poll: it can create a duplicate. If an import fails, report the error; never fall back to Python network calls or base64-encoded model bytes. Copy catalogSearch from the search result's importArguments. If settled is false, poll scene_builder_3d_get_project until appliedSceneSequence reaches targetSceneSequence. If submissionUnknown is true, inspect the returned entityId before deciding to retry. This version accepts catalog assets only. Finish each completed scene creation, edit, or import task by calling scene_builder_3d_show_scene once as the final scene inspection/edit call of that review phase, after mutations have settled and verification is complete. Pass the same projectId and the exact committed revision of the final result: revisionAfter from the final successful mutation, or the settled project.revision after an import. Do not guess the revision. Show an unchanged revision only once. Authorized generation and status calls may follow; later feedback or a verified mismatch can reopen scene editing. Verify and show the corrected revision at its next review boundary. This shows the result to the user; a text summary or download link alone does not finish scene delivery.
scene_builder_3d_list_generations
ChatGPTRead the shared image/video generation history of a 3D Jutsu project, newest accepted first. Includes pending and failed attempts. Pass nextCursor as before for older records; status changes never reorder records. Use scene_builder_3d_get_generation for an individual result.
scene_builder_3d_list_projects
ChatGPTDiscover the authenticated user's 3D Jutsu projects before choosing a scene to read or edit. Follow nextCursor to see more results. Use the selected project's id as projectId in every project-scoped 3D Jutsu tool; no call sets a global active project. Match the user's named project, and ask them to choose if the result is ambiguous. Then call scene_builder_3d_get_project for its current state. A project's presence here does not bypass permission checks on subsequent calls. To start a new project, use scene_builder_3d_create_project. Before building or editing a scene, load get_preset_instructions with { preset: "/3d-jutsu" } once for the full workflow, runtime limits and scene-building references.
scene_builder_3d_query_python
ChatGPTInspect the latest settled Blender scene without committing changes. bpy and the artifacts registry are available; assign concise JSON-serializable findings to result. Query exact names, metre-scale dimensions, transforms, parents, collections, materials, cameras, lights, visibility, and animation settings as needed. Inspect Blender RNA when an API or enum is uncertain. Temporary scene changes are discarded, including camera changes used for inspection. A query can render and publish images for visual inspection: allocate a target with artifacts.file(name="preview.png", media_type="image/png"), write the image to target.path, and call target.publish(). Resolve published IDs with scene_builder_3d_get_artifact. Use the successful query's revisionBefore and sceneSequenceAfter as the guards for the next scene_builder_3d_run_python call. If still active, poll scene_builder_3d_get_operation. Reuse an operation ID only to retry the identical request. Imported model bytes must enter through scene_builder_3d_import_asset; do not fetch URLs or embed file bytes in Python.
scene_builder_3d_run_python
ChatGPTCommit one coherent Blender scene edit against the exact revision and scene sequence you inspected with scene_builder_3d_get_project or scene_builder_3d_query_python. bpy and artifacts are available; assign JSON-serializable findings to result. Keep one mutation active per project, including imports. If this operation remains active, poll scene_builder_3d_get_operation before editing again. Reuse operationId only for the identical code and preconditions. On a stale-state conflict, inspect the scene again and regenerate the edit with fresh guards and a new operation ID. A successful mutation advances revisionAfter. This worker pins Blender 5.2: use BLENDER_EEVEE, BLENDER_WORKBENCH, or CYCLES, not BLENDER_EEVEE_NEXT. Code is capped at 256 KiB, and execution and checkpoint/export must fit the configured worker deadline; keep renders small and split expensive work into coherent edits. Do not invent texture paths or fetch external files from Blender; use scene_builder_3d_import_asset for models. Successful execution does not establish visual correctness. Render from the delivery camera, publish the image through artifacts, retrieve it with scene_builder_3d_get_artifact, and inspect it before claiming completion. If visual inspection is unavailable, state what remains unverified. Use scene_builder_3d_get_glb or scene_builder_3d_get_blend when the user needs the committed files. Before building or editing a scene, load get_preset_instructions with { preset: "/3d-jutsu" } once for the full workflow, runtime limits and scene-building references. Finish each completed scene creation, edit, or import task by calling scene_builder_3d_show_scene once as the final scene inspection/edit call of that review phase, after mutations have settled and verification is complete. Pass the same projectId and the exact committed revision of the final result: revisionAfter from the final successful mutation, or the settled project.revision after an import. Do not guess the revision. Show an unchanged revision only once. Authorized generation and status calls may follow; later feedback or a verified mismatch can reopen scene editing. Verify and show the corrected revision at its next review boundary. This shows the result to the user; a text summary or download link alone does not finish scene delivery.
scene_builder_3d_search_assets
ChatGPTSearch the curated GLB model catalog available to 3D Jutsu. This read is authorized against projectId; the catalog itself is shared. Pass a returned assetId to scene_builder_3d_import_asset for the same selected project. Search results are available models, not objects already present in the scene. Inspect existing scene objects with scene_builder_3d_query_python before deciding what to add. Never invent an asset ID or turn a catalog URL into Python download code. Copy the returned importArguments, including catalogSearch, into scene_builder_3d_import_asset.
scene_builder_3d_show_scene
ChatGPTShow a minimal interactive 3D Jutsu scene preview with orbit, pan, zoom, a basic animation timeline with play/pause and seeking, and a link to the website. Choose projectId with scene_builder_3d_list_projects, scene_builder_3d_create_project, or the user's explicit selection. Pass revisionAfter from a successful edit to show that exact result, or omit revision for the latest committed GLB. Wait for edits to settle with scene_builder_3d_get_operation before showing their result. This reads an existing export; it never starts Blender, edits the scene, or includes uncommitted collaborative changes. Call this when the user asks to see the scene. For a completed scene creation, edit, or import task, call it once at the scene review boundary after settlement and verification. Do not repeat an unchanged revision. Authorized generation/status calls may follow; feedback or a verified mismatch can reopen editing and lead to a newly verified revision. The widget is for the user to inspect; it does not give the agent visual evidence. Use scene_builder_3d_query_python and scene_builder_3d_get_artifact for the agent's visual verification. If the client cannot display widgets, provide the returned projectUrl.
scene_builder_3d_upload_catalog_asset
ChatGPTUpload a confirmed catalog GLB into the authorized project's current settled revision. Widget-only. sha256 must match the bytes displayed by the editor. Returns only the uploaded scene asset ID, which the editor references in one object.create.from_glb operation through scene_builder_3d_apply_scene_operations. This does not create a scene object.
search_folders
ChatGPTFind folder names across the whole project using a nonempty search. Use list_folders for direct children. Continue cursor with the same workspace, project and search; inspect has_more even when items is empty.
search_reference_elements
ChatGPTSearch completed reference elements and recent Soul Feed image/video generations for composer @mentions. Elements use the returned <<<UUID>>> promptToken in params.prompt; generations use the returned generation_id in params.medias[].value with a role supported by the selected model. Do not generate until the user gives instructions.
set_generation_like
ChatGPTLike or unlike a generation for the authenticated user from the app. Sets the requested state; repeated requests are safe. Pass folder_id when acting from a project so its LIKE permission is checked; unlike removes only the user's own bookmark even after access is revoked.
show_generation_by_ids
ChatGPTRender exactly 1-24 requested generation jobs in one dedicated gallery widget, ordered by index and paginated locally in groups of 12. Use once every jobs_wait group is terminal for generate_image_batch, generate_video_batch, or generate_audio_batch. Pass the collected indexed jobs returned by the batch tool. This tool fetches only those job IDs: it never loads generation history, uses cursors, requests additional pages, or adds other jobs. Do not use show_generations or job_display to present a completed batch.
show_generations
ChatGPTBrowse completed non-Marketing Studio generation history by default, or include all job states for a live feed with only_completed=false. Renders one paginated page in the gallery widget. Returns generations with {id, type, status, model, params, results}. Use only when the user explicitly asks to browse regular generation history. Do not use this history tool after generate_*_batch or jobs_wait; show an exact completed batch with one show_generation_by_ids call instead. Use show_marketing_studio_generations for Marketing Studio video/image/ad history. Pass a prior generation's id as value in the medias array of a new generation to reuse it. Use job_display only to inspect one specific previous result. Paginated: if next_cursor is not null, pass it as cursor to get the next page.
show_katana_result
ChatGPTDisplay the final completed Katana video in its result widget with preview and download. Retained for backward compatibility; prefer show_result with action for new calls. Call after verifying the final export. Pass exactly one of media_id (a confirmed owned video UUID) or url (a public HTTPS video URL, up to 50 MB). URL input imports and confirms the video in your media library before displaying it. Prefer media_id for an already uploaded video to avoid duplicate uploads. Never pass a job ID, local path or unfinished render.
show_marketing_studio_generations
ChatGPTBrowse past completed Marketing Studio generations only. Returns Marketing Studio video and ad/image generations with {id, type, status, model, params, results}. Use show_generations for non-Marketing Studio image/video history.
show_medias
ChatGPTShow the user's latest uploaded media files of one type in the widget. Returns media IDs, URLs, and creation timestamps. Call once with the single type the user asked for (default image); do not enumerate other types unless requested. The widget handles pagination. Do not call show_medias again merely because next_cursor is present; use cursor only when the user explicitly asks for more items. Pass media IDs as value in the medias array of generation tools.
show_reference_elements
ChatGPTElements widget — reusable characters / environments / props per workspace. Actions: - list (default; paginated by created_at DESC, use cursor from prev next_cursor). - get (default when element_id is set). - create: pass medias[] as { id, url, type: 'media_input' | 'image_job' }. Upload first via media_upload_and_confirm. category='auto' lets the server classify (use explicit only on user ask). Omit name to auto-derive (per-workspace unique, collisions get a numeric suffix). Returns synchronously. REUSABLE CHARACTER — user wants a recurring character/face across generations: create an Element (this tool action=create) from one clear reference image. USAGE IN GENERATION (implementation detail): Embed <<<element_id>>> inside params.prompt of generate_image / generate_video. Backend auto-injects the image and rewrites to @element_name. Multiple placeholders per prompt OK. Example: "Cinematic portrait of <<<UUID>>> on a rooftop", "<<<A>>> handing coffee to <<<B>>> in a Paris cafe". SUPPORTED MODELS (params.model = machine name, friendly in parens): - Image: nano_banana_pro (Nano Banana Pro), nano_banana_2 (Nano Banana 2), gpt_image_2 (GPT Image 2), seedream_v4_5 (Seedream 4.5), seedream_v5_lite (Seedream 5.0 lite), cinematic_studio_2_5 (Cinema Studio Image 2.5). - Video: cinematic_studio_video_v2 (Cinema Studio Video 2), cinematic_studio_3_0 (Cinema Studio Video 3.0), seedance_2_0 (Seedance 2.0), kling3_0 (Kling 3.0 — REQUIRES a start_image in params.medias; element placeholder alone won't trigger reference usage). Map friendly names to model ids. Other models ignore the placeholder. USER-FACING STYLE: prefer friendly model names and element names for readability. GUARDS: - @name form does NOT work in tool calls — only <<<UUID>>> in params.prompt. - Do NOT put element ids in params.medias / params.input_images — placeholder handles injection. - kling3_0 only honors reference elements when an explicit start_image is provided in params.medias. If the user wants Kling 3.0 with an element but hasn't supplied a start frame, ask for one (upload via media_upload_and_confirm, or pick a prior generation) before calling generate_video. Without a start_image, pick another video model from the list. - Only status: completed elements are usable; skip processing / ip_checking / failed / kling_failed / nsfw.
show_result
ChatGPTDisplay a final completed video in its result widget with preview and download. For an active Katana free-generation session, include preset_session_id with action "katana_video"; the session closes after video validation and before returning the result. Call after verifying the final export. Include a nonempty action string, the preset command when a preset run produced the video, optionally include meta as any JSON object, and pass exactly one of media_id (a confirmed owned video UUID) or url (a public HTTPS video URL, up to 50 MB). URL input imports and confirms the video in your media library before displaying it. Prefer media_id for an already uploaded video to avoid duplicate uploads. Never pass a job ID, local path or unfinished render.
soul_feed_author
ChatGPTRead the public profile of an asset's author for its showcase sidebar.
soul_feed_list
ChatGPTLoad one page of generation history for the Soul Feed app.
soul_feed_sync
ChatGPTWait briefly for status changes of the Soul Feed's unfinished generations, or for a new generation.
soul_list
ChatGPTList metadata for your already-trained Soul-IDs; this does not train characters or return reference images. Returns soul-ids sorted by creation date (newest first). Use type='soul_2' to find a soul_id for model='soul_2', type='soul_cinematic' for model='soul_cinematic', or type='soul' for legacy Soul references. Use status='ready' to find characters available for generation. Pass the returned soul_id to generate_image; a Reference Element ID is not a Soul ID. If the user requires a specific trained character, resolve it before generation. If it is unavailable or lookup fails, stop; never omit soul_id or substitute another identity without the user's agreement. Paginated: if next_cursor is not null, pass it as cursor to get the next page.
start_katana_preset_session
ChatGPTCreate a run session for a specific published Katana preset. This tool writes session state. Call for every Katana preset run, whether paid or free, after reading all get_preset_instructions parts and collecting required inputs. Reading instructions, browsing presets or asking about free balance alone does not start a run. Set free_generation to false for a paid tracking session, or true only when the user explicitly requests a free run; true spends the backend Katana free run when starting. Bare /katana must first resolve to a specific preset. Reuse the same idempotency_key on retries; never create a session just to reread instructions. Forward the returned preset_session_id in every generation, cost estimate and batch item in this run. Add use_free_gens: true only when the user explicitly requests free generations; a session alone does not select free billing.
track_generation_download
ChatGPTRecord a generation download started by the authenticated user in the app.
track_skill_activation
ChatGPTReport using a Higgsfield skill for a new user request, once per skill per request. Send only its canonical name. Preserve widget-first and exclusive-tool turns; defer tracking when needed. Do not retry or block the task if unavailable. Returns an acknowledgement, not a delivery guarantee.
unarchive_project
ChatGPTRestore one archived project. Does not create a new project or modify its contents.
unpublish_project
ChatGPTRequest unpublishing under Cinema semantics after explicit user approval. Does not delete the private project or source files. No snapshot compare-and-swap binding is promised. This is not cancelling a pending review. Obtain explicit user approval through the MCP host before invoking this tool. The host owns its approval policy; the server cannot independently verify a human decision. Do not invoke based only on inferred intent. After an uncertain response, stop and read get_project_publication to observe current state. There is no per-operation receipt or automatic replay guarantee; do not blindly repeat a publication mutation. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
update_preferences
ChatGPTPersist whether to automatically create a media project for new MCP conversations. Call only when the user asks to enable or disable this saved preference (for example, always create a project for new chats). A one-off create-project or no-project request must not change this preference. Does not create, delete or move any projects or existing media. Other preferences remain unchanged.
update_project
ChatGPTUpdate shared project metadata only. Omitted fields stay unchanged; null clears nullable fields. Does not change Supercomputer configuration. Inspect get_project capabilities when permissions are unclear.
update_project_publication
ChatGPTSave partial Cinema publication settings. This may immediately change public metadata or visibility; it is not always a private draft. Read current settings and disclose the effective resulting prompts/canvas/discovery visibility before user approval. Omission leaves fields unchanged and null follows Cinema clearing semantics. Obtain explicit user approval through the MCP host before invoking this tool. The host owns its approval policy; the server cannot independently verify a human decision. Do not invoke based only on inferred intent. After an uncertain response, stop and read get_project_publication to observe current state. There is no per-operation receipt or automatic replay guarantee; do not blindly repeat a publication mutation. The private working-project name, public publication title (settings.name), and URL slug (settings.slug) are distinct; never infer a title or slug change from a working-project rename. For a share-link request, preserve any existing slug; prepare a nonempty URL-safe slug in the proposal only when absent or when the user requests a URL change, before approval and verify public_url after completion. show_canvas does not establish whether chats are hidden; no separate chat-privacy control or complete composition inventory is available, so do not promise that chats are excluded. Pending moderation runs automatically: wait and read state; only awaiting_confirm needs a separate flagged-item decision. Capture can include changes made while publication is in flight; after a completed snapshot, later working-project changes require republishing. Report completion only from observed state and review, never merely an accepted mutation response. For republish, compare snapshot_id and processing state with the prior observation. An unchanged snapshot may be a successful no-op when current content is already served, or the old version while work is in flight; do not infer pending from an unchanged ID. Report observed state and any attribution uncertainty; neither a new snapshot nor current state is a per-call receipt.
use_higgsfield
ChatGPTInteract with Higgsfield through a single interface for app services and UI actions. Use action to select the operation and page to identify the current app page. If action is omitted, the app is initialized; if page is omitted, home is used. Returns structured data for the requested operation.
video_analysis_create
ChatGPTStart a scene-by-scene analysis of a video. Provide EXACTLY ONE of: (a) video_input_id — UUID of a video the user has uploaded via media_upload_and_confirm, or (b) youtube_url — a YouTube link (youtube.com / youtu.be hosts only). Returns immediately with status='queued'; poll video_analysis_status until status='completed'. Processing typically takes 3-5 minutes on average. IMPORTANT: warn the user up front that the longer the video, the less accurate the scene-by-scene analysis becomes — short clips give the most reliable results.
video_analysis_jobs
ChatGPTList the user's video analyses in the current workspace, newest first. Paginate by passing the previous response's cursor.
video_analysis_status
ChatGPTGet the status and result of a video analysis. Poll this after video_analysis_create until status='completed' (scenes populated) or 'failed' (fail_reason populated). Analyses typically finish in 3-5 minutes — poll accordingly every 30-60 seconds.
visual_effects_history
ChatGPTRead one page of the user's accessible Viral preset generations. Does not generate media.
visual_effects_list
ChatGPTRead the website's public visual preset previews and category filters. Does not generate media.
visual_effects_samples
ChatGPTRead approved public examples and their input media for a visual preset. Does not generate media.
voice_change
ChatGPTReplace the spoken voice in a video with a different voice while keeping the original timing and visuals, then re-merge the new audio onto the video. Use this when the user asks to change, swap, or revoice the speaker in a clip. Pass video_id for the source video (a confirmed uploaded media_id or a completed video generation job_id) and voice_id for the target voice. voice_type selects whether voice_id is a built-in preset voice ('preset') or a workspace reference element ('element'). This tool does not use prompt or count; output dimensions are taken from the source video automatically.
website_db
ChatGPTInspect the website's database (D1 / SQLite), READ-ONLY. The website has ONE database — the live site's real data. Pick an operation: 'tables' (list tables); 'schema' (a table's columns — needs table); 'rows' (a page of rows — needs table; optional filters, order_by + order_dir, limit (default 50) + offset); 'query' (one read-only SELECT/WITH — needs sql). Writes and DDL are rejected.
website_repo_access
ChatGPTPrepare a credential-free checkout in sandbox_exec (operation checkout), or push committed changes (operation push). Use the returned checkout_path to edit and commit with sandbox_exec; then call this tool with push before deploy_website. Each call reserves the user's sandbox for 15 minutes. Checkout reuses existing files; it never resets work. Push rejects uncommitted files and non-fast-forward updates. No Git credentials are returned or installed in the editing sandbox.
website_secrets
ChatGPTList configured secret names only. Values are never returned. Configure or remove secret values through Higgsfield's website settings; do not ask the user to paste credentials into chat. Secret changes take effect on the next deploy_website.
website_status
ChatGPTGet the website's deploy status — the live URL and the status of the last deploy. Use to check a deploy that returned 'pending', or to fetch the live URL.
workspace_clear_selection
ChatGPTClear the active workspace selection so subsequent MCP operations use the user's default private workspace. This changes selection only; it does not delete any workspace.
workspace_select
ChatGPTSet the active workspace for subsequent MCP operations. This changes workspace selection only; it does not create, update, or delete workspaces.
