Frameo.AI

Frameo.AI MCP server reference

Frameo is an AI video production platform that takes an idea or a script to a finished short film, micro-drama, ad or social video. Images, video clips, voiceovers, music and sound effects are generated with the latest models, such as Seedance, Kling and Veo, kept consistent from shot to shot, and edited and assembled on one canvas. This MCP server brings that to Claude, ChatGPT, Cursor and any other MCP client, working in the user's own Frameo account.

The reference below is generated from the server's live tool list.

Endpoint

Server URLhttps://mcp.frameo.ai/mcp
TransportStreamable HTTP (MCP)
AuthenticationOAuth 2.1 with PKCE (S256), scope frameo

Connecting

ClientHow
ClaudeSettings → Connectors → Add custom connector, and paste the server URL.
ChatGPTAdd a custom app in Settings → Apps, and paste the server URL.
Claude Codeclaude mcp add --transport http frameo https://mcp.frameo.ai/mcp
CursorAdd to mcp.json: {"mcpServers": {"frameo": {"url": "https://mcp.frameo.ai/mcp"}}}

On the first call the client opens Frameo's sign-in page. The user signs in with their Frameo account, picks the workspace the connection starts in, and approves. switch_workspace later moves the connection to any other workspace the user belongs to. Disconnecting the connector in the client, or revoking it, ends access.

Directories

This MCP server is listed in:

Authorization

Clients discover everything from the protected-resource metadata; no client secret is issued, and every client is public and uses PKCE.

Protected resource metadatahttps://mcp.frameo.ai/.well-known/oauth-protected-resource/mcp
Authorization server metadatahttps://mcp.frameo.ai/.well-known/oauth-authorization-server
Authorizehttps://mcp.frameo.ai/authorize
Tokenhttps://mcp.frameo.ai/token
Dynamic client registrationhttps://mcp.frameo.ai/register
Revocationhttps://mcp.frameo.ai/revoke

Client ID metadata documents are accepted in place of registration.

Overview

Frameo is an AI video production platform for short films, micro-dramas, ads, social video and more. Start with get_skill("get-started") before the first generation of a new piece of work, and for someone new or asking what Frameo can make: it agrees the brief and plan and names the skill for the job. Use each skill via the get_skill tool call; without using skills, the results are weaker. Images, video clips, voiceovers, music and sound effects are generated in a project, kept consistent from shot to shot, and assembled into the final cut. Frameo has a skill for almost every kind of job, from a script into a video to a UGC ad or a photoshoot. Only list_skills shows every skill. A job done without its skill runs on generic choices of model, prompt and shot order that were not tested for that job, so the result is usually weaker and takes more retakes and credits to fix. Work is organised as workspace → project → module, and each module has its own Library. This connection works in one workspace at a time. What this connection makes is saved to the module's Library. How a job goes: 1. whoami: the workspace this connection works in, its credits, and the user's other workspaces. 2. list_projects or create_project (create_modules adds modules to the project): the project_id and module_id every tool making something takes. 3. list_skills, then get_skill: the steps for the job. Before writing an image or video prompt from scratch, list_presets and get_presets have tested prompts for camera moves, lighting, framing, product shots and effects. 4. estimate_cost, then a generate tool (generate_images, generate_videos, generate_speech, generate_music, generate_sound_effect, generate_lipsync, upscale_video, upscale_image, make_control_map; generate_images and generate_videos start several at once, one quote_id per item): the quote_id is single-use, valid for 15 minutes and bound to those settings; the generate call redeems it with confirmed_by_user once the user agrees, and a call that differs is refused uncharged. 5. show_generations and wait_task: in chat apps that show cards, the user sees the work only on a show_generations card, and without one sees nothing for what can be tens of minutes. One card per wave: every id started before the next wait_task, shown before it; the card updates itself, so the same ids are not shown again. wait_task collects the results. Choosing the tool: - A question for the user, or a choice, decision or approval that is theirs: show_choices (up to 6 questions on one card, answered with a tap) and show_plan for a shot plan. - Files on the user's device: show_upload. Web links: import_media_url. Files attached in the chat, where the app passes them (ChatGPT): import_attachments. - Titles, captions and text on a video: render_motion_graphics or run_ffmpeg, not a video model. - Brightness, colour, crop, speed or length of existing media: run_ffmpeg. A change to what is in it: a new generation. - A voiceover: generate_speech. A person speaking on screen: generate_speech, then generate_lipsync when their mouth has to match the words. - The user's own clips: analyze_media reports what is in them before they are edited. - A sharper, larger video: upscale_video; an image: upscale_image. - A depth map, pose skeleton or subject cutout to guide another generation: make_control_map. - A problem with Frameo, something it cannot do yet, or a suggestion: send_feedback. Consistency: a recurring character, place or product stays the same when its earlier images are passed as references (image_urls, reference_image_urls) or saved with save_reference. Checking results: wait_task returns small previews and view_image shows one image or video frame in detail, so a result can be checked against the request before it is built on. The review-shots skill, via the get_skill("review-shots") tool call, checks a whole set of shots and the finished cut, and retakes a failed shot once; a retake is quoted like any other generation. Shapes: 9:16 for Reels, TikTok and Shorts; 16:9 for YouTube; 1:1 or 3:4 for feed posts, where the model takes them (list_models). Thumbnails and covers: a new image (the thumbnail-set skill, via get_skill("thumbnail-set")); a video has no cover setting. Without credits: some tools are free, and free modes or promotions can price some or all generations at 0 credits, so estimate_cost's quote gives the actual cost.

Errors

A tool that fails returns a result rather than a protocol error. error is a stable code, hint says what to change, and retryable says whether the same call may succeed later. A failed paid call states whether work started and what was charged.

{
  "ok": false,
  "error": "quote_mismatch",
  "hint": "These settings differ from the quoted ones (differs lists each). Nothing was charged, and the quote_id is still valid for its original settings; estimate_cost with the new settings returns a quote for them.",
  "differs": {"resolution": {"quoted": "480p", "requested": "720p"}},
  "retryable": false
}

Tools (63)

add_sound_to_library Writes · free

Save a library sound to a project

Save a sound from search_sound_effects into a project's Library. Free: nothing is generated. Finishes at once and returns the sound's name, its audio_url and open_in_app, the project's link in the web app.
ArgumentTypeDefault
sound_id string required
project_id string optional
module_id string optional
request_text string optional

add_upload_to_library Writes · free

Add uploads to the project's Library

Put files uploaded through create_upload_url into a project's Library. Free. Each stored file is checked first: it must exist, be within the size limit for its kind (images 20 MB, video 200 MB, audio 50 MB), and be stored with a content type of that kind. The files are added together. Adding the same file to the same module again changes nothing, its name included, and reports ok. Returns files, one entry per link in the order given: index, and file_url and kind, or that file's own error and hint. Also open_in_app, a link to the project. When no file could be added, the call fails and files still gives each one's error.
ArgumentTypeDefault
file_urls string[] required
project_id string optional
module_id string optional
names string[] optional

