acrobat_proxy
ChatGPTProxy for Adobe Document Cloud API calls with write/modify operations. This tool is for internal application workflows only. DO NOT USE this tool for any user-facing operations or general document processing workflows.
Creativity
Overview
Adobe unlocks more ways to create and get work done from the conversation. Previously available as Photoshop, the Adobe connector now brings creativity and productivity capabilities across Creative Cloud and Acrobat. Describe what you want to make or change, and Adobe can help turn ideas, images, videos, and documents into polished outputs — from editing photos and creating PDFs to designing social assets, resizing videos, searching Creative Cloud assets, and generating data-driven documents. Key capabilities: Retouch portraits or edit photos in bulk: Drop in photos and describe the look you want — adjust color, lighting, and tone; remove distractions and generate new elements; apply Lightroom presets; remove backgrounds; blur, crop, resize, and expand images. Design from template: Start from an Express template, update text and colors, and then animate for social media or convert to PDF. Refine video for any platform: Upload a horizontal clip and ask to reformat it for YouTube Shorts, Instagram Reels, or any platform. You can also stitch clips into a single sequence. Search and organize creative work: Describe what you're looking for and surface assets from your Creative Cloud library — by subject, style, mood, or content — without browsing folders. Work with PDFs and documents: Create and convert polished PDFs and documents. Create data-driven documents: Describe your output and provide your data — the connector turns raw data or content into formatted, shareable PDFs, including badges, cards, catalogs, and more. You can get started as a guest, and sign in with your Adobe account for more capabilities and tools, Creative Cloud storage, and saved work across sessions.
Tools
acrobat_readonly_proxy
ChatGPTRead-only proxy for Adobe Document Cloud GET API calls. This tool is for internal application workflows only.
adobe_home
ChatGPTOpen the Adobe creative hub.
adobe_mandatory_init
ChatGPTCALL ONCE per chat session before using any adobe tool (acrobat_proxy, acrobat_readonly_proxy, animate_design, asset_copy_assets, asset_create_folders, asset_finalize_file_upload, asset_get_mime_type, asset_get_presigned_url, asset_get_presigned_urls, asset_initialize_file_upload, asset_inline_preview, asset_license_and_download_stock, asset_lr_get_presigned_url, asset_migrate_guest_storage, asset_openai_file_upload, asset_preview_file, asset_resolve_short_url, asset_search, boards_add_items_to_board, boards_create_new_board, change_background_color, convert_pdf_to_indd, document_convert_pdf, document_merge_data_layout, document_merge_data_vector, document_render_layout, document_render_vector, download_design, enhanceSpeechPoll, export_idml, fill_text, font_activate, font_create_kit, font_details, font_preview, font_recommend, font_search, font_similar, font_styles, generate_indd_mapping_prompt, image_apply_adjustments, image_apply_auto_tone, image_apply_effects, image_apply_lens_blur, image_apply_preset, image_auto_straighten, image_crop_and_resize, image_crop_to_bounds, image_fill_area, image_generate, image_generative_expand, image_get_presigned_urls, image_get_task_status, image_instruct_edit, image_invert_selection, image_list_presets, image_open_file_app, image_remove_background, image_remove_blemishes, image_select_by_prompt, image_select_subject, image_vectorize, interactive_image_apply_adjustments_app, interactive_image_apply_effects_app, interactive_image_blur_background_app, interactive_image_edit_preview, interactive_image_get_context, interactive_image_get_options_for_adjustments_app, interactive_image_remove_background_app, interactive_image_undo_edits_app, interactive_image_uploader_app, log_analytics, markdown_to_pdf, media_enhance_speech, media_summarize, pdf_compress, pdf_create, pdf_edit_ui, pdf_export, pdf_file_open, pdf_highlight, pdf_ocr, pdf_operation_status, pdf_properties, pdf_to_image, pdf_to_markdown, pdf_viewer, prepare_indd_merge_template, quickCutPoll, replace_image, resizeVideoPoll, search_design, summarizePoll, vectorPollingHelper, videoMetadataPoll, videoRenderFramePoll, videoRenderPoll, video_create_quick_cut, video_metadata, video_render, video_render_frame, video_resize). Do NOT call again unless this tool's response is no longer in your context window. Returns file handling rules and tool routing guidance.
animate_design
ChatGPTAnimate an Express design with motion effects. WHEN TO USE: "animate this", "make it move", "add animation to the design". WHEN NOT TO USE: Only works on Express designs.
asset_copy_assets
ChatGPTCopy one or more assets within Creative Cloud storage. WHEN TO USE: "copy this to another folder", "duplicate asset", "copy to project".
asset_create_folders
ChatGPTCreate one or more folders in Adobe Creative Cloud Files storage for organizing assets. WHEN TO USE: "create a folder", "make a new folder", "set up project folders", "organize my files", creating destination folders before copying/moving assets, setting up project directory hierarchies. WHEN NOT TO USE: For uploading files -> use asset_openai_file_upload for ChatGPT-native file uploads. USAGE: - Folders can be created at root level (home directory) or nested within existing folders. - Use forward slashes to create nested hierarchies in one call (e.g., "myAssets/2024/Q4-Campaign" creates three nested folders). - If a folder with the same name already exists, a numbered suffix is automatically added (e.g., "MyFolder", "MyFolder (1)"). LIMITATIONS: Cannot create folders in Libraries or Brands (only in Files storage). Folder names must follow Adobe naming conventions. OUTPUT: Returns folder ID (assetId), folder name (may differ from input if renamed due to conflict), and creation metadata.
asset_finalize_file_upload
ChatGPTCompletes a block upload and creates the file asset after chunk transfer finishes. What this tool does: Sends the completed transfer document to RAPI to confirm all blocks were received and create the asset. Handles asynchronous finalization automatically (polls the monitor URL until the asset is ready). When to call this: After all blocks have been successfully PUT to their block transfer URLs from
asset_initialize_file_upload. Pass the transfer_document from init, updated so _links["http://ns.adobe.com/adobecloud/rel/block/transfer"] lists only the block links you actually used (same objects or { href } entries). Keep the finalize link from the init response. Optionally set repo:md5 for integrity verification. Returns: - assets: array containing the created asset (currently one asset per finalized upload) - Each asset includes ID, name, media type, and presigned URLs when available Important: - This is a mutating operation and should be called once per initialized upload session - For retries after uncertain network failures, expect backend conflict handling (for example filename renaming)asset_get_mime_type
ChatGPTInternal helper for the preview file UI: fetches HTTP headers for a URL and returns the Mime-Type parsed from the Content-Type header.
asset_get_presigned_url
ChatGPTRetrieves presigned download URLs for PNG renditions of Adobe Creative Cloud assets. WHEN TO USE: "give me a download link", "get download URL" — only when context has a URN (urn:aaid:...) and no presigned URL is available. WHEN NOT TO USE: - If context already has a presigned URL (https://cc-api-storage.adobe.io/... or similar), use that URL directly.
asset_get_presigned_urls
ChatGPTResolve presigned S3 URLs for Lightroom/ACP assets by id. Fallback for when you have an asset id but no auth-free renditionURL — asset_search results already include auth-free renditionURLs, so use those directly. Pass the full array of LR/ACP assets — all are resolved in parallel in one call. WHEN TO USE: When you have a Lightroom or CCAsset id but no auth-free renditionURL (e.g. not from asset_search, or resolution failed) and need a usable URL for asset_preview_file, asset_inline_preview, or an edit tool. WHEN NOT TO USE: For StockAsset results — renditionURL is a public CDN URL, safe to use directly. For assets loaded via the file picker — presignedAssetUrl is already resolved. INPUT: assets array — each item needs id and sourceType from search results. Include renditionUrl and mediaType if present. OUTPUT: assets array in the same order as input — each item has id, renditionUrl, downloadUrl, previewUrl. Always use previewUrl for asset_preview_file, asset_inline_preview, and edit tool inputs. Items where resolution failed have null URLs. EXAMPLE: asset_get_presigned_urls({ assets: [ { id: "<id>", sourceType: "lightroom", renditionUrl: "<renditionURL from search>" }, { id: "<id>", sourceType: "acp", renditionUrl: "<renditionURL from search>" } ] }) → { assets: [{ id, renditionUrl, downloadUrl, previewUrl }, ...] }
asset_initialize_file_upload
ChatGPTStarts a new block-based upload session for a file in Adobe Creative Cloud storage. What this tool does: Resolves or creates the destination directory and returns ordered pre-signed block transfer URLs plus the finalize URL required to complete upload. This is a mutating operation that allocates an upload session. When NOT to use this tool: - Uploading a file to a Project. Path behavior: - If
path is just a filename (e.g. "photo.png"), the file is placed directly in cloud-content/. - If path includes a directory (e.g. "my-project/photo.png"), the path is interpreted relative to cloud-content/ and any missing intermediate directories are created automatically. - Do not include cloud-content/ as a prefix — it is added automatically. Block transfer: Use transfer_document['repo:blocksize'] as the chunk size (last chunk may be smaller). Read pre-signed PUT targets from transfer_document._links["http://ns.adobe.com/adobecloud/rel/block/transfer"] (array of link objects with href). PUT each chunk in order. Do not send an Authorization header on block transfer requests. Returns: - filename: resolved filename — pass to finalize_file_upload - directory_asset_id: destination directory asset ID - transfer_document: RAPI bulk transfer document from block/init (includes repo:blocksize, block transfer / finalize / extend links under _links). After uploading blocks, replace the block/transfer link array with only the links you used (same href values), then pass the updated document to asset_finalize_file_upload. Important: - Call this once per upload intent; repeated calls create separate upload sessions - shorten_block_upload_urls defaults to true so transfer/finalize URLs stay compact in context; AI agents should leave it true.asset_inline_preview
ChatGPTFetch image bytes from a presigned URL and return base64 content for direct model inspection and analysis. WHEN TO USE: - "describe what's in this image", "what does this image show", "analyze this image" - "compare these images", "which image is sharper/better" - Any request requiring the model to SEE AND UNDERSTAND image contents. WHEN NOT TO USE: To show/display an image to the user -> use asset_preview_file instead. CRITICAL: Use this tool, not asset_preview_file, when you need to describe, analyze, or compare image contents. asset_preview_file only displays the image to the user; it does not let the model inspect it. INPUT: Presigned HTTPS URL. For assets from asset_search, renditionURL is directly usable — pass it directly. For tool output URLs, such as image editing outputs, or download URLs, such as asset_download_firefly_generation, pass those directly.
asset_license_and_download_stock
ChatGPTLicense an Adobe Stock asset and obtain a full-resolution download URL. WHEN TO USE: After the user has found a specific Stock asset via search and wants to acquire it or use it in subsequent editing workflows. Stock assets must be licensed before use in any editing workflow. WHEN NOT TO USE: Do not fall back to rendition or thumbnail URLs - always license first. NOTES: The returned download URL is a presigned S3 URL valid for 1 hour. Re-calling this tool on an already-licensed asset just refreshes the URL without consuming an additional license.
asset_lr_get_presigned_url
ChatGPTInternal helper: resolves presigned S3 URLs for one or more Lightroom assets via the Oz direct_links API. Returns presignedRenditionUrl (best available rendition) and presignedAssetUrl (master file) for each asset.
asset_migrate_guest_storage
ChatGPTOne-time migration: copies assets from the session's guest storage directory into the authenticated user's storage directory (same path used after sign-in). When to use this tool: - After a guest user authenticates, to recover files that were uploaded while unauthenticated Returned data: -
assetsTransferred: count of assets that copied successfully (HTTP 2xx). The tool succeeds when this count is positive, when there were no assets to migrate, or when guest storage already matches authenticated storage. The tool fails only when there were assets to migrate and every copy failed.asset_openai_file_upload
ChatGPTStreams bytes from a URL provided by the 'fileParams' extension into Adobe Creative Cloud Files at the given path using Bartlebee (server-side; no client upload of raw bytes). Do not choose, invent, or add a destination folder/path. By default, upload files to the connector’s default Adobe destination. Only provide path when the user explicitly specifies an Adobe destination folder, upload path, or exact filename/path. When the user simply says “upload these files to Adobe,” omit path. Input: -
files: array of file specifiers for upload. The schema of each entry adheres to the OpenAI 'fileParams' spec as documented below - path: optional directory path extending from the cloud-content/OpenAI root. Do not choose, invent, or add a destination folder/path. By default, upload files to the connector’s default Adobe destination. Only provide path when the user explicitly specifies an Adobe destination folder, upload path, or exact filename/path. When the user simply says “upload these files to Adobe,” omit path. File Specifiers The file specifiers use the openai/fileParams extension schema. Each entry must adhere to the following: - download_url: pre-signed or unauthenticated HTTP URL source for the input file - file_id: Stable ChatGPT file identifier (e.g. "file_...") - mime_type: MIME/media type for the incoming file - file_name: Original file name of the asset, when known. Must include extension (e.g. "document.pdf") Path behavior: - path is optional. It should not be provided unless the user makes a specific request to upload the assets to a specific folder. - path is interpreted relative to cloud-content/OpenAI. Do not include cloud-content/OpenAI as a prefix — it is added automatically. - If path is just a filename (e.g. "photo.jpg"), ignore it in favor of the file's file_name. - Any leading / will be trimmed from the path - If path includes a directory and name (e.g. "my-folder/photo.jpg"), truncate to just the directory - If path is a nested directory (e.g. photos/animals/dogs), the assets will be created at the end of the path (in dogs, citing the example). Returns: assets array with the created file (asset id, name, presigned download URL, etc.).asset_preview_file
ChatGPTShow/display/preview Adobe tool output to the user. WHEN TO USE: - After image_remove_background/image_generate/image_vectorize/any Adobe tool returns output_url AND user asks to see results. - After asset_search returns results and the user wants to see/view/preview them. This is the correct tool for showing search results to the user — NOT asset_inline_preview. asset_inline_preview is for the model to describe, analyze, or compare image content, not to display it. INPUT: {assets: [{presignedAssetUrl: "<output_url from previous tool>"}]} CRITICAL: Use this MCP tool instead of simulated curl/Read/Bash to display Adobe results.
asset_resolve_short_url
ChatGPTInternal helper for the preview file UI: follows a shortened URL redirect and returns the resolved long URL.
asset_search
ChatGPTSearch for Adobe assets across multiple sources: Creative Cloud files including Adobe Express documents and designs (CCAsset), Document Cloud PDFs (DCAsset), Lightroom photos (LightroomAsset), Adobe Stock (StockAsset), or Firefly generations (GenAIAsset). Set entityScope to exactly one source per request. WHEN TO USE: "search stock", "find stock images", "stock photos", "find my files", "search Creative Cloud", "find my Express files", "find my Express decks", "find my Express documents", "find my Express designs", "find my presentations", "find my decks", "find my Lightroom photos", "find my sunset photos", "find my X photos and edit them", "find my Firefly generations", "search my PDFs". CRITICAL: When user says "find my [description] photos", use this tool to search - do NOT open file picker. WHEN NOT TO USE: To find Adobe Express templates to start a new design from scratch (blank flyers, posters, cards) -> use search_design instead. To search the user's OWN existing/saved Express files or designs -> use this tool with entityScope CCAsset. USAGE: entityScope-specific filters: - CCAsset: filters.mediaType, filters.directoryIds, filters.owner, filters.sharedWith. Sort by name, createDate, modifyDate. Covers Creative Cloud files and Adobe Express documents/designs. - StockAsset: filters.pricing ("free"/"core"), filters.contentType ("Photo"/"Video"/"Vector"/"Illustration"), filters.orientation ("landscape"/"portrait"). - LightroomAsset: query only (e.g., "sunset from last week"). No filters. - GenAIAsset: filters.mediaType, filters.assetClass, filters.owner. Next steps after search: - If the user requests to preview a selection of assets, pass an assets array to asset_preview_file. - Show results -> list assets by name and type. - For LightroomAsset or CCAsset results: renditionURL is auth-free — pass it directly to asset_inline_preview or edit tools. - For StockAsset results: renditionURL is a public CDN URL, safe to pass directly to asset_inline_preview. License with asset_license_and_download_stock before editing. - Use Stock asset in editing -> call asset_license_and_download_stock first.
boards_add_items_to_board
ChatGPTAdd 1-12 images to an existing Firefly board. PREREQUISITE — board_id is required: - If you do NOT already have a boardId in context, FIRST call boards_create_new_board to get one, then call this tool with that board_id. Never invent or guess a board_id. - If you already have a valid boardId from earlier in this conversation, reuse it. ITEM TYPES — pick the lightest one the client can produce reliably: - presignedUrl : { type, urls: string[] } — time-limited https URLs the server fetches. PREFERRED. - generationUrn : { type, assetIds: string[] } — Firefly generation URNs (carry provenance). PREFERRED. - rawBlob : { type, bytesBase64, mimeType, width, height } — USE WITH CAUTION from chat/LLM clients: large base64 is often truncated and the call fails with a decode error. Each url / assetId expands to one image placement. Total placements across all entries must be 1-12. SVG / vector formats are not supported. INTERPRETING THE RESPONSE (do not retry on partial success): - HTTP 200: all images were added. Done. - HTTP 201: PARTIAL success — some added, some not. This is SUCCESS, not an error.
failedItems[] lists ONLY the items that failed (logicalIndex, stage, errorCode, errorMessage ending in "(item: <id/url>)"). Re-send ONLY the failed items after fixing the named cause; never resend ones that already succeeded. - HTTP 422: NONE could be added (message inlines the first few failures). Fix inputs and retry. OTHER ERRORS (isError: true, body = { status, ...details }): - 400 invalid payload or >12 images; 401 auth; 404 board or asset not found (if the board_id is wrong or expired, create a new board and retry); 413 too large; 415 unsupported media type; 502 upstream fetch/persistence; 503 busy (retry shortly); 504 timeout. Fix the request for 400/401/404/415; a single retry is reasonable for 503/504. GUIDANCE: prefer presignedUrl / generationUrn over rawBlob. If a rawBlob call fails with a decode error, the image was likely truncated — upload it and retry with a URL/URN type.boards_create_new_board
ChatGPTCreate a new Firefly board and return its boardId. WHEN TO CALL: - Call this whenever you do NOT already have a boardId in the current context. - The boardId it returns is REQUIRED by boards_add_items_to_board. Typical flow: 1) boards_create_new_board -> get boardId 2) boards_add_items_to_board(board_id = that boardId, items = [...]) - If you already have a valid boardId from earlier in this conversation, REUSE it instead of creating another board (don't create duplicates for the same task). INPUT: - doc_name (string, required): a human-readable name for the board (e.g. "Mood board", "Q3 launch"). ON SUCCESS: - Returns { boardId: "<urn>", boardUrl: "<url>" }. Remember boardId and pass it to boards_add_items_to_board. boardUrl is a shareable link to the board in the Firefly Boards web app — surface it to the user when linking back to the board is useful. ON FAILURE (isError: true, body = { status, ...details }): - 400 : doc_name missing/empty — supply a non-empty name and retry. - 401 : auth missing/invalid — not user-correctable; surface the error. - 503 : service at capacity (body includes a retry hint) — wait briefly and retry once. - 504 : creation timed out — retry once; if it persists, surface the error. - 500 / 502 : upstream/worker failure — retry once, then surface the error. Do NOT retry 400/401 without changing the input/auth.
change_background_color
ChatGPTUpdate the background color of an Express design. WHEN TO USE: "change the background to blue", "make the background white", "use a darker background". WHEN NOT TO USE: Only works on Express designs.
convert_pdf_to_indd
ChatGPTConverts a PDF into an InDesign (.indd) file for use as a variable-data merge template. WHEN TO USE: When the source template is a PDF that needs to be prepared for a data merge workflow. WHEN NOT TO USE: For general PDF-to-InDesign editing. Returns presigned .indd URL(s).
document_convert_pdf
ChatGPTConvert a PDF to an editable InDesign file (INDD or IDML). WHEN TO USE: "convert PDF to InDesign", "edit this PDF layout", "make PDF editable in InDesign", "PDF to INDD". NOTES: Returns a ZIP containing the document and linked assets. Requires login.
document_merge_data_layout
ChatGPTBatch-produce multiple InDesign documents by merging CSV rows into an .indd template, then export as PNG, JPEG, or PDF. WHEN TO USE: "generate personalized documents", "data merge InDesign", "batch create from CSV", "variable data publishing", "merge data into template". NOTES: One output file per CSV row. Requires an InDesign subscription.
document_merge_data_vector
ChatGPTBatch-produce multiple AI/PNG/SVG/JPEG/PDF files by merging CSV rows into an .ai template — e.g. personalized certificates, product labels, or localized assets. WHEN TO USE: "data merge Illustrator", "batch create certificates", "generate product labels from CSV", "variable data in Illustrator". NOTES: Requires an Illustrator subscription.
document_render_layout
ChatGPTExport an InDesign document (.indd or .idml) as PDF, JPEG, or PNG with page range and resolution control. WHEN TO USE: "export InDesign", "publish this InDesign layout", "InDesign to PDF", "render INDD as JPEG", "convert InDesign file". INPUT: Requires an .indd or .idml source file URL.
document_render_vector
ChatGPTExport one or more Illustrator (.ai) files as PNG, JPEG, SVG, PDF, AI, or EPS with artboard and resolution control. WHEN TO USE: "export Illustrator file", "save .ai files as PNGs", "convert Illustrator to PDF", "render AI files", "export this Illustrator file as PNG", "Illustrator to PNG", "AI to JPEG". CRITICAL: When the user has uploaded an .ai file and asks to export/convert/render it, use THIS tool immediately. Do not open the file picker again. NOTES: Requires an Illustrator subscription.
download_design
ChatGPTExport (download) an Adobe Express design as PDF. Use this tool when the user asks to download/export the current design. Notes: - Only PDF format is supported. - The tool returns pre-signed URLs for each exported page.
enhanceSpeechPoll
ChatGPTPoll for Completion of enhanceSpeech tool
export_idml
ChatGPTExports an InDesign (.indd) document to IDML format for document structure analysis. WHEN TO USE: When a presigned .indd URL needs to be analyzed for frame layout and field mapping before creating placeholders. WHEN NOT TO USE: For publishing or rendering the document as PDF/image. Returns a presigned IDML download URL.
fill_text
ChatGPTFill placeholder text fields in an Adobe Express design template with specific content. WHEN TO USE: "put my company name here", "add the date to this invite", "update the headline" - ONLY when working with an Express design template (from search_design). WHEN NOT TO USE: - Only works on Express designs opened via search_design LIMITATIONS: Replaces text content ONLY. Does NOT support: font color, font size, font family, bold/italic styling, or text alignment changes.
font_activate
ChatGPTResolve a font identifier to a Typekit id (if not already known) and add exactly ONE font to the user's Creative Cloud library. There is no bulk/batch mode — call this tool once per font, even when adding several. Scope: this makes the font available inside Adobe apps (Photoshop, Illustrator, InDesign, Express, etc.) via Creative Cloud sync. It does NOT install the font as an OS-level/system font usable by non-Adobe apps, and it does not download a font file to the caller — there is only one persistence mode and it is not caller-configurable.
font_identifier is required, e.g. {"postscript_name": "...", "font_id": "..."} from a recommended font's nested result returned by the font-recommendation tool. Supplying font_identifier.font_id when already known is used directly; when only font_identifier.postscript_name is given (font_id is None), it is resolved first. Successful JSON includes: `success` (bool), `user_message` (plain-language outcome for the end user—read this first), `steps` (variations + selections with ok per step), `summary` (technical flow), `variation_step`, `selections_step`, `selections_result`, and an `error_code` when something went wrong (invalid_input, not_authenticated, not_entitled, not_found, upstream_error, or upstream_timeout for a retryable transient failure — a timeout, connection error, or 5xx). On failure the response is {success, error_code, user_message} (plus steps/summary for context) — there is no error or status_code key in the response body. Re-adding a font the user already has does not create duplicates; the call is treated as a no-op and reflected in user_message ("added or was already present in your library"). Requires the caller to be authenticated (via OAuth, or the optional bearer_token arg for a caller that already holds a token). Anonymous adds are never allowed: when no usable token is available, this returns error_code="not_authenticated". not_authenticated and not_entitled are kept distinct: an auth/scope problem (an expired or under-scoped token that a plan upgrade can't fix) is error_code="not_authenticated", while a plan that doesn't include the font is error_code="not_entitled", with an actionable user_message naming the plans (Fonts Standard or Fonts Pro) that unlock it. A PostScript name that matches no font is surfaced as error_code="not_found", not not_entitled.font_create_kit
ChatGPTCreate and publish a real Adobe Fonts (Typekit) kit — a CSS/JS embed bundle — for one or more fonts, so they can be embedded on a website. The kit is created under the caller's own Adobe Fonts account and is visible/manageable at fonts.adobe.com, unlike the legacy "Instant Kit" mechanism (which Adobe's own guidance treats as deprecated for exactly this job). Scope: this is for embedding fonts on a website (a <link>/<script> embed via kit id), not for Adobe apps (see the library-add tool for that) and not for OS-level font install. Up to 10 fonts per call — a kit represents one site's font system, commonly 2-4 fonts, not a bulk-activation mechanism.
domains is a list of site domains this kit will be used on — localhost, file://..., a bare dev hostname with a port, or a normal https://example.com are all accepted. Values are trimmed and blank entries dropped; there is no URL/hostname format validation beyond a basic length and safe-character check. All-or-nothing entitlement: every requested font must be found and entitled to the caller's current Adobe Fonts plan. If even one font fails either check, NO kit is created at all — the whole call is rejected with the specific failing font(s) named, rather than silently creating a kit with fewer fonts than asked for. font_identifiers is a list of {"postscript_name": "...", "font_id": "..."} (font_id optional, e.g. from a font-recommendation tool result). kit_name is optional; if omitted, a human-readable name is generated from the first font's family name, the font count, and the first domain, so the kit is recognizable when the caller looks it up later at fonts.adobe.com. locale (default en_US) selects the language the font family names are translated into, and affects only that auto-generated default kit name (when kit_name is omitted) — the kit's fonts, domains, and entitlement are unaffected, and an explicit kit_name ignores it entirely. Pass a region-qualified value (en_US, ja_JP); hyphen, bare-code, and region-mismatched variants are normalized to the closest supported locale, and an unsupported value falls back to en_US rather than being rejected. See this server's MCP instructions for the list of supported locales. Successful JSON includes: `success` (bool), `user_message` (plain-language outcome), `steps` (per-stage ok), `summary` (technical flow), and `kit` (the created/published kit: id, name, domains, families, and the embed snippets — css_embed_code, embed_code, advanced_embed_code). On an all-or-nothing rejection, `kit` is null and `failures` lists each rejected font as {"postscript_name", "reason"} where reason is "not_found", "not_entitled", or "upstream_error" (found and entitled, but missing data needed to add it to a kit). Requires a Bearer token with tk_platform OAuth scope (via OAuth, or the bearer_token arg) — the same requirement as the library-add tool. Anonymous callers are refused with error_code="not_authenticated"; the same code is used if the token is missing the tk_platform scope, since that is an authentication problem, not an entitlement one. error_code is null on success. Other values: invalid_input, not_entitled, not_found, upstream_error. If kit creation succeeds but publishing fails, the response still includes the created (unpublished) kit.id so the caller isn't left with an invisible orphaned kit. Suite-wide error contract, with one intentional exception: error_code, when non-null, is always one of the canonical codes shared by every tool in this server (invalid_input, not_found, forbidden, not_authenticated, not_entitled, upstream_error, upstream_timeout, response_too_large). Unlike the six failure-only read tools (details/styles/similar/recommendations/search/preview), which only carry user_message alongside error_code on a failure, this tool's response is a combined success/failure envelope — user_message is the human-readable outcome on every call, success included, not just failures. **Not safe to blindly retry on a netw…font_details
ChatGPTLook up authoritative Adobe Fonts metadata for one or more fonts — text only, no image; this does not show what a font looks like — if a font-preview tool is available on this surface, use it instead for a visual specimen (its own docstring links back here for the reverse case). Args: font_identifiers: Fonts to look up. Each requires postscript_name; font_id is optional. The lookup has no combined-key mode — it resolves by exactly one identifier per request — so when both are given, font_id is tried first (it's the more precise identifier when valid), and postscript_name is tried as a fallback only if that specific font_id lookup fails. Either one resolving is enough; they are not cross-validated against each other, so if both are given and disagree, the result silently reflects whichever one succeeded — check the returned resolved_via if you need to know which. A malformed postscript_name is only rejected as invalid_input when font_id is absent; when font_id is present, a malformed postscript_name is simply not attempted as a fallback candidate — no error is raised about it specifically, so a failure in that case doesn't distinguish "font_id failed, postscript_name was fine but didn't match" from "font_id failed, postscript_name was malformed and never tried." postscript_name must match exactly, including case — this lookup does not fuzzy-match or case-normalize (e.g. "myriadpro-regular" will not resolve "MyriadPro-Regular"). Use an exact value, such as one already returned by the font-recommendation tool, rather than guessing from a display name. locale: Language the returned font family/style names (and recommendation/search group names) are translated into, when a translation is available (default en_US). Hyphen, bare-code, and region-mismatched forms are all normalized to the closest supported locale (e.g. ja-JP and ja both become ja_JP; en_GB becomes en_US); an unsupported value falls back to en_US rather than being rejected. See this server's MCP instructions for the list of supported locales. Returns: JSON string with a
results list, one entry per requested font, in the same order as the input. Each entry is either resolved metadata (family_name, style_name, full_name, designers, foundry, detail_url, preview_url, language_support, library_availability, weight, style, is_variable_font, axes, resolved_via, requested, and a font_identifier or bare postscript_name) or {"postscript_name": ..., "error_code": "<code>", "user_message": "...", "requested": {...}} where error_code is one of invalid_input, not_found, upstream_error, upstream_timeout, and user_message is human-readable text safe to show the caller as-is. weight is the numeric OpenType weight class (e.g. 400, 700); the same class can look visually different across different families. style is "normal" or "italic". Use these rather than inferring boldness or slant from style_name or postscript_name text. is_variable_font is always present (true/false). axes is present exactly when is_variable_font is true (and only then) -- always a list, though it may be empty ([]) for a variable font that exposes no usable named instances -- a list of axis tags (e.g. ["wght", "wdth"]) this font exposes — tags only, deliberately no min/max/default. This tool has no access to the font's true axis range, so it doesn't claim numeric ranges it can't verify — only that these axes exist. Do not guess at or state a specific min/max/default for an axis from this tool's output. resolved_via is "font_id" or "postscript_name" — whichever identifier actually produced this result. When only one was supplied it's that one; when both were supplied it tells you which one decided the outcome, since they aren't cross-validated against each other. requested ({postscript_name, font_id — font_id present only if you supplied one}) is always present, on every entry, success or error, echoing exactly what you sent for that entry (not the resolved identity) — use it to match a result back to its request after filtering, reordering, or merging results downstream, rather than relying on array positio…font_preview
ChatGPTDISPLAY-ONLY: renders fonts as inline visual specimen cards; it does NOT recommend or find fonts. You MUST first call font_recommend, font_search, or font_similar to get real fonts, then pass a real font identifier here. If both font_id and postscript_name are supplied, font_id takes precedence — NEVER invent font identifiers or call this without fetching real ones first. Pass every font you want to preview together in one call as a font_identifiers list (up to 10 entries) — do not call this tool once per font. WHEN TO USE: after font_recommend, font_search, or font_similar, to show what each font looks like; or when the user says 'show this font', 'preview this font', 'what does this font look like'. The returned card reflects the font that resolved and includes resolvedVia when applicable. On success, cards render automatically — reply with nothing, and never narrate this tool, its arguments, or how the call must be shaped in chat. On failure, briefly tell the user the preview could not be generated and why (e.g. font not found), without narrating tool internals.
font_recommend
ChatGPTGet font suggestions for a creative project or brand context. WHEN TO USE: "what fonts would work for X", "suggest fonts for a logo", "font recommendations", "what font should I use", "recommend fonts", "font advice", "fonts for [any project/brand/purpose]".
font_search
ChatGPTSearch the Adobe Fonts catalog for specific fonts. Use this to look up fonts by a free-form query and/or facets (foundry, designer, style, writing system), with sorting and pagination. For open-ended "what font should I use for X" design questions, prefer the font-recommendation tool.
user_query and the facet filters (foundry, designers, styles, moods, topics, font_group, writing_systems, exclude_variable_fonts) combine: the query is the search text and each facet narrows the matches, so supplying more of them tightens the result set rather than broadening it. The minimal call is a single user_query or one facet; sort orders the matches and page/per_page page through them. Args: user_query: Free-form text query (max 150 characters) doc_type: Document type (e.g., 'postcard', 'Instagram post', 'movie poster') styles: Comma-separated list of styles moods: Comma-separated list of moods topics: Comma-separated list of design topics font_query: Set true when user_query is (or contains) a specific font/family NAME the user wants to find (e.g. "Acumin", "Minion Pro"), rather than a descriptive query. This performs a literal name search: the matching family's styles are ranked to the top. Leave false for descriptive/semantic queries. text_hierarchy: Text focus ('heading' or 'body'); unrecognized values are dropped and ignored rather than rejected selected_font: PostScript name of a selected font for similarity foundry: Comma-separated foundries to filter by designers: Comma-separated designer names to filter by library: Font library ('full' or 'trial'); unrecognized values (e.g. 'adobe_fonts') normalize to 'full' rather than being rejected. 'trial' is always honored as requested. 'full' is clamped server-side to the caller's real Adobe Fonts entitlement (via OAuth context, bearer_token, or a server-configured fallback) — a free-tier caller cannot widen their catalog by passing 'full'; with no resolvable identity the effective value is 'trial'. writing_systems: Comma-separated writing systems the results must cover, as ISO 15924 script codes (e.g. 'latn,cyrl' or 'hani'). Case, surrounding whitespace, common full names ('Latin', 'Korean', 'Chinese Simplified'), and BCP-47 tags ('zh-Hans', 'ja') are normalized to the closest supported script; unrecognized tokens are dropped, and an empty result falls back to 'latn' rather than being rejected. See this server's MCP instructions for the list of supported writing systems. Distinct from locale (which language names are translated into) and from supported_languages (a font's own language capability). supported_languages: Optional list of language codes a returned font must support all of (AND semantics), via that font's language_support field. Case and separator variants ('zh_hans' -> 'zh-Hans', 'JA' -> 'ja') are normalized to the supported vocabulary; unrecognized codes are dropped rather than rejected, and if none remain no language filter is applied. Omit for no filtering. See this server's MCP instructions for the list of recognized language codes. exclude_variable_fonts: When False (the default), variable fonts are included in results alongside static fonts. Set True to omit variable fonts entirely. There is no variable-only mode — this only toggles whether variable fonts are included. font_group: Comma-separated font groups (e.g., 'Sans Serif,Display') sort: Result ordering ('relevance', 'name', or 'newest') locale: Language the returned font family/style names (and recommendation/search group names) are translated into, when a translation is available (default en_US). Hyphen, bare-code, and region-mismatched forms are all normalized to the closest supported locale (e.g. ja-JP and ja both become ja_JP; en_GB becomes en_US); an unsupported value falls back to en_US rather than being rejected. See this server's MCP instructions for the list of supported locales. Distinct from writing_systems (which script this call matches against). Group/category names in the response are localized only when the backend has a translation for the resolved locale -- your …font_similar
ChatGPTFind fonts visually similar to one or more given fonts. Use this when there's a concrete seed font — one the user likes, one their document already uses, or one that isn't in the Adobe Fonts catalog at all — and the goal is a licensed visual replacement, optionally one that also covers a language/script the seed doesn't (see
supported_languages below). For open-ended, context-driven suggestions merely nudged toward a font's style rather than a specific licensed replacement, use the font-recommendation or font-search tool instead, if one is available on this surface. Args: font_identifiers: Seed fonts to find similar fonts for (up to 20 per call). Only postscript_name is used for the lookup; any font_id given is accepted for input-shape consistency but not required or used. library: Font library ('full' or 'trial'); clamped server-side to the caller's real Adobe Fonts entitlement, same as the font-recommendation and font-search tools. locale: Language the returned font family/style names (and recommendation/search group names) are translated into, when a translation is available (default en_US). Hyphen, bare-code, and region-mismatched forms are all normalized to the closest supported locale (e.g. ja-JP and ja both become ja_JP; en_GB becomes en_US); an unsupported value falls back to en_US rather than being rejected. See this server's MCP instructions for the list of supported locales. Distinct from supported_languages (a font's own language capability). For CJK locales this also improves match quality for CJK scripts, not just display translation. per_page: Maximum number of similar fonts to return per seed font (1-100, default 10). supported_languages: Optional list of language codes a returned font must support all of (AND semantics), via that font's language_support field. Case and separator variants ('zh_hans' -> 'zh-Hans', 'JA' -> 'ja') are normalized to the supported vocabulary; unrecognized codes are dropped rather than rejected, and if none remain no language filter is applied. Omit for no filtering. See this server's MCP instructions for the list of recognized language codes. Silently excludes brought-your-own-font (byof) matches, which carry no language metadata. exclude_variable_fonts: When False (the default), variable fonts are eligible similarity matches. Set True to omit variable fonts from the results. Same include/exclude toggle as the font-recommendation and font-search tools. bearer_token: Optional Adobe IMS access token. Resolves the caller's real entitlement tier (see library above) — usually not needed for that alone, since the MCP server's OAuth context already supplies one when available. Separately, only an explicit token passed here also unlocks the caller's own brought-your-own-font (byof) matches in the response — OAuth context alone does not unlock BYOF. Without an explicit token, only library-source matches are possible. Returns: JSON string: {"results": [...], "library": "full" | "trial", "instructions": <model guidance>}. library is the tier actually queried after clamping to the caller's entitlement (see library above). results has one entry per seed font, in the same order as the input font_identifiers. Each results entry is either a success entry {"requested": {...}, "similar_fonts": [...]} or an error entry {"postscript_name": ..., "error_code": "<code>", "user_message": <message>, "requested": {...}}. requested ({postscript_name, font_id — font_id present only if you supplied one}) is always present, on every entry, echoing exactly what you sent for that seed, so you can match a result back to its input after any reordering. Error error_code is one of: invalid_input (a client-side format check on the postscript_name, no network call — the offending value is echoed in requested.postscript_name, not the message) or upstream_error / upstream_timeout (the lookup itself failed — upstream_error for a hard error, upstream_timeout for a transient one: a timeout, connection error, or 5xx, where retrying may help). Because every seed shares one upstr…font_styles
ChatGPTLook up every style variant (weights, widths, italics) in a font's family. Args: font_identifiers: Fonts whose family styles to look up. Each requires postscript_name; font_id is optional, with the same font_id-first, postscript_name-fallback resolution as the font-details tool (either one resolving is enough; they are not cross-validated against each other). postscript_name must match exactly, including case. locale: Language the returned font family/style names (and recommendation/search group names) are translated into, when a translation is available (default en_US). Hyphen, bare-code, and region-mismatched forms are all normalized to the closest supported locale (e.g. ja-JP and ja both become ja_JP; en_GB becomes en_US); an unsupported value falls back to en_US rather than being rejected. See this server's MCP instructions for the list of supported locales. Returns: JSON string with a
results list, one entry per requested font, in the same order as the input. Each entry is either {"resolved_via": "font_id" | "postscript_name", "requested": {...}, "family": {"name", "slug", "foundry", "designers", "detail_url", "language_support"}, "styles": [{"postscript_name", "style_name", "full_name", "weight", "style", "font_id", "preview_url", "language_support", "library_availability", "is_variable_font", "axis_values"}, ...]} or {"postscript_name": ..., "error_code": "<code>", "user_message": "...", "requested": {...}} where error_code is one of invalid_input, not_found, forbidden, upstream_error, upstream_timeout, and user_message is human-readable text safe to show the caller as-is. There is no top-level font_identifier on a success entry — use requested (below) to match a result back to its input, or find the input font's own entry inside styles by matching postscript_name (its resolved font_id is there too). resolved_via tells you which identifier decided the outcome when both font_id and postscript_name were supplied, since they aren't cross-validated against each other — same meaning as the font-details tool's resolved_via. requested ({postscript_name, font_id — font_id present only if you supplied one}) is always present on every entry, echoing exactly what you sent — same field and meaning as the font-details tool's requested. The requested postscript_name may not even appear in styles if font_id resolved to an unrelated family. family.language_support is present only when every style in the family shares the same language_support; a style then only carries its own language_support when its languages differ from that shared value. When styles disagree, family has no language_support at all and every style carries its own explicitly — there is no majority-vote default, so never assume a missing per-style language_support means it matches the family's unless family.language_support is actually present. invalid_input / not_found follow the font-details tool's exact semantics (same client-side format check; same "the font itself doesn't exist" meaning). forbidden means the font itself resolved fine but its family's style list is restricted for anonymous access — distinct from not_found. upstream_error means the lookup itself failed with a hard error. upstream_timeout means the lookup hit a transient failure — a timeout, a connection error, or a 5xx — so retrying may succeed. weight is the numeric OpenType weight class (e.g. 400, 700) — same field as the font-details tool — and the same class can look visually different across different families. is_variable_font (true/false) is present on every style — the same flag every font-returning tool exposes — so a variable style is never indistinguishable from a static one. axis_values (present only on a variable font's style, and only when that style's named instance carries concrete settings) is that specific named style's own variation-axis settings, e.g. {"wght": 400, "opsz": 12} — the exact values this style uses, not a min/max range (there's no reliable range data available; see the font-details tool's axes field for why). Where the font-level tools can only report …generate_indd_mapping_prompt
ChatGPTGenerates structured instructions for creating a CSV-to-template field mapping for InDesign placeholders. WHEN TO USE: Before assigning CSV columns to template frames — use this to obtain mapping guidance for reasoning out field assignments. WHEN NOT TO USE: This tool does not modify any document or call InDesign — it only returns instructions for the model to reason out the mapping JSON. Returns a prompt string with mapping structure requirements.
image_apply_adjustments
ChatGPTReusing a mask (only when the editing context with `actionHistory` is available): the user can edit or remove masks in the editor, so a mask URL you passed earlier may be stale — the context's
actionHistory lists each edit with its current mask. To carry a mask forward from an earlier edit, find that edit's most recent entry and pass its mask.maskURI, not the URL you originally passed; isMaskUpdated means the user edited it, so keep maskDescription / toBeInverted unchanged. If the entry has userRemovedMaskURI instead of maskURI, the user removed that mask: don't reuse it — call a selection tool if the request still targets that region, and pass userRemovedMaskURI only if the user explicitly asks for that mask again. To use the original AI selection instead of the user's edit, or after a crop, expand, straighten or undo-all, call a selection tool again. Use the attached context when present; call interactive_image_get_context only when none is attached. ROUTING — `interactive_image_apply_adjustments_app` owns single-image tonal/color adjustments (exposure, contrast, hue/saturation, vibrance, color balance, B&W). Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call interactive_image_apply_adjustments_app, not this tool. Never ask the user to choose; never offer a server-side edit. - 2+ images this turn: THIS tool for the whole set — interactive_image_apply_adjustments_app has no batch form; never call or mention it. - 1-image exceptions, use THIS tool when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; interactive_image_apply_adjustments_app is unavailable; the output feeds another tool, not the user. MANDATORY PREREQUISITE — before every call to this tool, you must first call asset_inline_preview or read_image (whichever is available) on each input image, including intermediate outputs from prior tool calls, and inspect the returned visual. Do not call this tool from the filename, the user's description, or prior assumptions alone. Do not proceed until the preview has returned and you have used it to judge the image's actual brightness, tonal balance, highlight/shadow state, and color cast. Without that visual grounding, parameter values are guesses. Adobe Photoshop and Lightroom professional image adjustments. Use when: brighten, darken, too dark, too bright, overexposed, underexposed, recover highlights, lift shadows, reveal shadow detail, crush blacks, boost contrast, boost saturation, muted colors, more colorful, desaturate, too yellow, too blue, warm up, cool down, white balance, color grade, hue shift, recolor an object, tone down a specific color, make it pop, looks dull, flat, lifeless, lacks contrast, professional look, polished, clean look — for specific, targeted adjustments where the direction or parameter is clear. For vague problem descriptions without a specified direction or amount, call image_apply_auto_tone first; use this tool only for follow-up fine-tuning. Adjustment groups — set only the fields you need: - Exposure: exposure, gamma, exposureOffset - Tonal regions: highlights, lights, darks, shadows - Brightness / contrast: brightness, contrast - Color temperature: tempA + tempB + tempLuminance (all three required) - Hue / sat / lightness: hslHue + hslSaturation + hslLightness (all three required; optionally add colorize or targetColor) - Vibrance / saturation: vibrance, saturation - Per-channel saturation: channelTarget + channelSaturation (both required) Why this tool: - CIELAB color temperature: precise warm/cool via Lab colorspace - Vibrance: smart saturation that protects skin tones - Camera Raw tone controls: exposure, gamma, offset, tonal regions - Deterministic single-pass pipeline: all adjustments applied in optimal fixed order in one call To target a specific object or area in the image: 1. If the user provides a mask URL, use …image_apply_auto_tone
ChatGPTChoosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. Automatically corrects the tonal balance of the images in one step by adjusting exposure, contrast, highlights, shadows, whites, and blacks. No prior image analysis or preview is needed — call this tool directly. Use when: the user describes a tonal or visual problem without specifying exact values or a direction — e.g., "improve", "fix the lighting", "I can't see the subject", "looks flat". Always call this tool first; use image_apply_adjustments afterward only if finer manual control is still needed. Not for: adjustments where the user specifies a clear direction or amount (e.g., "make shadows warmer", "boost saturation") — use image_apply_adjustments directly for those. Long-running batches: A batch may take longer than a single call can wait. If the response is a single result with status: "working", NO images are ready yet — call image_get_task_status with its taskId to collect them all at once. Do NOT call image_apply_auto_tone again, which would redo the work and bill for it twice.image_apply_effects
ChatGPTReusing a mask (only when the editing context with `actionHistory` is available): the user can edit or remove masks in the editor, so a mask URL you passed earlier may be stale — the context's
actionHistory lists each edit with its current mask. To carry a mask forward from an earlier edit, find that edit's most recent entry and pass its mask.maskURI, not the URL you originally passed; isMaskUpdated means the user edited it, so keep maskDescription / toBeInverted unchanged. If the entry has userRemovedMaskURI instead of maskURI, the user removed that mask: don't reuse it — call a selection tool if the request still targets that region, and pass userRemovedMaskURI only if the user explicitly asks for that mask again. To use the original AI selection instead of the user's edit, or after a crop, expand, straighten or undo-all, call a selection tool again. Use the attached context when present; call interactive_image_get_context only when none is attached. ROUTING — `interactive_image_apply_effects_app` owns single-image artistic effects and filters. Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call interactive_image_apply_effects_app, not this tool. Never ask the user to choose; never offer a server-side edit. - 2+ images this turn: THIS tool for the whole set — interactive_image_apply_effects_app has no batch form; never call or mention it. - 1-image exceptions, use THIS tool when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; options.effect is colorOverlay — not in the widget; interactive_image_apply_effects_app is unavailable; the output feeds another tool, not the user. Applies a single Photoshop filter/style effect to the image or an area, chosen via options.effect. Effects — set `options.effect` to one of: - grain: film grain, analog grain, add grain, cinematic texture, grainy photo, shot on film. - noise: add noise, digital noise, pixel noise, noisy image, uniform noise, digital texture. - colorOverlay: color overlay, color wash, tint filter, color layer on photo. Adds a new flat-color layer on top — a graphic/stylized tint. For a natural-looking global warm/cool or color-cast shift that preserves existing lighting, shadows, and detail, use image_apply_adjustments's color temperature or HSL params instead. Cannot set opacity — for "at 20%"/semi-transparent requests use image_fill_area. Without a mask covers the whole canvas. Do not use to fill or replace a background behind a subject (even a transparent cutout); use image_remove_background with options.backgroundColor instead. - gaussianBlur: blur, soften, defocus, bokeh, out of focus, hazy background. Uniform-radius; for falloff/shallow depth-of-field use image_apply_lens_blur. To blur the background behind a subject, the interactive_image_blur_background_app routing rule above applies. - glitch: glitch, chromatic aberration, broken screen, VHS distortion, cyberpunk. Larger absolute offset = more intense. - halftone: halftone, dot pattern, comic book, newspaper, screen printing, risograph. - monochromaticTint: black and white, grayscale, sepia, duotone, faded, washed out, single color wash. One effect per call — to layer several, call once per effect, chaining each result's outputUrl into the next call's imageURIs. To target a specific object or area in the image: 1. If the user provides a mask URL, use it to limit the effect to that region. 2. If no mask URL is provided but the user wants to target a specific area, first use available masking tools to create a mask based on their description, then apply the effect. 3. If no mask is specified and no targeting is requested, apply the effect to the entire image. Long-running batches: A batch may take longer than a single call can wait. If the response is a single result with status: "working", NO images are ready yet — call image_get_task_status with …image_apply_lens_blur
ChatGPTROUTING — `interactive_image_blur_background_app` owns single-image background blur behind a subject. Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call
interactive_image_blur_background_app, not this tool. Never ask the user to choose; never offer a server-side edit. - 2+ images this turn: THIS tool for the whole set — interactive_image_blur_background_app has no batch form; never call or mention it. - 1-image exceptions, use THIS tool when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; no subject mask is available or obtainable (the widget requires one); interactive_image_blur_background_app is unavailable; the output feeds another tool, not the user. Blurs the background with depth-of-field falloff (bokeh) while keeping the subject sharp. Auto-detects the primary subject and progressively blurs the background — no manual masking. Output Format: ALWAYS use outputFileType: "png". PNG is required — it preserves lossless quality and transparency through multi-step edits and selection-mask chains. Only use "jpeg" when the user has explicitly requested JPEG format for the final result. **Use ONLY when the user explicitly asks for blur, bokeh, depth-of-field, or out-of-focus background. Takes no mask and ignores selection state — do not chain image_select_subject / image_invert_selection ahead of it; subject masking is built in. For a uniform-radius blur instead of DoF falloff/bokeh, use image_apply_gaussian_blur: either blurTarget: 'background' (auto subject detection), or pass a maskURI from image_select_subject or image_select_by_prompt + image_invert_selection when you need a custom region or a sharper mask boundary. Example: <example> Apply lens blur: {} </example>image_apply_preset
ChatGPTChoosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. Applies named Lightroom preset(s) to one or more images in a single batched call, transforming each image's look in one step. A preset adjusts tone, color, contrast, grain, and sharpening together as a unified look. Group the work into edits: each entry pairs one presetName with the images it applies to. Use multiple entries to apply different presets to different images in the same call. WHEN TO USE: the user's request is about color/tone/mood only — preset, color grade, film look, vintage, black and white conversion, matte finish, warm tone, cool tone, skin tone edit, vignette, cinematic grade, dramatic sky, sharpen, add grain, subject pop. WHEN NOT TO USE: composed-look requests that imply a different background, subject/background separation, or relighting — e.g. "studio photo", "product shot", "clean white backdrop", "magazine cover", "headshot on grey", "professional portrait". Those require structural changes that presets cannot produce. In those cases, build the composition first (isolate subject, replace background, relight) using the subject-selection / fill / blur / exposure tools, and only then apply a preset as the final color pass if needed. One look per result: Presets are a complete look, not additive filters. Apply a single preset as the final color/tone step for any given output, and do NOT re-run this tool on an image that already has a preset baked in — chaining presets on the same pixels compounds the effect and looks unnatural. Listing the same source image under different presets is fine: each preset is applied independently to the original image and produces a separate variant. 100+ presets across 14 categories: B&W (10), Color (6), Creative (13), Curve (4), Defaults (4 profiles with optional lens correction / noise reduction), Grain (3), Optics (3), Portraits (13: light/medium/deep skin variants), Sharpening (3), Vignetting (3), Adaptive (19: portrait, sky, subject, background blur), Auto+ (3: retro), Style (12: futuristic, cinematic II, film-inspired, vintage, B&W), Subject (8: travel, food, lifestyle). The catalog also includes a handful of curated custom presets that apply as a complete look exactly like the built-in ones. Important: The categories above are summaries, not exact preset names. You MUST call image_list_presets first to get the exact display names — preset names have specific formatting (e.g. "B&W - B&W High Contrast", not "B&W High Contrast"). Do not guess preset names. Returns one result per (preset, image) pair, each carrying the applied presetName in its metadata. Long-running preset applications: A batch may take longer than a single call can wait. If the response is a single result with status: "working", NO images are ready yet — call image_get_task_status with its taskId to collect them all at once. Do NOT call this tool again, which would re-apply the presets and bill for them twice. Examples: <example> One preset on two photos: { "edits": [ { "presetName": "B&W - B&W High Contrast", "images": [ "https://example.com/a.jpg", "https://example.com/b.jpg" ] } ] } </example> <example> A different preset per photo: { "edits": [ { "presetName": "B&W - B&W High Contrast", "images": [ "https://example.com/a.jpg" ] }, { "presetName": "Style: Vintage - VN07", "images": [ "https://example.com/b.jpg" ] } ] } </example> <example> Two looks of one ph…image_auto_straighten
ChatGPTAutomatically straighten and level the image. WHEN TO USE: "straighten this", "fix the horizon", "level the image", "the photo is crooked".
image_crop_and_resize
ChatGPTChoosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. Smart crop and resize with subject-aware positioning. Automatically detects subjects and positions crops intelligently. Preferred tool for tight subject / product / face crops — uses server-side face/subject/prompt detection, which is far more reliable than estimating 0-1 bounds visually. If the user asks to "crop to only X", "tight crop on X", "isolate X", or frame any nameable subject, use this tool with fit: "extract" rather than image_crop_to_bounds. For geometric crops (halves, quarters, fixed percentages, letterbox bars) where no subject detection is needed, use image_crop_to_bounds directly. Key capabilities: - Crop to exact dimensions with subject-aware focus (face, upper_body, or custom point) - Focus on arbitrary objects by text prompt (e.g., "the red car", "the dog") - Crop to aspect ratio at source resolution ("16:9", "4:5", etc.) - Resize to a single dimension (proportional scaling) - Pad mode: fit entire image within target dimensions with transparent (PNG only) or white background (JPEG only) fill - Adjustable per-side margins around detected subjects (margin: 0.15 = 15% of subject size added to each side) - Custom alignment (rule of thirds, etc.) align parameter — controls where the focus point lands in the output frame (0=left/top, 0.5=center, 1=right/bottom). Only set the axis you want to shift; omit for centered crops. - "subject in the left third" → align: { x: 0.33 } - "subject in the right third" → align: { x: 0.67 } - "face in upper third" → align: { y: 0.33 } - "rule of thirds, upper-left" → align: { x: 0.33, y: 0.33 } - "leave space on the right for text" → align: { x: 0.3 } - "leave space above for a title" → align: { y: 0.6 } - "subject at the bottom" → align: { y: 0.75 } Values below 0.5 push the subject toward top-left; above 0.5 toward bottom-right. Note: align has no effect on an axis when the crop spans the full source dimension on that axis (e.g., cropping a landscape to portrait uses the full source height, so align.y cannot move the crop). When this happens, an "align_constrained" tradeoff is recorded in metadata. align may also be partially overridden to keep the detected subject visible in the crop. Aspect compatibility & clipping: fit: "reframe" cannot grow the crop; when source and target aspect differ sharply (portrait → landscape or vice versa) the subject will clip and no focus/align/margin can prevent it. On focus: "subject" the tool auto-retries with focus: "face" when the subject looks upright (tall bbox, a proxy for "person"); non-upright subjects (pets, produce, landscapes) skip this step. If still clipped (visible_fraction < 0.7), onSubjectClipping kicks in: "expand" (default — emits a requires_expand_chain tradeoff with pre-filled image_generative_expand args; baseline action is an extract crop) · "extract" (tight crop, may upscale) · "pad" (letterbox, no loss) · "error" (fail with guidance) · "ignore" (tradeoffs only). `requires_expand_chain` tradeoff: invoke the pre-filled next_call (image_generative_expand) exactly as given, then re-invoke image_crop_and_resize with the same arguments, replacing imageURI with the expand output URL. The baseline action returned alongside this tradeoff is an extract crop — usable as a fallback, but chaining yields the content-preserving result. Read cause to know which problem it…image_crop_to_bounds
ChatGPTChoosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. PREREQUISITE: call asset_inline_preview or read_image (whichever is available) on the input image first. Choosing bounds without a current visual can clip subjects, miss borders or crop the wrong region. If the only information you have is the filename or a description, you do NOT have enough grounding; preview first, then choose bounds from what you see. Crop images to exact geometric bounds using normalized coordinates (0-1). Each coordinate is a fraction of the image dimension: 0 = top/left edge, 1 = bottom/right edge. The same normalized bounds are applied to every image — since coordinates are relative, images of different sizes produce proportionally equivalent crops. Use ONLY for geometric / compositional crops where the region is specified by position, not by subject: - "the left half", "center 50%", "top-right quarter" - "remove 10% from all edges", "trim the black letterbox bars" - "16:9 letterbox from the center" - Fast, deterministic crops with no detection overhead needed. Do NOT use this tool as the first choice for subject / product / face crops — even if you can see the subject clearly. Visual coordinate estimation is unreliable for tight framing and frequently leaves empty regions on one side or clips the subject on the other (a recurring failure mode). For any of these, use image_crop_and_resize first: - "crop to only the product", "crop to the tube / bottle / box", "isolate X", "just the dog" → image_crop_and_resize with fit: "extract" + focus + margin - "crop this to 16:9 keeping the subject in frame", social media crops with a subject → image_crop_and_resize with default fit: "reframe" + focus - Any request to frame a nameable subject — server-side face/subject/prompt detection is far more reliable than eyeballing 0-1 coordinates from a preview. - Decorative frame / ornate border / rotated-subject-on-background (e.g. a framed document, certificate, photo on a desk, scanned paper that isn't axis-aligned): the inner content is a subject, not a geometric crop — the frame edges don't align with the image edges. Use image_crop_and_resize with fit: "extract" and focus: { prompt: "<the subject>" }. Use this tool as a fallback when image_crop_and_resize detection misses (empty match, wrong region, or subject in an unexpected position). In that case the subject is already visually located in the preview, so explicit coordinates are the right escape hatch — pad bounds by 5–8% outward around the subject to avoid clipping limbs / edges that are easy to under-estimate visually. Border / letterbox / frame removal — overshoot, single call. Rule: if the visible border is V% on a side, set the inner bound to at least V + 5 on that side. Never equal, never less. Measure each side independently — for asymmetric frames (e.g. Polaroid with a thicker bottom), do NOT default to symmetric bounds. If a sliver survives, jump by another 5–10% — do not nudge by 1%. After the call, follow the importantNote on the result to verify the output visually before reporting success. Long-running batches: A batch may take longer than a single call can wait. If the response is a single result with status: "working", NO images are ready yet — call image_get_task_status with its taskId to collect them all at once. Do NOT call image_crop_to_bounds again, which would redo the work and bill for it twice. E…image_fill_area
ChatGPTChoosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. Reusing a mask (only when the editing context with `actionHistory` is available): the user can edit or remove masks in the editor, so a mask URL you passed earlier may be stale — the context's actionHistory lists each edit with its current mask. To carry a mask forward from an earlier edit, find that edit's most recent entry and pass its mask.maskURI, not the URL you originally passed; isMaskUpdated means the user edited it, so keep maskDescription / toBeInverted unchanged. If the entry has userRemovedMaskURI instead of maskURI, the user removed that mask: don't reuse it — call a selection tool if the request still targets that region, and pass userRemovedMaskURI only if the user explicitly asks for that mask again. To use the original AI selection instead of the user's edit, or after a crop, expand, straighten or undo-all, call a selection tool again. Use the attached context when present; call interactive_image_get_context only when none is attached. Fills a masked area of the image with a solid color at a specified opacity. The mask's white pixels are filled; black pixels are preserved. WHEN TO USE: filling a specific masked region (not the whole background-behind-the-subject) with a solid color. Typical cases: a sub-region selected by prompt (e.g. "the sky", "the wall"), a user-supplied mask, a region from image_select_by_prompt, or compositing flat color into part of a layout. WHEN NOT TO USE: replacing the entire background behind a subject with a solid color — however phrased (e.g. "fill the background with green", "make the background white", "give it a red background", "put a solid <color> behind the subject"). Use image_remove_background with options.backgroundColor instead (single call) — it detects the subject and composites it onto the color in one step. Do not use a generative tool such as image_instruct_edit for this, and do not chain image_select_subject → image_invert_selection → this tool — either mistake fills the subject instead of the background. Do not feed the transparent PNG output of image_remove_background into this tool as a mask — it has alpha, not black/white mask semantics, and will produce wrong polarity. Long-running batches: A batch may take longer than a single call can wait. If the response is a single result with status: "working", NO images are ready yet — call image_get_task_status with its taskId to collect them all at once. Do NOT call image_fill_area again, which would redo the work and bill for it twice. Examples: <example> Create solid white fill layer: { preset: 'white' } </example> <example> Create 50% opacity white fill layer: { preset: 'white', opacity: 50 } </example> <example> Create custom RGB color fill layer: { color: { red: 255, green: 128, blue: 0 }, opacity: 75 } </example> <example> Create gray fill layer with multiply blend mode: { preset: 'gray', blendMode: 'multiply' } </example>image_generate
ChatGPTGenerate a NEW AI image from scratch using Adobe Firefly. WHEN TO USE: "generate an image of", "create a picture of", "create a product photo background", "imagine a scene", "text to image" - ONLY when NO image is uploaded in context. WHEN NOT TO USE: - If context shows an image is already uploaded -> use image_instruct_edit instead - Style requests with uploaded image ("anime style", "make it look like X") -> use image_instruct_edit - For flyers/posters/banners -> use design_search (Adobe Express templates) CRITICAL: Check context first! If user already uploaded an image and asks for a style, use image_instruct_edit to transform it - don't generate a new image. NOTES: Requires login. Uses Firefly credits. USAGE: Parameter constraints (mutually exclusive): - aspectRatio: Use for general terms ("portrait" -> "3:4", "landscape" -> "4:3", "widescreen" -> "16:9") - size: Use for exact pixel dimensions (e.g., "2688x1536"). Cannot combine with aspectRatio. - referenceImage: Provide URL to guide style/composition. Cannot combine with aspectRatio or size. If no dimension specified, omit aspectRatio (service uses default).
image_generative_expand
ChatGPTExpand an image by adding content around it. Generates seamless context-aware borders without altering the original content. WHEN TO USE: "expand this image", "extend the canvas", "add more space", "make it wider", "add sky above", "outpaint", "extend in [direction]". WHEN NOT TO USE: For resizing/scaling existing content -> use image_crop_and_resize. For upscaling/super-resolution -> not available. Requirements: - Dimensions: If missing, retrieve via a dimension tool; if unavailable, infer from context/URL or ask the user. - Inset: Specify direction(s) for expansion. For horizontal/vertical expansion, distribute insets evenly. Examples: - Expand landscape images to make them wider: { width: 1200, height: 800, inset: { left: 200, right: 200 } } - Add sky space above portrait images: { width: 800, height: 1200, inset: { top: 300 } } - Create panoramic effect by extending images on all sides: { width: 1000, height: 750, inset: { top: 100, right: 200, bottom: 100, left: 200 } }
image_get_presigned_urls
ChatGPTInternal presigned url accessor tool for Adobe Photoshop custom UX widgets.
image_get_task_status
ChatGPTWaits for an operation that a previous tool call started but did not finish, and returns its result once ready. Use when: any tool returned
status: "working" together with a taskId. That result is NOT finished — there is no output yet — and this tool is the only way to get the real one. Call this with the taskId verbatim. If it comes back status: "working" again, the operation is still running: call this tool again with the taskId from the LATEST result. Usually that is the same value you sent, but for a batch it can be a new one — always use the most recent. Repeat until you get results. One taskId may cover SEVERAL operations. It is then all-or-nothing: while any operation is unfinished you get a single status: "working" result with no outputs, and once they are all done you get every result together, in the order of the original request. You will never receive some of a batch's images now and the rest later. Do not report the operation as complete, and do not end your turn, until every result contains outputUrl. Example: <example> Continue waiting: { "taskId": "v1.aGVsbG8…" } </example>image_instruct_edit
ChatGPTEdit an image using a natural language instruction. Powered by Adobe Firefly. WHEN TO USE: - Remove objects/text/logos/people from image ("remove the text", "remove the logo", "remove the person") - Add objects/elements to image ("add sunglasses", "add wings", "add text saying X") - Replace/change background ("change background to sunset", "studio backdrop") - Change color of SPECIFIC NAMED OBJECT ("make the car blue", "make shirt green") - Style transformations ("anime style", "cartoonize", "sketch effect", "make it look like a painting", "oil painting style", "Y2K style", "retro style", "80s style", "90s style", "vaporwave", "pop art") - Edit/change text in an image ("change the text to say X", "edit the text", "replace SALE with CLEARANCE") - Face/body modifications ("add makeup", "change hairstyle", "make them smile") - Retouching ("whiten teeth", "brighten eyes", "smooth skin") - Convert film negative to positive ("negative to positive", "invert negative") - Region-specific effects ("glitch the background", "blur only the sky", "add grain to the background") WHEN NOT TO USE: Global color adjustments -> use adjust_* tools. Exposure/brightness -> use image_adjust_exposure. Cropping/resizing -> use image_crop_and_resize. Background blur -> use image_apply_lens_blur. NEVER for watermark removal (copyright violation). NOT SUPPORTED (explain to user and suggest Photoshop): - Flip/mirror image horizontally or vertically - Rotate image by specific degrees - Geometric transformations (skew, warp, perspective) CRITICAL RULES: 1. This is the PRIMARY tool for any content modification. When in doubt, use this tool. 2. For text removal: ALWAYS use this tool, NOT image_fill_area (which just fills with color). 3. For style changes (anime, cartoon, sketch, Y2K, retro, etc.): ALWAYS use this tool on the uploaded image. 4. For retouching (teeth whitening, eye brightening): ALWAYS use this tool - it's simpler than select+adjust. 5. For region-specific effects ("X the background", "X only the Y"): use this tool - it understands regions. 6. If user mentions a style with an uploaded image, apply the style - don't ask for clarification. 7. For flip/rotate requests: explain this is not supported and suggest Photoshop. 8. For editing text in images: ALWAYS use this tool - it can read and modify text content. NOTES: Requires login.
image_invert_selection
ChatGPTInvert the current selection mask - selects everything that wasn't selected and deselects everything that was. WHEN TO USE: After image_select_subject to switch from selecting the subject to selecting the background, "invert selection", "select inverse".
image_list_presets
ChatGPTList available Lightroom presets. WHEN TO USE: "what presets do you have?", "show me available styles", "what film presets are there?", before calling image_apply_preset when user doesn't know preset name.
image_open_file_app
ChatGPTOpens the Photoshop image editor for a file the user selected through a file entrypoint. The host supplies the file name and an opaque resource URI; the widget reads the file contents through the host.
image_remove_background
ChatGPTROUTING — `interactive_image_remove_background_app` owns single-image background removal to a transparent cutout. Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call
interactive_image_remove_background_app, not this tool. Never ask the user to choose; never offer a server-side edit. - 2+ images this turn: THIS tool for the whole set — interactive_image_remove_background_app has no batch form; never call or mention it. - 1-image exceptions, use THIS tool when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; a solid-color backdrop is wanted (options.backgroundColor) — the widget only makes transparent cutouts; no subject mask is available or obtainable (the widget requires one); interactive_image_remove_background_app is unavailable; the output feeds another tool, not the user. Detects the main subject and creates a cutout. Default: transparent PNG with subject isolated. With backgroundColor (hex): JPEG with subject composited onto that solid color. WHEN TO USE: remove background, cut out subject, isolate subject, strip background, transparent cutout, OR replace/fill the background behind the subject with a solid color ("fill the background white", "make the background blue", "put it on a white backdrop"). This works even when the input is ALREADY a transparent cutout — it re-detects the subject and composites it onto the solid color, so it is the correct tool for "fill the (transparent) background with a color" on a cutout PNG. Reach for this tool whenever the user wants a clean solid-color backdrop behind the subject — pass options.backgroundColor. This is the core building block of any "studio photo", "product shot on white", "headshot on grey", or "professional ID photo" request. A solid neutral backdrop (white, light grey, or black) is what defines the studio look far more than any color grade or blur. Do NOT try to fake the studio look with lens blur, gaussian blur, vignettes, or color presets alone — the background must actually be replaced. Default output is a cutout PNG (transparent background), not a mask. Do not pass this result as maskURI to other tools — it has transparency, not black/white mask semantics, and feeding it into mask-accepting tools will produce the wrong result. WHEN NOT TO USE: anything else targeting subject or background — blurring only the background, selectively adjusting the subject, applying effects to either region, or any downstream masked edit. Use image_select_subject instead to get a proper mask. Downscale behavior: If input exceeds the API resolution limit, it is automatically downscaled before processing and the cutout is returned at reduced resolution (not upscaled back). When this happens, output metadata includes a tradeoffs array with a downscaled entry and output_width/output_height will be smaller than source_width/source_height. Examples: <example> Transparent PNG cutout: {} </example> <example> Studio / headshot on white: { "backgroundColor": "#ffffff" } </example> <example> Headshot on neutral grey: { "backgroundColor": "#cccccc" } </example> <example> Any 6-digit hex is accepted (not just neutrals): { "backgroundColor": "#1a73e8" } </example>image_remove_blemishes
ChatGPTRemove skin blemishes, spots, or small imperfections from an image. WHEN TO USE: "remove blemishes", "clean up the skin", "spot removal", "remove that pimple". WHEN NOT TO USE: NOT for wrinkles/anti-aging (recommend Photoshop Neural Filters). NOT for watermark removal - this is often copyright violation, suggest using Adobe Stock instead.
image_select_by_prompt
ChatGPTimage_select_by_prompt — Select objects by text prompt with optional body parts filtering Choosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. Background / negative-space selection takes two calls. Step 1: this tool with prompt: "the subject" or the named positive object. Step 2: image_invert_selection on the returned mask. Never use "the background", "everything except X", or "the area around X" as the prompt. DO NOT USE for generative requests. This tool only creates selection masks — it does not generate, remove or replace content. If the user asks to remove objects/people, replace backgrounds, generate content, or perform any generative AI editing, inform them that generative editing is not currently available. Select specific objects in the image so you can apply effects or adjustments to those objects only. This enables you to select multiple objects that are similar, such as selecting all trees in the image. Generates a precise mask for non-anatomical, uniquely identifiable objects or scene elements using a detailed prompt. When bodyParts is provided, the prompt-matched person is further parsed and only the requested parts are returned (combined into one mask if multiple). Supported body parts: Aliases shown in parentheses are common synonyms — not exhaustive; map any reasonable phrasing to the canonical name. - Eyes (sclera / eye whites — not the colored part) - Pupil (iris, for eye-color changes) - Face (includes Nose by default) - Upper Clothes (shirt, T-shirt, top, blouse, sweater) - Lower Clothes (pants, trousers, shorts, skirt) - Coat (jacket, coat, outer layer, hoodie) Other parts: Hair, Eyebrow, Nose, Mouth, Teeth, Neck, Beard, Left Ear, Right Ear, Left Arm, Right Arm, Left Hand, Right Hand, Left Leg, Right Leg, Left Shoe, Right Shoe, Dress, Hat, Glasses, Accessories. When to use - Non-human objects, scene elements (buildings, furniture, vehicles, plants, cables, wires, railings, pipes) → prompt naming the object, no bodyParts. - Single person, with a body part or clothing item → prefer image_select_subject with bodyParts (simpler). - Multiple people, with a body part or clothing item → prompt identifying the person + bodyParts naming the part. Example: "the jacket on the person on the left" → { prompt: "the person on the left", bodyParts: ["Coat"] }. - Background / negative space → see the rule at the top of this description. IMPORTANT: Do NOT use image filenames for tool routing or prompts - Image filenames and URLs are arbitrary identifiers and do NOT indicate what the user wants to do. - Never extract words from a filename or URL path to use as a prompt or to influence tool choice. - Only use the user's explicit words to determine what to select and which tool to use. Examples: <example>Select the bridge: { prompt: 'the bridge' }</example> <example>Select all trees: { prompt: 'all the trees' }</example> <example>Select the hair: { prompt: 'the person', bodyParts: ['Hair'] }</example> <example>Select the jacket on the left: { prompt: 'the person on the left', bodyParts: ['Upper Clothes'] }</example> <example>Select the face of the woman in the back excluding the nose (nose is included by default): { prompt: 'the woman in the back', bodyParts: ['Face'], excludedBodyParts: ['Nose'] }</example> <example>Select hair and face of right person: { prompt: 'the person on the right', bodyParts: ['Hair', 'Fa…image_select_subject
ChatGPTimage_select_subject — Select main subject(s) or specific body parts Choosing the image to edit: pick the source image URL by the first rule that applies — if the user uploaded a new image with this request (a new conversation, or a switch to a different image to edit), use that uploaded image's URL; otherwise, if the previous tool returned an image output, use that output URL; otherwise, read the latest context and use
currentInputImage, the flattened current image (when multiple contexts are present, use the one with the most recent updateTimestamp); otherwise, fall back to the last known image URL. After editing: once this tool returns an edited image, you MUST call interactive_image_edit_preview with that output URL to display the result to the user. DO NOT USE for generative requests. This tool only creates selection masks — it does not generate, remove or replace content. If the user asks to remove objects/people, replace backgrounds, generate content, or perform any generative AI editing, inform them that generative editing is not currently available. Selects the main subject(s) in an image and creates a selection mask. Optionally, you can specify specific body parts or clothing items to isolate using the bodyParts parameter. PRIORITY RULE (applies before the routing guide): The input image MUST be analyzed first to determine if it is already a particular part of a human subject, such as legs or feet only. If the image is cropped to a specific body region (e.g., only legs, feet, hands), DO NOT use image_select_subject with bodyParts. Instead use image_select_by_prompt with a descriptive prompt such as: - "the shoes" - "the legs" - "the hands" Rationale: body-part parsing works best with a full or mostly full human subject. Body Parts Support: When bodyParts parameter is provided, the tool will: 1. First detect and select the main subject 2. Parse the subject into body parts using Adobe Sensei 3. Return a mask for the specified body part(s) 4. Combine multiple body parts into a single mask if multiple parts are requested Supported body parts: Aliases shown in parentheses are common synonyms — not exhaustive; map any reasonable phrasing to the canonical name. - Eyes (sclera / eye whites — not the colored part) - Pupil (iris, for eye-color changes) - Face (includes Nose by default) - Upper Clothes (shirt, T-shirt, top, blouse, sweater) - Lower Clothes (pants, trousers, shorts, skirt) - Coat (jacket, coat, outer layer, hoodie) Other parts: Hair, Eyebrow, Nose, Mouth, Teeth, Neck, Beard, Left Ear, Right Ear, Left Arm, Right Arm, Left Hand, Right Hand, Left Leg, Right Leg, Left Shoe, Right Shoe, Dress, Hat, Glasses, Accessories. When to use: - Select main subject(s): Call without bodyParts parameter - Select specific body part(s) or clothing: Call WITH bodyParts parameter (e.g. ["Hair"], ["Upper Clothes"]) - Which person? (left/right, "man in back"): Use image_select_by_prompt to isolate that person and set bodyParts parameter if any body parts are requested. - Non-human objects / scene elements: Use image_select_by_prompt IMPORTANT: Do NOT use image filenames for tool routing or prompts - Image filenames and URLs are arbitrary identifiers and do NOT indicate what the user wants to do. - Never extract words from a filename or URL path to use as a prompt or to influence tool choice. - Only use the user's explicit words to determine what to select and which tool to use. Tool routing quick guide - Single person + body parts or clothing → image_select_subject with bodyParts parameter - Multiple people + body parts or clothing (e.g. "person on the left") → image_select_by_prompt with prompt identifying the person + bodyParts parameter - Non-human objects / scene elements → image_select_by_prompt without bodyParts — do not use this tool Examples: <example>Select the subject: {}</example> <example>Select the person's face (by default, the nose is included): {"bodyParts": ["Face"]}</example> <example>Select the person's face excluding th…image_vectorize
ChatGPTConvert a raster image (PNG or JPEG) — including photos, portraits, product shots, logos, illustrations etc. — into a clean, scalable SVG of editable vector paths. WHEN TO USE: "vectorize this", "convert to SVG", "make this a vector", "make this scalable", "scalable version of this", "make this Illustrator-ready", "trace image", "raster to vector", "turn into vector graphic".
interactive_image_apply_adjustments_app
ChatGPTSession handle: each source image (
originalUploadedImage) has its own sessionId, minted on demand — it is not one handle for the whole conversation. The first call for a given source image must pass sessionId: -1; wait for the sessionId it returns and reuse that value for every later call on that same image. When originalUploadedImage changes to a different image, pass -1 again to start that image's session, and keep a per-image mapping so returning to an earlier image reuses its sessionId. Apply adjustments for brightness, contrast, hue, saturation, vibrance, exposure, color balance, or black and white conversion. These adjustments can be applied to an entire image or parts of the image by manually adjusting sliders in the widget. Based on the user's intent, configure specific parameter values for each adjustment or let them start at defaults for manual adjustment. ROUTING — this widget owns every single-image request for tonal/color adjustments (exposure, contrast, hue/saturation, vibrance, color balance, B&W). Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call THIS tool. Never ask widget-vs-server-side; never offer the direct tools (image_apply_adjustments). - 2+ images this turn: NEVER this tool — no batch form; use those direct tools and do not mention this one. - 1-image exceptions, use those direct tools when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience. - STOP after calling. It renders its own result and returns no asset URL — no asset_inline_preview, asset_preview_file, interactive_image_edit_preview, or any next step. - Non-generative — never widens what generative editing is permitted. DEFAULT IMAGE VIEWER: For generic requests to open, view, show, or edit a file, image, or photo (including "in Photoshop") without a specific edit, call THIS tool with no adjustments. Do NOT use interactive_image_edit_preview for this — it only previews server-side tool results. IMPORTANT: This tool does NOT analyze the image or apply image-context-aware logic. Default values are fixed schema values (e.g., exposure: 0), not computed from image content. HOW TO USE THIS TOOL: 1. Basic usage - Display adjustments with default starting values: - Call with adjustments array: [{"id": "hueSat"}, {"id": "exposure"}] - All parameters start at their default values; user adjusts manually via sliders 2. Advanced usage - Pre-configure specific parameter values: - Call with adjustments array including params: [{"id": "hueSat", "params": {"hue": 15, "saturation": 20}}, {"id": "exposure", "params": {"exposure": 0.5}}] - Adjustment sliders will start at your specified values instead of defaults - IMPORTANT: Only include parameters related to the user's intent - omit other parameters that would stay at defaults 3. User can click on the settings icon on each image to reveal adjustment sliders for real-time refinement MANDATORY PARAMETER DISCOVERY (ENFORCED): If any entry in the adjustments array includes a params object, you must use correct parameter names and constraints for that adjustment. If you do not already have the specific details (parameter names, ranges, defaults) for the adjustment in question, call interactive_image_get_options_for_adjustments_app (no input) first to get them. When you receive results from interactive_image_get_options_for_adjustments_app, you MUST follow the "instruction" for each parameter when configuring adjustment parameters—the instruction describes valid ranges, units, and how to interpret values. ENFORCEMENT RULES: 1. For each adjustments[i].id where adjustments[i].params is present: a. Use specific details (parameter names, ranges, defaults) for the adjustment in question when you already have them; otherwise call interactive_image_get_options_for_adjustments_app (no input) to get all adjustments and their parameters b. All keys in adjustments[i].params mus…interactive_image_apply_effects_app
ChatGPTSession handle: each source image (
originalUploadedImage) has its own sessionId, minted on demand — it is not one handle for the whole conversation. The first call for a given source image must pass sessionId: -1; wait for the sessionId it returns and reuse that value for every later call on that same image. When originalUploadedImage changes to a different image, pass -1 again to start that image's session, and keep a per-image mapping so returning to an earlier image reuses its sessionId. Apply artistic effects and filters to a whole image or a masked region. Each effect is applied with default parameter values; see the available effects listed below. ROUTING — this widget owns every single-image request for artistic effects and filters. Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call THIS tool. Never ask widget-vs-server-side; never offer the direct tools (image_apply_effects, image_add_grain, image_add_noise, image_apply_glitch_effect, image_apply_halftone, image_apply_monochromatic_tint, or image_apply_color_overlay). - 2+ images this turn: NEVER this tool — no batch form; use those direct tools and do not mention this one. - 1-image exceptions, use those direct tools when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; the request is a color overlay — not in this widget. - STOP after calling. It renders its own result and returns no asset URL — no asset_inline_preview, asset_preview_file, interactive_image_edit_preview, or any next step. - Non-generative — never widens what generative editing is permitted. IMPORTANT – ASSISTANT BEHAVIOR CONSTRAINTS: - This tool applies effects with default parameter values; it does NOT allow setting specific parameter values in the tool call. - The assistant MUST NOT claim to set or configure specific parameter values (e.g., "I'll set glitch intensity to 80%," "I've configured blur radius to 15px," "Grain amount is now at 50%"). The assistant MAY only: - Call this tool with effectIds to apply effects with their default parameters - Explain that users can manually adjust effect parameters using the interactive sliders in the widget after the effect is applied - Give directional guidance on adjusting parameters (e.g., "Use the Intensity slider to increase the glitch effect") When asked to "apply effects to xxx or give xxx effects" or something along those lines, you should use the "selectSubject" or "selectionByPrompt" tool to generate a mask first. See those selection tools' descriptions for more details. Forbidden phrasing: - "I'll set the glitch intensity to 80% for you." - "I've configured the blur radius to 15 pixels." - "Grain amount is now at 50%." - "I can apply the effect with specific parameter values." Allowed phrasing: - "I'll apply the glitch effect with default settings. You can adjust the intensity using the sliders in the widget." - "The blur effect has been applied. Use the Radius slider to control the blur amount." - "After the grain effect is applied, increase the Amount slider to make it more pronounced." - "The effect will start with default values. Click the settings icon to adjust the parameters." EFFECT SELECTION STRATEGY: If you want to suggest additional related effects, do NOT add them to this array. Instead, include suggestions in your response text as follow-up prompts for the user. 1. VAGUE REQUESTS (e.g., "apply effects to my image", "add some effects") → OMIT this parameter entirely to use the default set of effects 2. DESCRIPTIVE INTENT (e.g., "apply creative effects", "make me stand out", "make my image pop", "add artistic touches") → Analyze the intent and select up to 5 effects from the available list that best match the description → Consider image context: for portraits prioritize effects recommended for people, for landscapes use scene-appropriate effects 3. EXPLICIT SINGLE EFFECT (e.g., "apply glitch effec…interactive_image_blur_background_app
ChatGPTSession handle: each source image (
originalUploadedImage) has its own sessionId, minted on demand — it is not one handle for the whole conversation. The first call for a given source image must pass sessionId: -1; wait for the sessionId it returns and reuse that value for every later call on that same image. When originalUploadedImage changes to a different image, pass -1 again to start that image's session, and keep a per-image mapping so returning to an earlier image reuses its sessionId. Blur background of the image to make the main subject stand out. This tool uses the Gaussian Blur effect to blur the background. For other types of blur effects, use the interactive_image_apply_effects_app tool instead. ROUTING — this widget owns every single-image request for background blur behind a subject. Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call THIS tool. Never ask widget-vs-server-side; never offer the direct tools (image_apply_lens_blur, image_apply_gaussian_blur, or image_apply_effects). - 2+ images this turn: NEVER this tool — no batch form; use those direct tools and do not mention this one. - 1-image exceptions, use those direct tools when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; no subject mask is available or obtainable (this tool requires one). - STOP after calling. It renders its own result and returns no asset URL — no asset_inline_preview, asset_preview_file, interactive_image_edit_preview, or any next step. - Non-generative — never widens what generative editing is permitted. Requires a mask: - If no maskURI exists for this image, call image_select_subject_action_json tool first. - Verify the mask was generated from the same image being edited. - The mask required for this tool must be the background mask. → If the mask is the subject mask, set toBeInverted to true. → If the mask is the background mask, set toBeInverted to false.interactive_image_edit_preview
ChatGPTSession handle: each source image (
originalUploadedImage) has its own sessionId, minted on demand — it is not one handle for the whole conversation. The first call for a given source image must pass sessionId: -1; wait for the sessionId it returns and reuse that value for every later call on that same image. When originalUploadedImage changes to a different image, pass -1 again to start that image's session, and keep a per-image mapping so returning to an earlier image reuses its sessionId. Preview the result of a server-side image tool. This tool's only purpose is to display a NEW image URL returned by a server-side image_* tool (e.g., image_crop_and_resize, image_remove_background, image_generate, image_instruct_edit, image_apply_preset), including the final output collected via image_get_task_status. WHEN TO USE THIS TOOL: Immediately after a server-side image_* tool returns a NEW edited image URL, call this tool with that URL to display the result. WHEN NOT TO USE THIS TOOL: - Do NOT call it to open, view, or show a user's own file or uploaded image (e.g., "view my file", "open my image") — call interactive_image_apply_adjustments_app with no adjustments instead. - Do NOT call it after an in-app (*_app) tool — those render their own result in the widget and return no image URL to preview: - interactive_image_apply_adjustments_app - interactive_image_apply_effects_app - interactive_image_blur_background_app - interactive_image_get_options_for_adjustments_app - interactive_image_remove_background_app - interactive_image_undo_edits_app - interactive_image_uploader_app HOW TO USE THIS TOOL: - Pass the tool's output image URL as imageURI. - Set isGenerativeImage: true only when the output came from a generative-AI tool.interactive_image_get_context
ChatGPTReturn the current editing context for a source image's session (identified by its
sessionId, the per-originalUploadedImage handle — not one handle for the whole conversation): the flattened currentInputImage a destructive edit should build on, plus originalUploadedImage and actionHistory (each masked edit's current mask.maskURI, or userRemovedMaskURI if the user removed it). WHEN TO USE THIS TOOL: - Before a DESTRUCTIVE edit (e.g. image_instruct_edit, image_generate) that must build on the flattened result of prior non-destructive interactive_*_app edits, and only when you have no outputUrl from the previous tool. Call it, then pass the returned currentInputImage as the destructive tool's imageURI. - Before reusing a mask from an earlier edit, when no context is attached: the user may have edited or removed it in the editor. Pass the matching actionHistory entry's mask.maskURI. Reusing the same mask.maskURI across edits ties them together like a shared Photoshop layer mask: if the user later refines that mask in the editor, every edit sharing it moves to the refined mask. To target the same subject independently, generate a new mask instead — a fresh mask URL is treated as a separate mask. DO NOT CALL THIS TOOL: - Before a non-destructive interactive_*_app tool just to choose its image. Those stack on one base, so reuse the SAME imageURI you passed to the previous *_app edit (or the previous tool's outputUrl, or the freshly uploaded image) — NEVER currentInputImage or a rendition. - When the previous tool's response already contains an outputUrl — use that outputUrl directly as the next tool's imageURI. - When the session's editing context (currentInputImage, originalUploadedImage) is already attached to your context.interactive_image_get_options_for_adjustments_app
ChatGPTRetrieve all available adjustments and their configurable parameters. Call this tool when you need to know what adjustments exist and how to configure them (e.g. parameter names, types, defaults, min/max). WHEN TO USE THIS TOOL: Call this tool to get the full list of available adjustments and their configurable parameters before suggesting or applying adjustments.
interactive_image_remove_background_app
ChatGPTSession handle: each source image (
originalUploadedImage) has its own sessionId, minted on demand — it is not one handle for the whole conversation. The first call for a given source image must pass sessionId: -1; wait for the sessionId it returns and reuse that value for every later call on that same image. When originalUploadedImage changes to a different image, pass -1 again to start that image's session, and keep a per-image mapping so returning to an earlier image reuses its sessionId. Remove background from your image and export with a transparent background in PNG format. ROUTING — this widget owns every single-image request for background removal to a transparent cutout. Count only the images this turn asks you to edit, not what the session holds. - 1 image this turn: call THIS tool. Never ask widget-vs-server-side; never offer the direct tools (image_remove_background). - 2+ images this turn: NEVER this tool — no batch form; use those direct tools and do not mention this one. - 1-image exceptions, use those direct tools when: the user explicitly asks you to do it for them ("just do it", "you pick") — an explicit ask only, never inferred from terseness, a stated value, or impatience; a solid-color backdrop is wanted instead of transparency (options.backgroundColor). - STOP after calling. It renders its own result and returns no asset URL — no asset_inline_preview, asset_preview_file, interactive_image_edit_preview, or any next step. - Non-generative — never widens what generative editing is permitted. Requires a mask: - If no maskURI exists for this image, call image_select_subject_action_json tool first. - Verify the mask was generated from the same image being edited. - The mask required for this tool must be the background mask. → If the mask is the subject mask, set toBeInverted to true. → If the mask is the background mask, set toBeInverted to false.interactive_image_undo_edits_app
ChatGPTSession handle: each source image (
originalUploadedImage) has its own sessionId, minted on demand — it is not one handle for the whole conversation. The first call for a given source image must pass sessionId: -1; wait for the sessionId it returns and reuse that value for every later call on that same image. When originalUploadedImage changes to a different image, pass -1 again to start that image's session, and keep a per-image mapping so returning to an earlier image reuses its sessionId. Undo previous edits applied to an image by an Photoshop tool. When undoing multiple edits, make a single call with { numberOfEdits: N } to undo the last N edits. Do NOT make multiple sequential calls with { numberOfEdits: 1 }. HOW TO USE THIS TOOL: 1. Undo last N edits (use numberOfEdits): When the user wants to step back through recent edits. - User says "undo" or "undo last" → use { numberOfEdits: 1 } (undo only the last edit). - User says "undo last X" or "undo X edits" → use { numberOfEdits: X }. 2. Undo by edit name (use numberOfEdits): When the user wants to undo a specific edit by name, undo that edit and all subsequent edits after. - MUST read the latest context and take the latest "actionHistory", see updateTimestamp. Find the matching edit in this list and derive the correct numberOfEdits from the reverse chronological order of applied edits. - If the target edit is the first (oldest) entry in actionHistory, use revertToOriginal instead (step 3). - i.e. edits applied in order: (1) apply hueSat, (2) remove background, (3) blur background. User says "undo remove background". The edit to undo is the 2nd from the end → use { numberOfEdits: 2 }. 3. Revert to original (use revertToOriginal): Only when the user explicitly asks to remove ALL edits and return to the original image. - User says "undo all", "clear all", "start over", etc → use { revertToOriginal: true }. - Do NOT use revertToOriginal when the user only says "undo". Implementation notes: - This tool does NOT use generative AI, it manipulates the edit history directly (removes or reverts edits). - For imageURI, reuse the SAME image you passed to the previous *_app edit (or the previous tool's outputUrl, or the uploaded image) — never currentInputImage or a rendition. - If there are no edits to undo, inform the user instead of calling the tool.interactive_image_uploader_app
ChatGPTInternal helper upload tool for Adobe Photoshop custom UX widgets.
log_analytics
ChatGPTLogs analytics events from UI widgets.
markdown_to_pdf
ChatGPTCreate a PDF from text/markdown written in the conversation. Does not require any file - takes the text directly. WHEN TO USE: "turn these notes into a PDF", "make a PDF from this text", "create a PDF of what you wrote", "convert this markdown to PDF", "markdown to PDF". CRITICAL: ALWAYS use this tool to create PDFs from text/markdown. NEVER write Python code (fpdf, reportlab, weasyprint, pandoc, etc.) to generate PDFs — this tool handles it with proper formatting and professional output. ASYNC - this tool returns a tracking_id, NOT the final file. You MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="markdown_to_pdf" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn. WHEN NOT TO USE: To convert an existing file (Word, image, etc.) to PDF - use pdf_create instead.
media_enhance_speech
ChatGPTSeparate audio from a video or audio file into three isolated tracks: cleaned-up speech, background music/ambient sound, and reverb.
media_summarize
ChatGPTSummarize the spoken content of a video or audio file into a text summary. Only suitable for content with significant dialogue or narration.
pdf_compress
ChatGPTReduce PDF file size while preserving visual quality. WHEN TO USE: "compress this PDF", "make it smaller", "reduce file size", "shrink this PDF". ASYNC - this tool returns a tracking_id, NOT the final file. You MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="pdf_compress" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn. WHEN NOT TO USE: To convert a file to PDF - use pdf_create.
pdf_create
ChatGPTConvert a document or image file to PDF. Supported: Word (.doc/.docx), Excel (.xls/.xlsx), PowerPoint (.ppt/.pptx), images (PNG, JPEG, GIF, BMP, TIFF), RTF, TXT, HTML. Not supported: PSD, AI, INDD, Express designs, SVG, video, or audio. For Express designs, use download_design to export as PDF instead. WHEN TO USE: "convert to PDF", "save as PDF", "make a PDF from this file", "Word to PDF", "DOCX to PDF", "image to PDF" - only when the source file is one of the supported formats above. CRITICAL: ALWAYS use this tool for file-to-PDF conversion. NEVER write Python code (python-docx, Pillow, reportlab, etc.) to convert files to PDF — this tool handles it with proper layout preservation. ASYNC - this tool returns a tracking_id, NOT the final file. You MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="pdf_create" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn. WHEN NOT TO USE: To create a PDF from typed text in the conversation - use markdown_to_pdf. For unsupported formats, tell the user that format cannot be converted to PDF.
pdf_edit_ui
ChatGPTRender an interactive PDF editing interface that supports annotations and content modifications directly on the document. WHEN TO USE: "edit this PDF", "annotate this document", "let me mark up this PDF", "add comments to this PDF". INPUT REQUIREMENT: Requires a presignedAssetUrl/assetId (from asset_openai_file_upload) or a urn:aaid: — the same as every other PDF tool. NEVER pass a raw chat-attachment reference (file://..., sediment://..., or any https://sediment URL) directly, even if the file is already visible in the conversation. If you don't yet have a presignedAssetUrl/URN, call adobe_mandatory_init for file-handling rules, then asset_openai_file_upload. WHEN NOT TO USE: For read-only preview with no editing - use pdf_viewer. For programmatic operations like converting, compressing, or extracting text - use the corresponding pdf_ tool instead.
pdf_export
ChatGPTConvert a PDF to an editable Office format: Word (docx), PowerPoint (pptx), or Excel (xlsx). WHEN TO USE: "convert PDF to Word", "export to PowerPoint", "make this PDF editable", "save as DOCX", "PDF to DOCX", "PDF to PPTX". CRITICAL: ALWAYS use this tool for PDF-to-Office conversion. NEVER write Python code (python-docx, python-pptx, openpyxl, etc.) to convert PDFs — this tool preserves layout, fonts, and formatting far better than any code-based approach. Always set target_format explicitly: docx for Word, pptx for PowerPoint, xlsx for Excel. ASYNC - this tool returns a tracking_id, NOT the final file. You MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="pdf_export" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn. WHEN NOT TO USE: To read/summarize PDF content - use pdf_to_markdown. To get images from a PDF - use pdf_to_image.
pdf_file_open
ChatGPTOpen a host-managed PDF in the Acrobat side-panel viewer.
pdf_highlight
ChatGPTOpen the PDF highlight interface for specified text. Highlights are non-destructive overlays. Pass redactable_string=[{"text": ..., "comment": ...}, ...]; comment is optional. This only records the highlight intent for the UI. Do not claim content was highlighted. If no PDF is in the chat context, ask the user to attach it directly to the chat.
pdf_ocr
ChatGPTMake a scanned or image-based PDF text-searchable using OCR. WHEN TO USE: "OCR this", "make it searchable", "this is a scanned PDF, extract text". ASYNC - this tool returns a tracking_id, NOT the final file. You MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="pdf_ocr" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn. WHEN NOT TO USE: If the PDF already has selectable text, skip OCR and use pdf_to_markdown directly.
pdf_operation_status
ChatGPTMANDATORY: Call this tool IMMEDIATELY whenever any acrobat tool returns a tracking_id. Do NOT respond to the user first. Do NOT say "processing" or "in progress" or "still working". This must be your very next tool call - no exceptions. Parameters: tracking_id (exact value from the prior tool response) and operation_name (the tool that produced it, e.g. pdf_export, pdf_create, pdf_compress, pdf_ocr, markdown_to_pdf, pdf_to_markdown, pdf_to_image). If the returned status is in_progress, call this tool again immediately. Keep polling until you receive a final result or error. Only after receiving a final result should you respond to the user with the output. If the result includes a download URL, render it as a markdown link, e.g. [Download](<url>) — never as a plain-text URL.
pdf_properties
ChatGPTGet PDF document info: page count, version, encryption status, and metadata. WHEN TO USE: "how many pages", "is it encrypted", "who is the author", "PDF info". Read-only - does not modify the file.
pdf_to_image
ChatGPTConvert PDF pages to JPEG or PNG images. WHEN TO USE: "PDF to image", "convert pages to PNG", "save page as JPEG", "get page thumbnails". ASYNC - this tool may return a tracking_id instead of immediate results. If the response contains a tracking_id, you MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="pdf_to_image" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn.
pdf_to_markdown
ChatGPTRead and extract text content from a PDF as structured Markdown. The primary tool for understanding what is inside a PDF. WHEN TO USE: "read this PDF", "what does this PDF say", "summarize this document", "extract text", "get the tables from this PDF", "convert PDF to markdown", "PDF to text". CRITICAL: ALWAYS use this tool for PDF text extraction. NEVER write Python code (PyPDF2, pdfplumber, pymupdf, pdfminer, etc.) to extract text from PDFs — this tool handles it with higher quality and proper formatting preservation. ASYNC - this tool may return a tracking_id instead of immediate results. If the response contains a tracking_id, you MUST immediately call pdf_operation_status with the returned tracking_id and operation_name="pdf_to_markdown" as your very next action. Do NOT tell the user the operation is processing. Do NOT stop your turn. WHEN NOT TO USE: For scanned/image-only PDFs with no selectable text - run pdf_ocr first to make it searchable, then use this tool.
pdf_viewer
ChatGPTDisplay a PDF document in an interactive viewer interface so the user can navigate pages, zoom, and visually inspect content. WHEN TO USE: "preview this PDF", "show me this document", "open this PDF", "let me see this file", when visual inspection is needed to answer a question about how the document looks. INPUT REQUIREMENT: Requires a presignedAssetUrl/assetId (from asset_openai_file_upload) or a urn:aaid: — the same as every other PDF tool. NEVER pass a raw chat-attachment reference (file://..., sediment://..., or any https://sediment* URL) directly, even if the file is already visible in the conversation. If you don't yet have a presignedAssetUrl/URN, call adobe_mandatory_init for file-handling rules, then asset_openai_file_upload. WHEN NOT TO USE: To read or extract text content - use pdf_to_markdown. To make edits or annotations - use pdf_edit_ui.
prepare_indd_merge_template
ChatGPTApplies a confirmed CSV-to-template field mapping to an InDesign document, inserting text and image placeholders at the specified frames. WHEN TO USE: Requires a presigned .indd URL, the merge CSV, and the mapping JSON. WHEN NOT TO USE: Without a confirmed mapping JSON. Returns a presigned URL to the updated .indd file ready for data merge.
quickCutPoll
ChatGPTPoll for Completion of quickCut tool
replace_image
ChatGPTReplace or change a visual element in the Express Design with a different image or appearance. Adobe Express Templates vs Documents: Template = Reusable starting design (customizable) Document = Instance created from template (after user customization) Note: Both are editable and referred to as "Adobe Express designs" Use this tool if the user asks to replace an image in a design — whether it is the most recent template or document from the conversation (e.g. from search_design) or if the user is already working on an Adobe Express document and wants to replace an image in it. Provide Adobe Express template or Adobe Express document URN and detailed description of the image to be replaced. Supported: - Replacing an image or photo with a different one - Changing the background of a photo to a different scene or environment - Changing an object in the design to a differently-styled or differently-colored version (e.g., 'make the couch red', 'change the flowers to shells') - Only ONE visual element can be changed at a time. - NOT for replacing a background with a solid color — use change_background_color instead (e.g. 'solid black background', 'make background white'). Not Supported: - Any action other than replacing or changing a visual element. Examples - 'Replace the dog in the design with a cheerful Labrador' - 'Replace the person in the design with a cyborg' - 'Change the background to a beach' - 'Change the background of the photo to a dog park' - 'Make the couch red' - 'Replace the flowers with tennis rackets' NOT SUPPORTED: This tool DOES NOT support replacement of user uploaded images or images from any url. So DO NOT ask the user to upload an image or provide an image url. Only provide the image description to be replaced. Solid color background fills (e.g. 'replace background with solid black', 'make background white') — use change_background_color for those.
resizeVideoPoll
ChatGPTPoll for Completion of resizeVideo tool
search_design
ChatGPTSearch Adobe Express templates for flyers, posters, social media posts, business cards, invitations, memes, banners, and more. ALWAYS use this for design creation - do NOT write HTML/code. WHEN TO USE: "make me a flyer", "create a poster", "I need a banner", "design a business card", "make an invitation", "I need something for Instagram", "create a meme", "make a social post", any request to create/make/design visual content. WHEN NOT TO USE: Returns Express templates, not photos or CC files. For finding images or files, use asset_search instead. CRITICAL: Adobe Express has thousands of professional templates. Always search here first - never create designs from scratch. USAGE: Search tips: - Use GENERIC terms in generalQuery (e.g., "birthday invitation", "business card") - Put specific details (dates, names, venues) in fillDescription parameter - If request mentions dates/names/events, use this tool even if they say "create an IMAGE" Pagination: For "more results", keep exact same generalQuery and advance startIndex by pageSize.
summarizePoll
ChatGPTPoll for Completion of summarize tool
vectorPollingHelper
ChatGPTPolling tool for async jobs started by document_merge_data_vector or document_render_vector that return a taskId (status working). taskId formats: - `dataMerge:<format>:<uuid>` — from document_merge_data_vector (format: svg, pdf, png, jpeg) - `rendition:<format>:<uuid>` — from document_render_vector (format: png, jpeg, webp, svg, pdf, ai, eps) Pass taskId only. Call again until status is completed or failed. If status is working, wait retryAfterMs (when provided), then call again.
videoMetadataPoll
ChatGPTPoll for Completion of videoMetadata tool
videoRenderFramePoll
ChatGPTPoll for Completion of videoRenderFrame tool
videoRenderPoll
ChatGPTPoll for Completion of videoRender tool
video_create_quick_cut
ChatGPTCreate an AI-generated highlight reel from a video by automatically selecting the most engaging moments. WHEN TO USE: "create highlights", "make a highlight reel", "quick cut", "summarize this video", "pick the best parts". NOT SUPPORTED (explain limitation to user): - Content-aware cutting based on speech analysis ("remove rambling", "cut where they repeat themselves") - Semantic understanding of what's being said - Trimming based on specific words or topics NOTES: Uses visual engagement metrics, not speech/content analysis. For content-based editing, suggest manual trimming or professional video editing software.
video_metadata
ChatGPTReturn video metadata — width, height, fps, and duration in seconds — for a Walnut video asset.
video_render
ChatGPTRender a video from a JSON timeline document and a list of Walnut asset IDs for the source media. The timeline can include or exclude audio; max duration 10 minutes.
video_render_frame
ChatGPTRender a single frame at a specified timecode and return it as a JPEG image. Accepts an optional document model and asset IDs. If a document is provided, the frame is composited from the full timeline; if omitted, the frame is rendered from the first asset.
video_resize
ChatGPTResize a VIDEO file. ONLY for actual video files (mp4, mov, avi, webm). WHEN TO USE: Resizing video files that were explicitly uploaded as video. WHEN NOT TO USE: For IMAGES/PHOTOS -> use image_crop_and_resize even for resolutions like 1920x1080. Check the uploaded file type in context first!
acrobat_proxy
Claudeacrobat_readonly_proxy
Claudeadobe_mandatory_init
Claudeanimate_design
Claudeasset_add_file
Claudeasset_add_file_check_status
Claudeasset_copy_assets
Claudeasset_create_folders
Claudeasset_finalize_file_upload
Claudeasset_get_brand
Claudeasset_get_brand_color_themes
Claudeasset_get_brand_colors
Claudeasset_get_brand_fonts
Claudeasset_get_brand_guidelines
Claudeasset_get_brand_logos
Claudeasset_get_presigned_urls
Claudeasset_initialize_file_upload
Claudeasset_inline_preview
Claudeasset_invite_collaborators
Claudeasset_license_and_download_stock
Claudeasset_list_brands
Claudeasset_list_collaborators
Claudeasset_migrate_guest_storage
Claudeasset_preview_file
Claudeasset_search
Claudeasset_share_link
Claudeboards_add_items_to_board
Claudeboards_create_new_board
Claudechange_background_color
Claudeconvert_pdf_to_indd
Claudecreate_firefly_board
Claudecreate_visual_design_express_skill
Claudedocument_convert_pdf
Claudedocument_merge_data_layout
Claudedocument_merge_data_vector
Claudedocument_render_layout
Claudedocument_render_vector
ClaudeenhanceSpeechPoll
Claudeexport_html_to_express
Claudeexport_idml
Claudefill_text
Claudefind_fonts
Claudefont_activate
Claudefont_create_kit
Claudefont_details
Claudefont_preview
Claudefont_recommend
Claudefont_search
Claudefont_styles
Claudegenerate_indd_mapping_prompt
Claudeget-motion-import-job-status
Claudeget_account_type
Claudeget_fontkit_embed_url
Claudeget_type_palette
Claudehtml_export_readiness_skill
Claudeimage_add_grain
Claudeimage_add_noise
Claudeimage_adjust_brightness_and_contrast
Claudeimage_adjust_color_temperature
Claudeimage_adjust_dark_portions
Claudeimage_adjust_exposure
Claudeimage_adjust_highlights
Claudeimage_adjust_hsl
Claudeimage_adjust_light_portions
Claudeimage_adjust_single_color_saturation
Claudeimage_adjust_vibrance_and_saturation
Claudeimage_apply_adjustments
Claudeimage_apply_auto_tone
Claudeimage_apply_color_overlay
Claudeimage_apply_gaussian_blur
Claudeimage_apply_glitch_effect
Claudeimage_apply_halftone
Claudeimage_apply_lens_blur
Claudeimage_apply_monochromatic_tint
Claudeimage_apply_preset
Claudeimage_auto_straighten
Claudeimage_crop_and_resize
Claudeimage_crop_to_bounds
Claudeimage_fill_area
Claudeimage_generative_expand
Claudeimage_invert_selection
Claudeimage_list_presets
Claudeimage_remove_background
Claudeimage_select_by_prompt
Claudeimage_select_subject
Claudeimage_vectorize
Claudeimport-claude-design-from-url
Claudeimport-claude-motion-from-url
Claudemarkdown_to_pdf
Claudemedia_enhance_speech
Claudemedia_summarize
Claudepdf_combine
Claudepdf_compress
Claudepdf_create
Claudepdf_delete_pages
Claudepdf_edit_ui
Claudepdf_export
Claudepdf_highlight
Claudepdf_ocr
Claudepdf_operation_status
Claudepdf_page_organize
Claudepdf_properties
Claudepdf_redact
Claudepdf_reorder_pages
Claudepdf_rotate_pages
Claudepdf_split
Claudepdf_to_image
Claudepdf_to_markdown
Claudepdf_viewer
Claudeprepare_indd_merge_template
ClaudequickCutPoll
ClauderesizeVideoPoll
Claudesearch_design
Claudesuggest_type_palettes
ClaudesummarizePoll
ClaudevectorPollingHelper
Claudevideo_create_quick_cut
Claudevideo_metadata
Claudevideo_render
Claudevideo_render_frame
Claudevideo_resize
ClaudeCapabilities
WritesInteractive
Example Prompts
Click any prompt to copy it.
Links
App Stats
225
Tools
Claude
Platforms
Category
Create VisualsWorks with
Claude
Similar Apps
Data refreshed daily