bash
ChatGPTRuns in the Buzzy execution environment: a remote Linux sandbox owned by the project identified by projectId. It is not your own machine and not the user's — these files are reachable only through these tools. Run a shell command and return its output. Files persist across calls, but each call starts a new shell in /workspace (or in cwd), so a cd does not carry over to the next call. A non-zero exit code is returned normally; read stderr and correct the problem. To run code, create it with write first, then execute that file.
choose_skill_asset
ChatGPTReturn a flat catalog of skill assets (styles, musics, backgrounds, character images, and similar) for the configured style template so the user can pick one.
confirm_file_upload
ChatGPTConfirm that a file PUT to an upload_file presigned URL is now readable on the CDN. Call this only after every curl PUT returned HTTP 200. Pass the url (or urls[]) returned by upload_file. Do not pass the url to generate_image / generate_video / create_canvas_node until this succeeds — the CDN 404s until the PUT completes. The widget path does not need this tool: the browser already observed PUT 200.
create_canvas_node
ChatGPTPlace text or a media URL that already exists onto the project canvas as one node. Use it for content the user or an earlier step already produced. It does not generate new text, images, or videos, and it does not update an existing node.
create_project
ChatGPTCreate a project to hold generated assets for a multi-step workflow. Call this after loading a workflow skill and before the first skill step. Pass the returned project id as projectId on every subsequent workflow tool, and as project_id on generate_image / generate_video.
create_story
ChatGPTCreate a video storyline from a creative brief, or return a new version when the user asks to change an existing storyline. A new version is added beside the previous one. Pass instruction_prompt with the brief, or with the latest story result plus the requested change. Optional image_path and video_path accept external media URLs. This generation consumes credits and adds a story node to the project canvas; retries may create another version. The result includes the story text, characters, backgrounds, and the image and video settings later steps need.
create_storyboard
ChatGPTCreate a storyboard from a story and its character and background images. Use the story segments and image records from generate_story_assets, plus the director image size from create_story. Each shot is saved as an image on the project canvas.
display_product_info
ChatGPTSave a confirmed product title, description, and images on the project canvas. Call it once after the user confirms the product editor. Put the main image first. Do not use it for text or media that is not product info.
edit
ChatGPTRuns in the Buzzy execution environment: a remote Linux sandbox owned by the project identified by projectId. It is not your own machine and not the user's — these files are reachable only through these tools. Replace an exact string in a file. Read the file with read first and copy old_string verbatim, including indentation. old_string must match exactly once or the edit is rejected; add surrounding lines to make it unique, or set replace_all. Use write to create a file or replace it wholesale.
export_file
ChatGPTRuns in the Buzzy execution environment: a remote Linux sandbox owned by the project identified by projectId. It is not your own machine and not the user's — these files are reachable only through these tools. Publish files from the sandbox to public URLs. Sandbox files are not reachable from anywhere else and are lost when the environment is reset, so this is the only way an artifact survives. Pass every finished artifact in one call. Returns one entry per path with its URL, or an error for that path alone. Export finished artifacts, not scratch files.
generate_audio
ChatGPTSubmit a speech, music, or sound-effect task that consumes credits; retries can create and charge for another clip. Returns a task_id and project_id immediately. The audio is placed on the project canvas. If you already have a project_id from an earlier generate call in this conversation, pass it. If omitted, a project is created automatically — reuse the returned project_id on later generate calls. On Apps-capable hosts a widget shows progress and plays the result — do not repeat the audio as markdown. Poll get_task until TASK_STATE_SUCCEEDED or a failure state; the playable URL is in resources with media_type audio. prompt, model and mode are required. Call list_model, pick a model whose output_modalities include "audio", and copy mode, duration and provider verbatim from that row. For text_to_speech that needs a voice, call list_voices with that provider and copy voice_id into voiceId. Do not pass voiceId for music or sound_effect — the upstream rejects it. title is only a label for the widget.
generate_image
ChatGPTSubmit an image generation task that consumes credits; retries can create and charge for another image. Returns a task_id and project_id immediately. The generated image is placed on the project canvas as an image node. If you already have a project_id from an earlier generate_image or generate_video call in this conversation, pass it so all assets stay in the same project. If omitted, a project is created automatically — reuse the returned project_id on later generate calls. Hosts should confirm the arguments with the user before calling. On Apps-capable hosts a widget shows progress and the result — do not repeat the image as markdown. A loaded skill must still poll get_task until TASK_STATE_SUCCEEDED or a failure state; the widget does not replace get_task. On other hosts poll get_task with the task_id until it succeeds, then present the resource URLs as text. When a later skill tool needs a canvas reference, poll get_task until TASK_STATE_SUCCEEDED and pass the returned node_id as nodeIds. Do not call create_canvas_node with the generated URL — that duplicates the canvas node. model, resolution and aspect_ratio are all required: call list_model, pick a model whose output_modalities include "image", and copy those values verbatim from that entry's resolutions / aspect_ratios. Do not invent values — unsupported combinations fail.
generate_story_assets
ChatGPTGenerate character and background reference images for a story. Use the character, background, story, duration, and image size fields from the latest create_story or update_story_assets result. Returns the image records and the story segments used by the storyboard and clip steps.
generate_story_clips
ChatGPTGenerate one video clip for each storyboard segment. Use the story segments and character images from generate_story_assets, and the storyboard records from create_storyboard. Each clip is saved on the project canvas.
generate_video
ChatGPTSubmit a video generation task that consumes credits; retries can create and charge for another video. Returns a task_id and project_id immediately. The generated video is placed on the project canvas as a video node. If you already have a project_id from an earlier generate_image or generate_video call in this conversation, pass it so all assets stay in the same project. If omitted, a project is created automatically — reuse the returned project_id on later generate calls. Hosts should confirm the arguments with the user before calling. On Apps-capable hosts a widget shows progress and the result — do not repeat the video as markdown. A loaded skill must still poll get_task until TASK_STATE_SUCCEEDED or a failure state; the widget does not replace get_task. On other hosts poll get_task with the task_id until it succeeds, then present the resource URLs as text. When a later skill tool needs a canvas reference, poll get_task until TASK_STATE_SUCCEEDED and pass the returned node_id as nodeIds. Do not call create_canvas_node with the generated URL — that duplicates the canvas node. model, resolution, aspect_ratio and duration are all required: call list_model, pick a model whose output_modalities include "video", and copy those values verbatim from that entry's resolutions / aspect_ratios / durations. Do not invent values — unsupported combinations fail.
get_task
ChatGPTLook up an async generation task by task_id. Returns state, node_id (the canvas node created for this generation), and the generated resources once it succeeds. Pass node_id as nodeIds on later skill tools to wire reference edges. Do not call create_canvas_node for the same image or video — that would duplicate the canvas node. While state is TASK_STATE_PENDING or TASK_STATE_RUNNING the task is still working — call get_task again until TASK_STATE_SUCCEEDED or a failure state; do not stop and wait for the user. Video generation usually takes minutes. Do not resubmit the generation, that would bill twice.
list_model
ChatGPTList generation models with the resolutions, aspect ratios, durations and input limits each one supports. Call this before generate_image or generate_video whenever you will pass resolution, aspect_ratio, or duration; copy those values verbatim from the matching model's arrays. You may skip this call when generating with a known model id and omitting those fields. Known generate model ids are listed on generate_image and generate_video.
list_voices
ChatGPTList speech voices for one provider. Copy provider from the same list_model row you will use for generate_audio. Copy a returned voice_id into generate_audio voiceId. Only text_to_speech accepts a voice. page_size and page_num are reserved; most providers return the full catalog in one response. preview_url is a short sample you can give the user when they want to hear a voice first.
load_workflow
ChatGPTList Buzzy skills or load one skill's instructions. Call with no argument to see skill names and what each one produces. Call with a skill name when the user asks for a product ad, brand commercial, cinematic clip, 3D clip, or story. When the loaded skill names a bundled file, call load_workflow_bundle_file with that exact path. Follow the loaded skill and call the tool names it lists. generate_image and generate_video return a task_id; poll get_task for the result and node_id.
load_workflow_bundle_file
ChatGPTLoad a bundled file from a skill previously returned by load_workflow (a reference, script, or asset listed in files). Pass the exact path from that files list, e.g. "skills/mcp/ugc-ads/reference/intent-questions.md". Do not guess relative names from SKILL.md; copy the path verbatim.
merge_videos
ChatGPTJoin two or more existing video clips into one video, in the given order. Use it only when there are at least two clips. Set is_generate_bgm when the merged video should also include a soundtrack.
parse_product_info
ChatGPTOpen the product editor when making an ad from a product page, product image, or product description. Pass productLink only when the user gave a product page URL; omit it for an image or a written description. This tool does not save the product. Wait for the user's Confirmed Product Info message, then call display_product_info.
read
ChatGPTRuns in the Buzzy execution environment: a remote Linux sandbox owned by the project identified by projectId. It is not your own machine and not the user's — these files are reachable only through these tools. Read a file from the sandbox. Output is line-numbered. Read a file with this tool before calling edit, and quote text from it exactly.
regenerate_background_music
ChatGPTCreate a new background music version for a merged video that does not yet have a soundtrack. Pass the merged video. When earlier music exists, pass it so the result is the next version; existing nodes remain available.
run_prompt
ChatGPTCreate a draft for the current Buzzy video workflow step: a product brief, selling-point analysis, ad storyboard, video script, scene breakdown, or image/video prompt. Choose prompt_key from the declared options for that workflow step and pass its task-specific inputs in instruction. This operation consumes credits and may add text or media nodes to the project canvas; retries may repeat those effects. Returns prompt_key and template-specific items; some include generated content text.
update_story_assets
ChatGPTDerive new character and background records from a storyline the user edited. Call it after the user changes the story markdown and before generating images from those records. Pass the edited markdown and the previous character, background, and story records.
upload_file
ChatGPTRequest a presigned PUT URL for a local file the agent can upload itself. Use this when the MCP client cannot render the upload_resource widget (Hermes, curl, a code-execution sandbox). Pass filename and content_length (bytes). Run the returned curl PUT, then call confirm_file_upload with the returned url. Do not use this for user-provided local image/video/audio on Apps UI-capable hosts — call upload_resource so the widget uploads in the browser. Supports batch via files[].
upload_resource
ChatGPTOpen the Buzzy upload widget for a user-provided local image, video, or audio file. Use it when the user asks to import a local media file and the MCP client can render Apps UI. Do not ask the user to upload the file directly into chat; remote MCP tools cannot read those attachments. The widget is the upload surface: the user chooses files in the browser, the browser uploads them directly to storage, then sends the CDN url(s) back for generate_image / generate_video / create_canvas_node. If the user provided an HTTP or HTTPS URL, pass it as url to import the file into Buzzy storage. Hosts that cannot render the widget should call upload_file (PUT local bytes) or pass url.
upload_skill_to_sandbox
ChatGPTInstall a skill's files into the project sandbox before bash, read, write, or edit. Pass the skill name from load_workflow and the projectId from create_project. Files land at /workspace/skills/<skill name>/, including scripts, assets, and SKILL.md. Call this instead of copying files in with load_workflow_bundle_file and write.
write
ChatGPTRuns in the Buzzy execution environment: a remote Linux sandbox owned by the project identified by projectId. It is not your own machine and not the user's — these files are reachable only through these tools. Write a file in the sandbox, creating parent directories as needed. Overwrites an existing file. Prefer writing a script and running it with the bash tool over passing code inline.