analyze_media

Analyze a video or audio clip

Describe or transcribe a video or audio clip generated, uploaded or imported here. Uses credits, charged by clip length once it has run — the one paid tool with no quote. The answer comes back as text. The price is not knowable before the run: it is a few credits per minute of media. confirmed_by_user records that the user was told that and agreed; without it the call is refused. The finished run's result (wait_task) carries credits_charged_estimate, the wallet's change while it ran (null on a poll that came before the charge landed). Returns a generation id for wait_task. Usually done within a minute. The finished result's analysis is markdown. For a video: an overall summary, an audio summary, a timestamped transcript when there is speech, then the scenes; with detect_shots each scene is one shot, headed `Shot N` with its `(start_ms=N, end_ms=N)`, which go verbatim into extract_frames to grab that shot's frames and clip. For audio: an overall summary, the audio analysis and a transcript of `speaker: text` lines, each with its measured start and end, safe to cut at. In one module these runs (ffmpeg, motion graphics, HTML scenes, media analysis) go one at a time: while one is in progress, another started in the same module is refused with module_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run.
ArgumentTypeDefault
media_url string required
question string required
detect_shots boolean True
project_id string optional
module_id string optional
confirmed_by_user boolean False

create_handoff Writes · free

Open the web app signed in

Make a link that opens a web app page signed in as this connection's user, for a card's Open in Frameo or Manage credits button. Free. page canvas takes project_id and module_id. Returns url, a short link that signs in the first time it is opened within 15 minutes and opens the page for 12 hours.
ArgumentTypeDefault
page 'canvas' | 'home' | 'pricing' required
source string required
project_id string optional
module_id string optional

create_modules Writes · free

Add modules to a project

Add one or more modules to an existing project in one call, numbered in the order given. Free. A project from create_project already has its first module. Returns modules, one entry per created module with its module_id, name, module_number and open_in_app link, in the order given. A name the project already has is not added again: its entry is that module, marked existing. The call returns within about 45 seconds: when the service is slow, or refuses a name partway (then error says why), the modules made so far are returned and not_created lists the names still to add, in order; a create_modules with just those names continues the numbering. The same project_id and names sent again within 5 minutes returns the same result, marked replayed, and adds nothing.
ArgumentTypeDefault
project_id string required
names string[] required

create_project Writes · free

Create a project

Create a new, separate project, with its first module, to generate into. Free. Each call makes another project. Work already under way keeps the project_id it has, even when its plan, title or shape changes: rename_project renames a project, and each generation carries its own aspect_ratio. list_projects finds the user's earlier projects by name. Returns the project_id and the module's module_id that every generate tool takes, and an open_in_app link to the new project. The same name and aspect_ratio sent again within 5 minutes returns that project, marked replayed. module_not_created means the project in project_id exists without a module.
ArgumentTypeDefault
name string required
aspect_ratio string '9:16'
description string ''

create_upload_url Writes · free

Create upload links

Get links to upload files whose bytes the caller sends itself (an HTTP PUT each). Free. For clients that can make HTTP requests; show_upload is the card for files on the user's device. A code sandbox without internet access cannot send this PUT; there use show_upload for a file on the user's device or import_attachments for a file attached in the chat. When the PUT cannot reach upload_url at all, new links fail the same way: open show_upload instead of calling again. Returns files, one entry per file name in the order given: index, and upload_url, file_url, headers, kind and max_mb, or that file's own error and hint. When no link could be issued, the call fails and files still gives each one's error. The bytes do not pass through this server. For each file the caller sends one HTTP PUT to its upload_url with the whole file as the raw body, up to its max_mb, and exactly the headers given in its headers. upload_url is valid for 60 minutes and for its one file; a fresh call issues another. Once that PUT succeeds, file_url is a link accepted anywhere a media link is taken -- image_urls, first_frame_url, reference_image_urls, or a lipsync source -- with no further step. Until add_upload_to_library is called with file_url, the file does not appear in any project's Library. Where no HTTP request is possible, the same file can be added in the web app and its link used instead.
ArgumentTypeDefault
file_names string[] required
project_id string optional
module_id string optional

delete_module Can overwrite · free

Delete a module

Delete a project's last module, with its Library. Free; cannot be undone. Only the module with the highest module_number can be deleted; any other is refused with not_last_module, which names the last one. Without confirmed_by_user it deletes nothing and answers not_confirmed with the module's name and project_name, for the user to agree to by name; the same call with confirmed_by_user true then deletes it, and no tool restores it. It is allowed to the project's owner and managers; another role is refused with not_permitted. Returns the project_id, module_id and the name it had, with deleted true and modules_left. The same call sent again within 5 minutes returns that result, marked replayed.
ArgumentTypeDefault
project_id string required
module_id string required
confirmed_by_user boolean False

delete_project Can overwrite · free

Delete a project

Delete a project with all its modules and Library. Free; cannot be undone. Without confirmed_by_user it deletes nothing and answers not_confirmed with the project's name and module_count, for the user to agree to by name; the same call with confirmed_by_user true then deletes it. The project leaves list_projects and the web app, and no tool restores it. It is allowed only to the project's owner; another role is refused with not_permitted. Returns the project_id and the name it had, with deleted true. The same call sent again within 5 minutes returns that result, marked replayed.
ArgumentTypeDefault
project_id string required
confirmed_by_user boolean False

delete_skill Can overwrite · free

Delete a skill

Delete a skill saved with save_skill, or one of its files. Free; cannot be undone. Without path, deletes the skill with all its files; with path, deletes that one file. Built-in skills cannot be deleted. Without confirmed_by_user it deletes nothing and answers not_confirmed with the skill's name, for the user to agree to by name; the same call with confirmed_by_user true then deletes it, and no tool restores it. Returns skill_id, deleted true and, with path, path and the skill's new version.
ArgumentTypeDefault
skill_id string required
path string optional
confirmed_by_user boolean False

estimate_cost Read-only · free

Quote the cost of a generation

Quote the credits a generation will cost. Free. Required before any generate tool. Each item names its kind and takes the same fields as that kind's generate call: a generate_images or generate_videos item, or the arguments of generate_speech, generate_music, generate_sound_effect, generate_lipsync, upscale_video, upscale_image or make_control_map. Fields that don't change the price are ignored. For one generation, pass one item. Returns quotes, one entry per item in order, each with its index and either its own quote_id, credits and settings (what was priced) or its own error, and total_credits, the sum of the items that were quoted. A quote is single-use, valid for 15 minutes, and bound to the settings and project it priced. The generate tool redeems it alongside confirmed_by_user, which records that the user has seen those credits and agreed to them. A generate call whose settings differ from the quote, or with confirmed_by_user false, is refused uncharged and leaves the quote valid. The same generate call sent again returns the work it started, marked replayed, at no charge; the quote sent with other arguments is refused with quote_used, which names that work. Never take a new quote to recover a call whose outcome is unclear. Each quote_id is redeemed on its own, so any of the items can be generated and the rest left to expire. attached, on an image or video quote, says what each image the model receives is, in the order it receives them (@Image1 first): a saved reference by name, an upload by what it shows, or image when neither. prompting_guide, when present, is the call that reads the prompting guide for what was priced, read before writing its prompt. For image and video items the prompt may be a draft; the generate call may reword it. credits_available is the workspace's balance at the time of the quote (the member's own limit where the workspace sets one), when it is reported. When total_credits is more, short_by is the difference and account_url links where credits are managed; the quotes are still issued, and a generate call the balance cannot cover is refused with out_of_credits, uncharged, and its quote is used; a retry takes a new quote.
ArgumentTypeDefault
items any[] required
project_id string optional
module_id string optional

extract_frames Writes · free

Extract frames from a video

Pull still images out of a video, and optionally cut a range of it into a clip. Returns media links. Free: no credits are charged. The common use is the LAST frame of a clip, which becomes a generate_videos item's first_frame_url so the next shot continues from exactly where this one ended. With start_ms and end_ms (for example one shot's bounds, copied verbatim from an analyze_media run with detect_shots), the range is also cut into its own clip, returned as clip.url (a link only: it is not added to the module's Library), and every moment in at_seconds lies inside the range. One call covers one range; several shots take one call each, and they can run in parallel. Answers within about 50 seconds. The result also carries small JPEG previews of up to 4 of the frames (at most 384 px) as image content next to the same JSON; previews lists the frame links they show, in the same order as the images.
ArgumentTypeDefault
video_url string required
duration number optional
at_seconds number[] optional
start_ms integer optional
end_ms integer optional
project_id string optional
module_id string optional

generate_images

Generate images

Start one or more independent images together in one call. Uses the user's credits. This starts one or several at once, such as the keyframes of a sequence that do not depend on each other's results. Each item has an index of your choosing (such as the shot number) that its result carries. An image made from another's result waits for that one to finish, in a later call. Each item is text-to-image, or from image_urls: source images that either EDIT an image or hold a character, product or style steady in a new scene, with the prompt saying what to keep and what to change. Supported resolutions and source-image counts vary by model; list_models reports each. How to write the prompt and pick the model: get_skill("image-prompting"). Paid: estimate_cost(items=...) quotes them in one call and returns one quote_id per item, single-use, valid 15 minutes and bound to that item's settings. Each item passes its own, and confirmed_by_user records that the user agreed to them. An item without its quote, or with other settings, is refused uncharged, and the other items still start. Returns items, one entry per item with its index and its result: its generation_ids and credits_charged once started, or its own error. generation_ids and credits_charged at the top add up the items that started. Where the chat app shows cards, show_generations with all of generation_ids, once, shows the work to the user before the first wait_task; wait_task returns the images. A wait_task timeout leaves the work running and the ids valid. Each image is saved in the project; the finished result's open_in_app link opens it there. When the outcome is unclear, send the same call again: items that started return their work, marked replayed, and charge nothing. Never take new quotes to recover a call; a new quote starts new work.
ArgumentTypeDefault
items ImageItem[] required
project_id string optional
module_id string optional
confirmed_by_user boolean False

generate_lipsync

Lip-sync a video to a voiceover

Make the person in a video speak an audio clip (lipsync). Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. For a person on screen who has to say exact words in a chosen voice, generate_speech makes the voiceover and this matches the mouth to it. Both files are measured. The result runs as long as the voiceover (the video plays back and forth when the voiceover is longer), is priced per second of that result, and is among the more expensive tools here. Returns generation ids once the work is queued; wait_task returns the result when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The result is saved in the project; the finished result's open_in_app link opens it there.
ArgumentTypeDefault
video_url string required
audio_url string required
model string optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

generate_music

Generate a music track

Start a background-music track in a project. Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. Returns generation ids once the work is queued; wait_task returns the track when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The track is saved in the project. How to describe it: get_skill("audio-prompting").
ArgumentTypeDefault
prompt string required
duration integer 30
model string optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

generate_sound_effect

Generate a sound effect

Generate a new one-shot sound effect in a project. Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. This makes a new sound. search_sound_effects searches a library of ready-made sounds, which are free and instant. Returns generation ids once the work is queued; wait_task returns the sound when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The sound is saved in the project. How to describe it: get_skill("audio-prompting").
ArgumentTypeDefault
prompt string required
duration integer 5
model string optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

generate_speech

Generate a voiceover

Start a voiceover (text to speech) in a project. Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. Returns generation ids once the work is queued; wait_task returns the audio and its duration_seconds when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The voiceover is saved in the project. When a person on screen has to say this exact audio, generate_lipsync then makes their mouth match it. Choosing and keeping a voice, and directing the delivery: get_skill("audio-prompting").
ArgumentTypeDefault
text string required
voice_id string required
language_code string optional
stability number optional
similarity number optional
style_instructions string optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

generate_videos

Generate videos

Start one or more independent videos together in one call. Uses the user's credits. This starts one or several at once, such as the shots of a sequence that do not depend on each other's results. Each item has an index of your choosing (such as the shot number) that its result carries. A shot that continues from another's last frame waits for that one to finish, in a later call. Each item is text-to-video by default, or opens on, passes through or ends on its frames, carries reference images or audio into a new shot, or works from the clips in reference_video_urls. On Seedance frames guide the clip rather than pin it and count as reference images; on other models the clip takes the first frame's shape, and frames with reference images or audio are refused. An item that breaks a model's rules is refused uncharged. Paid: estimate_cost(items=...) quotes them in one call and returns one quote_id per item, single-use, valid 15 minutes and bound to that item's settings. Each item passes its own, and confirmed_by_user records that the user agreed to them. An item without its quote, or with other settings, is refused uncharged, and the other items still start. Returns items, one entry per item with its index and its result: its generation_ids and credits_charged once started, or its own error. generation_ids and credits_charged at the top add up the items that started. Where the chat app shows cards, show_generations with all of generation_ids, once, shows the work to the user before the first wait_task; a video takes one to a few minutes, and wait_task returns it. Each video is saved in the project; the finished result's open_in_app link opens it there. When the outcome is unclear, send the same call again: items that started return their work, marked replayed, and charge nothing. Never take new quotes to recover a call; a new quote starts new work.
ArgumentTypeDefault
items VideoItem[] required
project_id string optional
module_id string optional
confirmed_by_user boolean False

get_presets Read-only · free

Get presets

The prompt text of up to 10 presets, for an image or video prompt. Free. Each preset has its prompt (used as written, then tied to the scene), when to use it, notes, and any reference images, videos or audio to pass along with it. Ids that are not found are listed in missing; when none is found, the call returns unknown_preset.
ArgumentTypeDefault
preset_ids string[] required

get_profile Read-only · free

Get the signed-in profile

Return the profile of the account signed in on this connection. Free. id is the account's user id, which stays the same across reconnections and token refreshes. name and email are the account's own, each left out when it is not known. whoami reports the same account along with its workspaces and credits.

No arguments.

get_skill Read-only · free

Get a skill's instructions

Step-by-step instructions for one skill, such as a video from a script. Free. Returns the skill text: when it applies, what to ask the user first, the tool calls in order (every paid step is quoted with estimate_cost before it runs) and what the user gets. `files` lists the skill's own files, and get_skill with path reads one; `uses` lists the other skills, their files, and the presets and preset categories the text calls. Load each when its step comes. A skill's text names a file at the step that needs it, as get_skill(skill_id=..., path=...): call it then, with exactly that skill_id and path. A text can point at another skill's file; that skill does not need loading first. With path, it returns the file's text and the `uses` of that file.
ArgumentTypeDefault
skill_id string required
path string optional

import_attachments Writes · free

Import files attached in the chat

Import images, videos or audio the user attached in the chat into a project's Library. Free. In chat apps that pass attached files to apps (ChatGPT), each entry in files names one attachment in the user's message by its file path (/mnt/data/<file name>) or its file id (file_...), as plain text on its own, and the app sends this server the file. Where attachments do not arrive here, show_upload takes files from the user's device and import_media_url takes web links. Takes PNG, JPEG or WebP (up to 20 MB), MP4, M4V or MOV (up to 200 MB), MP3, WAV or M4A (up to 50 MB). The files are imported together, and each one is named after its file name in the Library. An entry the app does not turn into a file is refused on its own, and the others are still imported. Returns files, one entry per file in the order given: index, and file_url (accepted anywhere a media link is), kind, bytes and name, or that file's own error and hint. Also open_in_app. When no file could be imported, the call fails and files still gives each one's error. The same call sent again returns the files it already imported instead of copying them twice. Each account can import 10 files a minute, links included, and one call takes at most about 50 seconds. A refused file that still carries file_url is stored, or is still being copied there, and add_upload_to_library can file it later.
ArgumentTypeDefault
files AttachedFile[] required
project_id string optional
module_id string optional

import_media_url Writes · free

Import media from links

Copy images, videos or audio from public web links into a project's Library. Free. Each file is fetched from its site by the server, so this works where the client cannot send files. The links are imported together. Returns files, one entry per link in the order given: index, and file_url (accepted anywhere a media link is), kind, bytes and name, or that link's own error and hint. Also open_in_app. When no link could be imported, the call fails and files still gives each one's error. The same call sent again returns the files it already imported instead of copying them twice. Each account can import 10 files a minute, attachments included, and one call takes at most about 50 seconds. source_refused means the site serves the file only to a signed-in user or a browser, or the link has expired, so the same link fails again: show_upload takes the file from the user's device, import_attachments takes it attached in the chat (ChatGPT), and the web app takes any file. A refused file that still carries file_url is stored, or is still being copied there, and add_upload_to_library can file it later.
ArgumentTypeDefault
urls string[] required
project_id string optional
module_id string optional
names string[] optional

list_library Read-only · free

List a project's Library

List the media in a project's Library, newest first. Free. The Library holds everything captured for a module: every generation (from the web app's agent and quick actions, from this server, from ffmpeg runs) and every uploaded or imported file. Each item has kind and url (a link the other tools accept), and where recorded its name, origin, tool, model, prompt (cut to 500 characters), description (what an upload shows, written automatically a little after it is filed) and created_at. Each image, video and audio item has a media_id, which show_generations and show_choices take to show it on a card. counts gives the number of matching items of each kind. At most 60 items are returned per call; when more matched, truncated is true and next_cursor, passed as cursor, returns the next page. Items added after the first page do not shift later pages. open_in_app links to the project.
ArgumentTypeDefault
project_id string optional
module_id string optional
kind string optional
origin string optional
cursor string optional

list_models Read-only · free

List the generation models

The models of one kind this workspace offers, with each one's limits and price. Free. The answer settles which model a named request needs, what a higher-quality option costs, and which rule a refused request broke. Models are listed best first, best_for says what each one suits, and default is the model the generate tool and estimate_cost use when none is given. prompting_guide is the call that reads a model's prompting guide, read before writing a prompt for it. For video: clip lengths, aspect ratios, whether it starts from an image, whether it takes clips in reference_video_urls (from_video) and their limits (from_video_limits; reference_only means the clip guides a new video and is not edited), how many clips a call takes (reference_clips; one without it), the frames it takes, how many reference images and audio clips it accepts, and credits per second at each resolution, silent and with sound. default_resolution, when set, is the default model's resolution when none is given. For image: aspect_ratios, max_source_images, qualities (the quality values it takes), and credits per image at each resolution (text-to-image, 9:16, medium quality where it has qualities, and per quality in credits_by_quality); some add credits per source image. For speech: the engines; the voice from search_voices decides which one speaks. For music and sound_effect: the seconds each model makes (none where it sets the length) and sample_credits, the price of the sample in price_note. For lipsync: credits_per_second of the result. For upscale: credits_per_second by output tier at 30 fps, the largest source a model takes (max_source), and max_seconds. For image_upscale: sample_credits and the largest output. estimate_cost prices the exact request; the figure it returns is what is charged.
ArgumentTypeDefault
kind string 'video'

list_notes Read-only · free

List or search a module's notes

List a module's notes (scenes, beats, cast, assets) under a path, or find text in them. Free. Each module keeps a JSON tree of notes addressed by unix-style paths, such as /scenes/1/beat or /characters/lucy/voice_id. The web app reads and writes the same tree, so notes kept on either side are visible to the other. Without query, returns entries [{name, kind ("dir" or "leaf"), bytes, updated_at (top-level keys only)}], at most 200, with truncated and total when there are more. With query, returns matches [{path, snippet}] for the string values under path that contain it, at most 50, at most 6 levels deep, with truncated when there may be more. Paths start with "/" and have no empty, "." or ".." segments.
ArgumentTypeDefault
path string '/'
query string optional
scope string optional
project_id string optional
module_id string optional

list_presets Read-only · free

List presets

Find presets: short, tested prompts for camera moves, lighting, framing, product shots, effects and more, to use in an image or video prompt. Free. Before writing an image or video prompt from scratch, look here: there is often a tested preset for the shot, the camera move, the light or the effect, and it gives steadier results than an improvised prompt. Most presets are a piece of a prompt; some categories hold a whole image, a whole clip, a caption style or a line delivery, and each preset's when and notes say where it goes. Called with no arguments, it returns the categories, each with its sub-categories and counts. With query it searches, best match first, leaving out presets that match only a small part of the query; with category or sub_category it browses. Either way at most 30 presets come back, with total, the number that matched. Each entry has preset_id, title, category, sub_category, description and when to use it; get_presets returns the prompt text. A search with no match returns no presets and the categories: the library has nothing for that need. A camera move, a framing or a lighting look adds to another prompt; a product shot or an ad layout is a whole image on its own; an effect is a whole clip made from one still.
ArgumentTypeDefault
category string optional
query string optional
sub_category string optional

list_projects Read-only · free

List projects

Find the user's projects, newest first, optionally by name. Free. A project_id and module_id from here are where the generate tools put results; module_id is optional when the project has a single module. The first five matches list up to 20 modules each, with module_count and an open_in_app link to each module; modules_truncated is true when a project has more, and list_projects with that project_id lists them all. Later matches carry only project_id, name and description. A project's description, when it has one, is what the user said the project is (what they are making, for whom and in what style), its first 200 characters.
ArgumentTypeDefault
query string optional
limit integer 10
project_id string optional

list_references Read-only · free

List a project's references

List a project's recurring characters, locations and props, each with its images. Free. References are what a project reuses from shot to shot: those in its Reference Library (made in the web app or with save_reference) and those the app keeps in the module's notes. Each has kind (character, location or prop), name, images (up to 6 image links, which image_urls and reference_image_urls accept) and in_library: false for one kept only in the module's notes under /characters, /locations or /props (by the app or save_note), which has no images until save_reference adds it to the Library. A character also has voice_id (a voice generate_speech takes, or null when none is set). Sorted by kind, then name; at most 30 of each kind.
ArgumentTypeDefault
project_id string optional
module_id string optional
kind 'character' | 'location' | 'prop' optional

list_skills Read-only · free

List skills

Step-by-step skills for almost any job: films, UGC ads, photoshoots and edits. Free. There is a skill for most requests: script-to-video turns a script into a film with a consistent cast and spoken dialogue, faceless-story-video makes a narrated explainer, story or kids' song, ugc-video makes creator-style product ads, product-photoshoot makes store and ad stills, thumbnail-set makes thumbnails and covers, review-shots checks a set of shots and the finished cut, and others cover presenters, character sheets, ad remakes and re-cutting footage the user already has. Check this list before planning a multi-step job yourself: a skill sets the models, prompts, checks and order that work. Each entry has a skill_id, a title, a one-sentence summary of what it makes, when to use it, a version, and made_by (built_in or workspace). Use a skill via the get_skill(skill_id) tool call, which returns its full instructions. get-started is listed first: it comes before the first generation of a new piece of work, and for someone new or asking what Frameo can make; it guides the brief, plan, checks and cut alongside the job's skill. The prompting guides follow: the rules and prompt format of each video model (video-prompting), image prompts and edits (image-prompting), voices, music and sound effects (audio-prompting) and ffmpeg commands (ffmpeg-recipes).

No arguments.

make_control_map

Make a depth, pose or cutout map

Make a depth map, a pose skeleton, a cutout or matte of a subject, surface normals or an albedo map from a video or image. Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. A video gives a video with the same frames, rate and length (the frame size can differ, and pose keeps the source's audio); an image gives an image. These are conditioning and reference material for other generations, such as a structure or pose guide. Depth: grayscale, nearer is brighter, is the form to feed a model; quality best on an image (Marigold) is a colour map instead, red near and blue far. Segmentation isolates what prompt names. The black around a cutout or matte is baked in (no transparency), so a prompt that uses one as conditioning says the black background is not part of the scene. Pose draws everyone in frame in one output; on a video the skeletons are not tracked per person and can swap or flicker where people overlap. For one character's pose, make a segmentation cutout of them first, then pose the cutout. Normals: surface normals. Albedo: the base colour without lighting. Depth on a video is priced per second of the source, the rest per job. Returns generation ids once queued; wait_task returns the result. Images take seconds, Marigold (quality best, normals, albedo) a few minutes, video depth about 10 s per second of video; pose jobs can queue a few minutes when several arrive together, which is not a failure. Where the app shows cards, show_generations with these ids shows the work to the user. The result is saved in the project; its open_in_app link opens it there.
ArgumentTypeDefault
source_url string required
extract 'depth' | 'segmentation' | 'pose' | 'normals' | 'albedo' required
prompt string optional
output 'cutout' | 'matte' optional
colormap 'grayscale' | 'turbo' optional
quality 'fast' | 'best' optional
draw_mode 'body-pose' | 'full-pose' | 'face-pose' | 'hand-pose' | 'face-hand-mask' | 'face-mask' | 'hand-mask' optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

poll_balance Read-only · free

Refresh the balance

The balance widget's check. Free. Returns immediately. Chat apps that show widgets hide it from the model; elsewhere it is the same as show_balance, but read fresh, so a change in the balance shows at once; its account_url is the plain pricing page, not a sign-in link.
ArgumentTypeDefault
generation_quote integer optional

poll_generation Read-only · free

Refresh the generations gallery

The gallery card's progress check. Free. Returns immediately. Chat apps that show cards hide it from the model; elsewhere it is the same as wait_task with timeout_seconds 0, without image previews. Takes the same generation_ids.
ArgumentTypeDefault
generation_ids string[] required

poll_home Read-only · free

Refresh the home card

The home card's refresh of the newest projects. Free. Returns immediately. Chat apps that show cards hide it from the model; elsewhere it returns projects as show_home does: the newest first, each with project_id, name, module_count, its first module with an open_in_app link, and recent, that module's latest images and videos (for the newest six only; later projects carry an empty recent). running lists the generations this connection started that are still in progress, each with kind, project_id, module_id, started_at and estimated_seconds.
ArgumentTypeDefault
limit integer 6

poll_project Read-only · free

Open a project on the home card

The home card's view of one project. Free. Returns immediately. Chat apps that show cards hide it from the model. Returns project_id, name, modules (module_id, name and an open_in_app link each), module_id (the module shown, the first when none is given), items (that module's Library, newest first: kind, group, url, still, name, origin, tool, model, prompt, created_at) and characters (the project's saved cast, each with name and still). group is cut, shot, image, audio or upload.
ArgumentTypeDefault
project_id string optional
module_id string optional

read_note Read-only · free

Read a module's note

Read the note at one path of a module's notes, such as a scene, beat or cast entry. Free. Each module keeps a JSON tree of notes addressed by unix-style paths, such as /scenes/1/beat or /characters/lucy/voice_id, shared with the web app. Returns value, the JSON at path. A value over 50 KB is refused with value_too_large, except a string, which comes back cut to 50 KB with truncated: true. A string like "$state:/assets/<id>/url" points to another path in these notes: read that path for the value. Other tools take the value itself (such as a media link), not the pointer. Paths start with "/" and have no empty, "." or ".." segments.
ArgumentTypeDefault
path string required
scope string optional
project_id string optional
module_id string optional

read_settings Read-only · free

Settings

The settings ChatGPT shows on this app's page: the workspace this connection works in, picked by name from the user's workspaces, and a button that opens the home card. Free. Hidden from the model where the chat app supports app-only tools; whoami reports the same workspace. Returns schema, values and layout, the shape of ChatGPT's structured settings.

No arguments.

rename_module Can overwrite · free

Rename a module

Rename a module in a project. Free. Only the name changes: the module's Library, notes and module_number stay as they are. Returns the project_id, module_id, the new name and previous_name.
ArgumentTypeDefault
project_id string required
module_id string required
name string required

rename_project Can overwrite · free

Rename a project

Rename a project. Free. Only the name changes: the project's modules, Library and settings stay as they are. It is allowed to the project's owner and managers; another role is refused with not_permitted. Returns the project_id, the new name and previous_name.
ArgumentTypeDefault
project_id string required
name string required

render_html_scene Writes · free

Render an animated scene

Render HTML pages you write into videos, GIFs or stills: animated titles, kinetic type, lower thirds, captions, stat cards, layouts with exact text, transparent overlays. Free. It works only in workspaces where it is turned on. Each page must: 1. Load GSAP in <head>: <script src="https://cdn.jsdelivr.net/npm/gsap@3.14.2/dist/gsap.min.js"></script>. The only other script files allowed are gsap@3.14.2/dist/SplitText.min.js and lottie-web@5.13.0/build/player/lottie.min.js from the same CDN. Put all other code inline. 2. Have one root element with data-composition-id="main", data-width, data-height, data-start="0" and data-duration, and size body and root to width x height px. 3. Give each timed element class="clip", data-start, data-duration and data-track-index (higher is on top). 4. Drive all motion from one paused timeline: const tl = gsap.timeline({paused: true}); then window.__timelines = window.__timelines || {}; window.__timelines["main"] = tl; CSS animations, timers and anything off the timeline do not render. Use tl.set for instant changes. 5. Be deterministic: no Date.now(), Math.random() or fetches. Images, video and audio come only from links these tools returned. The page reaches no other site. A video layer is a muted <video>. Installed fonts: Inter, Poppins, Montserrat, Oswald, Jost, Archivo, Space Grotesk, Playfair Display, Bebas Neue, Anton, Outfit, Ubuntu and Noto (with the Indic scripts). Load other Google Fonts with their fonts.googleapis.com <link>. The root shows only a flat background-color. Put a gradient on a child. Independent scenes (the parts of a long video) start together in one call: generation_ids holds one id per scene, in order. A scene that needs another's output goes in a later call. wait_task returns each file as a media link. Where the chat app shows cards, show_generations with these generation_ids shows the work to the user. In one module one call's runs are in progress at a time, and module_busy is retryable.
ArgumentTypeDefault
jobs HtmlScene[] required
project_id string optional
module_id string optional

render_motion_graphics Writes · free

Render a motion-graphics clip from a template

Render a short motion-graphics clip from a built-in template: a title card, a lower third, caption lines, an end card, a countdown, or kinetic text. Free. The text is rendered by a browser, so it is exact; the whole page is written from the template — no HTML is accepted. Returns a generation id for wait_task. Where the chat app shows cards, show_generations with these generation_ids shows the work to the user. The clip is saved to the module's Library. In one module these runs (ffmpeg, motion graphics, HTML scenes, media analysis) go one at a time: while one is in progress, another started in the same module is refused with module_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run.
ArgumentTypeDefault
template string required
reason string required
title string optional
subtitle string optional
lines string[] optional
aspect_ratio string '9:16'
duration number 5
font string 'Inter'
accent string optional
background string optional
text_color string optional
count_from integer optional
count_to integer optional
project_id string optional
module_id string optional

run_ffmpeg Writes · free

Run an ffmpeg command

Run ffmpeg commands on media in a project: trim, join, resize, crop or pad, change speed, adjust brightness, contrast or colour (eq), overlay, mix in a voiceover or music, burn captions, extract audio. Free. Each job is the caller's own command line (argv), run against a private workspace holding its inputs and sidecars; its declared outputs come back as media links. A job runs in a sandbox with a time limit. The normal sandbox safety screen checks the complete command and sidecars before execution, with no separate FFmpeg capability allowlist. An .ass sidecar with the `ass` filter renders text captions more reliably than drawtext. jobs holds 1 to 5 independent jobs, started together and run side by side. Returns generation_ids at once, one per job in the order given; wait_task reads each job's result, which is also saved to the module's Library. Where the chat app shows cards, show_generations with these generation_ids shows the work to the user. A job that needs another's output goes in a later call, once that one has finished. Tested commands, the rules every job follows and what each failure means: get_skill("ffmpeg-recipes"). In one module one call's runs are in progress at a time: while they run, another run started in the same module (ffmpeg, motion graphics, HTML scenes, media analysis) is refused with module_busy, which is retryable. Other modules are unaffected, and generate tools in the module still run.
ArgumentTypeDefault
jobs FfmpegJob[] required
project_id string optional
module_id string optional
request_text string optional

save_note Can overwrite · free

Save a module's note

Save a note in a module (scenes, cast, a shot list), or change part of one. Free. Each module keeps a JSON tree of notes, shared with the web app (list_notes and read_note read it). Only the module's own notes are written; the project-level notes and other modules are read-only. Each entry under /characters, /locations or /props is also listed by list_references as a reference of the project, named by its name field or its key, with no images until save_reference adds it. The value merges at path: an object merges into the object there, its keys replacing the same keys, null removes the key it lands on, and missing parent objects are created. A save that would replace an object with a value is refused unless overwrite is true, which replaces the value at path. /assets holds the web app's own records: they cannot be saved over, and only annotations on existing records can change. The result has path, bytes (the size of the top-level value afterwards) and created (true when a new top-level key was made, which can mean a mistyped path); corrections lists any input that was repaired, such as a list stored as keyed objects. Writes in one module apply one at a time; while an ffmpeg, HTML-scene, motion-graphics or media-analysis run is in progress there, a save is refused with module_busy, which is retryable. A save not finished within about 20 seconds returns status running with generation_ids, and wait_task reads its result.
ArgumentTypeDefault
path string required
value any required
project_id string optional
module_id string optional
overwrite boolean False
request_text string optional

save_reference Can overwrite · free

Save a reference to a project

Save a recurring person or pet, place, or product or object to a project, so later shots reuse its look. Free. It is added to the project's Reference Library as a character, location or prop, shared by every module of the project and shown in the web app. A name already saved as that kind is not added again: its images are left as they are, a character's voice is set when given, and the result says so (saved false). The result has kind, name, saved and, for a character, voice_id.
ArgumentTypeDefault
kind 'character' | 'location' | 'prop' required
name string required
image_urls string[] required
project_id string optional
module_id string optional
description string optional
voice_id string optional

save_skill Can overwrite · free

Save a skill

Save a skill, or one of its files: create it or overwrite it. Free. It is then listed by list_skills, marked made_by workspace, and runs with get_skill like any other skill. The make-skill skill, via the get_skill("make-skill") tool call, gives the format and the steps for writing a good one. Without path, text is the skill's main text: the first save creates the skill and needs title, summary and when; a later save with the same skill_id overwrites it, and any of title, summary and when left out keeps its saved value. Its files are kept. With path, text is that one file of a skill already saved, created or overwritten. A save identical to what is saved changes nothing. The text names other skills, files and presets as full calls, such as get_skill(skill_id="review-shots"), get_skill(skill_id="<this id>", path="references/shot-list.md") or get_presets(preset_ids=["dolly-in"]). Every tool the text calls has to be a listed tool, and deleting tools are refused. A refused save writes nothing, and its hint names what to fix. Returns skill_id, title, summary, when, version, made_by, files and uses (with path: path and that file's uses), created (true for a new skill or file) and warnings: files of this skill the text calls that are not saved yet.
ArgumentTypeDefault
skill_id string required
text string required
path string optional
title string optional
summary string optional
when string optional

search_sound_effects Read-only · free

Search the sound-effect library

Search the library of ready-made sound effects. Free. A library sound is instant and free, where generate_sound_effect costs credits and takes time. Each result has an `id` to pass as sound_id to add_sound_to_library, and an `audio_url`, the sound file itself, which plays in a browser. An empty result means the library has nothing matching.
ArgumentTypeDefault
query string required
category string optional
max_duration integer optional
limit integer 8

search_voices Read-only · free

Search voices

Find voices for generate_speech in the user's voice library. Free. The filters (gender, age, language_code, accent) are exact matches, so a guessed value returns nothing rather than a near miss. Returns up to `limit` voices (max 20), best first, each with a voice_id for generate_speech and, where the voice has a recording, a sample_url that plays it in a browser. Voices cloned in the workspace are included, marked cloned: true, with yours: true on the user's own clones and false on other members'. The user's own clones rank ahead of other voices when there is no query or the query matches them.
ArgumentTypeDefault
query string ''
gender string ''
age string ''
language_code string ''
accent string ''
limit integer 8

send_feedback Writes · free

Send feedback to the Frameo team

Send feedback about Frameo to the Frameo team: a bug, a wrong result, a stuck task, a misleading tool description or skill, a feature request or a suggestion. Free. Feedback is specific enough to act on: what happened, or what would help and why. It can come from the user, who asked to send it, or from the assistant on its own when it meets a problem or a gap in these tools; trigger records which. A refusal whose hint explains it, such as an empty wallet, an expired quote or an argument the tool rejected, is Frameo working as intended rather than a problem. The team receives the title, description and type with the account, workspace, assistant app, project and module, and this connection's tool errors from the last hour. Nothing else from the conversation is sent. Returns report_id, which the team can look the feedback up by.
ArgumentTypeDefault
title string required
description string required
feedback_type string required
trigger string required
project_id string optional
module_id string optional
tool_name string optional

show_balance Read-only · free

Show balance

Show the workspace's balance, against what a request costs. Free. In chat apps that show widgets, the widget shows the balance and, given generation_quote, whether it covers that amount, with a Manage credits button that opens the web app signed in as this connection's user. After that button is used, the widget rechecks the balance every few seconds for up to 15 minutes, and once the balance covers generation_quote a Continue button lets the user carry on in the chat. The widget uses no credits. Where widgets are not shown, only the result below comes back. Returns the balance and, given generation_quote, short_by. Nothing is bought through this tool.
ArgumentTypeDefault
generation_quote integer optional

show_choices Read-only · free

Ask the user questions on a card

Ask the user up to 6 questions on one card, each answered with a tap. Free. Returns immediately; the user answers on the card afterwards, and the answers arrive as their next message. Use it whenever the user is to choose, decide or confirm something, or a step needs answers only the user can give: the options go in front of the user, and selected marks the one you recommend. A question written in your reply instead leaves the user typing. Put every question the next step needs in one call; call again only for one that depends on an earlier answer. Leave out what the user already said. Each question gives one of: - options: written options, for anything that is not a built_in setting. - generation_ids: finished work to pick between. - built_in: a setting whose options are filled in from what the model takes, so each one is valid: aspect_ratio (shape), duration (clip length), resolution, sound, model, count, voice, yes_no. Use it for these instead of options, even before a model is chosen. Example: questions=[{"id": "look", "question": "Which look?", "options": [{"label": "Rainy night"}, {"label": "Golden hour"}]}, {"id": "shape", "built_in": "aspect_ratio", "selected": "9:16"}] Answers: one question arrives as 'My pick for "<question>": <label>.' ("My picks" for several, "My answer" for typed text); a pick between generations names the chosen link. Several arrive as one message: "My answers: Look Rainy night · Shape 9:16." Cards shown earlier send the older "Picked: <label>" or "Look: Rainy night · Shape: 9:16". To keep the answers, save_note saves them in a module note. The result lists each question with its options as shown, notes on anything changed or left out, and without_card: the questions to ask in the chat where no card is displayed. Neither the call nor the card saves, spends or starts anything.
ArgumentTypeDefault
questions Question[] required

show_generations Read-only · free

Show generations

Show generations to the user as an interactive card in the chat, where the chat app supports MCP Apps, by their ids. Free. Returns immediately. A generation takes seconds to a few minutes, and a whole job tens of minutes. The card is shown as soon as the work starts: the user watches each generation's progress live and every result as it lands. It is for the user; wait_task is how the assistant gets updates and results. Called before wait_task, the card shows progress while wait_task waits. A card covers one wave of work: every generation started before the next wait_task, shown once with all their ids before that wait. The card updates itself as the work finishes and offers Download and Share on each finished item, so the same ids are not shown again. Every result the user should see goes on a card. One card covers the generations running at the same time. A single id makes a complete card when it is the only generation running. Each call adds a new card, so generations running together but shown one call at a time stack separate cards in the chat. Without MCP Apps support, only the result below comes back. Work already in a project, made in the web app, by a teammate or earlier, is shown by the media_id list_library gives each item, as finished. The result is wait_task's snapshot of those ids, without image previews. Generation ids that are not recognised are left off the card and listed in unknown_ids; the call is refused only when no id is recognised.
ArgumentTypeDefault
generation_ids string[] required
final boolean required
share_title string optional
share_description string optional

show_home Read-only · free

Frameo.AI

The home card, opened by the user from ChatGPT's sidebar or a conversation tab: the workspace and its credits, the newest projects, and the kinds of work there is a skill for. Free. Hidden from the model. The user writes what to make on the home, picks a project or a starting point, and the home posts it into the chat as the user's message; it spends nothing and starts no work. Returns workspace_name, credits (null when they are not reported), app_url (the web app) and projects: the newest few, each with project_id, name, module_count and its first module with an open_in_app link. It reads no Library, so it returns fast; poll_home adds each project's recent work. list_skills and list_models list the skills and models the card offers.

No arguments.

show_plan Read-only · free

Show a shot plan to approve

Show a shot plan for the user to approve before anything is generated. Free; returns immediately. The card offers Looks good and Change. The reply names the plan's stamp: "I approve plan <stamp> (<n> credits): <titles>. Go ahead and make it." (with total_credits), "I approve plan <stamp>: <titles>." or the older "Plan approved (plan <stamp>): ...". A change arrives as "Change shot <n> (plan <stamp>): <text>" or "Change the plan (plan <stamp>): <text>": update the plan and show it again. An older stamp means a replaced plan: act only on the latest. save_note keeps an approved plan in a module note. Approving a plan with total_credits agrees to that spend, so its waves run without asking again within the total (each still takes a fresh quote_id from estimate_cost); more, and every retake, needs a new yes. Make the shots with the approved camera, references, dialogue and aspect_ratio. The result has the plan, its stamp and without_card: without a card nothing was shown, so put the plan in the chat.
ArgumentTypeDefault
shots Shot[] required
total_credits integer optional
title string optional
notes string optional
aspect_ratio string optional

show_upload Read-only · free

Upload files

Open a card where the user picks files from their device to upload. Free. In chat apps that display cards, the card sends each picked file straight to storage through create_upload_url, files it in the project's Library through add_upload_to_library when a project is given, and then posts the files' file_url links into the conversation as a message from the user. Those links are accepted anywhere a media link is taken. This result does not contain the files: they arrive later, in that message, after the user picks them. Wait for it before any work that needs them, a quote included; calling show_upload again does not bring them sooner. Where cards are not displayed, nothing is uploaded and only the result below comes back. A file already attached in the chat goes through import_attachments instead, in apps that pass attachments on, such as ChatGPT. Returns accepts, the file extensions taken with each one's kind, content type and size limit in MB, and the project_id and module_id the files go to, if any.
ArgumentTypeDefault
project_id string optional
module_id string optional

switch_workspace Writes · free

Switch the workspace

Move this connection to another workspace the user belongs to, by its id from whoami's workspaces. Free. From the next call on, every tool works in that workspace: its projects, Library, voices and characters, and its credits are the ones spent. Quotes from estimate_cost that were not yet redeemed are discarded, since they priced work against the previous workspace. Work started before the switch belongs to the workspace that started it: wait_task reports its ids as unknown_generations, and their results are saved to that project only once the connection is switched back. Returns the workspace now active and its credits.
ArgumentTypeDefault
workspace_id string required

update_settings Writes · free

Save settings

Save a change made on this app's settings page in ChatGPT: set.workspace moves this connection to another of the user's workspaces, by its name as read_settings lists it. Free. Hidden from the model where the chat app supports app-only tools. It switches as switch_workspace does: from the next call on, every tool works in that workspace, and quotes not yet redeemed are discarded. Returns values, the settings now in effect.
ArgumentTypeDefault
set WorkspaceSetting required

upscale_image

Upscale an image

Make an image sharper and larger. Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. The image is measured. An upscale is priced by the model and the size the image becomes; estimate_cost with an image_upscale item of the same image_url, factor and model gives the credits and the quote_id this call redeems with confirmed_by_user. This enlarges an existing image; for a new or changed image, generate_images. Returns generation ids once the work is queued; wait_task returns the image when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The result is saved in the project; the finished result's open_in_app link opens it there.
ArgumentTypeDefault
image_url string required
factor number 2.0
model string optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

upscale_video

Upscale a video

Make a video sharper and higher resolution. Uses the user's credits. Paid: pass the quote_id estimate_cost returned for these settings (single-use, valid 15 minutes) and confirmed_by_user once the user has agreed to its credits; without them, or with other settings, the call is refused uncharged. When a call's outcome is unclear, send the same call again with the same quote_id: it returns the work already started, marked replayed, and charges nothing. Never take a new quote to recover a call; a new quote starts new work. The video is measured. Upscaling is priced by the model, the size the video becomes and its length, and is normally the last step, applied to finished clips. Returns generation ids once the work is queued; wait_task returns the result when it is ready. Where the chat app shows cards, show_generations with these ids shows the work to the user; wait_task returns it to the assistant. A wait_task timeout leaves the work running and the ids valid. The result is saved in the project; the finished result's open_in_app link opens it there.
ArgumentTypeDefault
video_url string required
factor number 2.0
model string optional
project_id string optional
module_id string optional
request_text string optional
quote_id string optional
confirmed_by_user boolean False

view_image Read-only · free

View an image or video frame

Look at an image, or one frame of a video, in enough detail to check it: read small text, count fingers, compare a face with its reference, spot artifacts. Free; nothing is generated, saved or charged. Takes a link one of these tools returned (generations, list_library, extract_frames, uploads, imports); any other link is refused, and import_media_url brings an outside file in first. A video link (.mp4, .mov) shows the single frame at at_seconds. Returns the picture as JPEG image content, scaled down to fit resolution (never enlarged), next to a short JSON block: media_url, kind (image or video_frame), max_edge (the resolution's limit, not the picture's own size), and at_seconds for a video. Other tools' results carry previews of at most 384 px; this is the larger view. image_unavailable means the picture could not be produced: the file does not exist or is not an image or video, or at_seconds is past the video's end.
ArgumentTypeDefault
media_url string required
resolution 'default' | 'high' | 'max' 'default'
at_seconds number 1.0

wait_task Read-only · free

Wait for generations to finish

Wait for generations: returns when any of them finishes, or after 25 s. Free. With timeout_seconds 0 it returns their current state at once. finished_during_wait lists the ids that finished or failed during this call. When nothing finishes within 25 s, it returns status 'running', with seconds_left when there is an estimate, and the work carries on unaffected. While status is 'running', call wait_task again with the same ids. Between waits, continue any other work; where the app can run a background task or agent, wait there. In chat apps that show cards, the user sees this work only on a show_generations card: one card per wave, with every id started since the last wait_task, shown before waiting on them. Without one, they see nothing while it runs, and a whole job (a batch of clips, a cut) takes tens of minutes across many wait_task calls. Work the service could not be reached to check comes back as 'unchecked', with a hint: it is unaffected, and the same ids can be checked again. Each failed generation carries reason: one short sentence on why it failed and what usually works instead, and refunded: true when its credits came back. A finished generation reports credits_charged (with credits_quoted and charge_note when the charge differed from the quote) and open_in_app. Ids from several calls can be checked together: the result then has one entry per call in `tasks`, each with its kind, generation_ids and status, and the top-level status is 'finished' once every entry is. A finished video, lipsync, upscale, speech, music or sound effect result has duration_seconds for each media link whose length was recorded. A finished image or video result carries small previews of its images and videos, and view_image shows one in full detail, so a result can be checked against the request before it is built on.
ArgumentTypeDefault
generation_ids string[] required
timeout_seconds integer 25

whoami Read-only · free

Check the Frameo connection

Confirm the Frameo connection: who is signed in, which workspace is active, and its credits. Free. email is the signed-in account's email. workspaces lists every workspace the user belongs to; switch_workspace moves the connection to another of them. credits is the active workspace's balance (the member's own limit where the workspace sets one), or null when it is not reported. spent_by_this_connection is what this connection has spent. account_url links the web app, where the account's credits are managed; nothing is bought through this tool.

No arguments.