apply_actions
ChatGPTApply an ordered list of project mutations — the op values (create_object, update_object, delete_object, create_scene, …, see the schema) are ops of this one tool, not tools. Commits as ONE undo step (the user can Cmd+Z it; you can call undo). Malformed actions are skipped and reported in skipped (index, op, id, reason); the valid ones in the same call still apply, and nothing applying is an error — atomic:true applies nothing if any action would be skipped, dryRun:true compiles and reports without committing. A create's config.id is an alias for THIS call — the engine assigns the real id and returns the mapping in ids; use those ids in later calls. The result also lists the scenes the call touched (scenes), the geometry of every object it touched (objects: bounds, offCanvas, textOverflow for fixed-size text on screen) and warnings (e.g. a fontFamily nobody has). Rules it writes run when the show plays and can reach outside the project: openURL opens its link; fetch (a web request) is written by hand in the editor — send back the ones you read as they are, a new or changed one is skipped. Read get_guide('apply') first for the rules, then the sections for the config shapes you need.
arrange_object
ChatGPTMove objects in the layer stack as one undo step: options.to brings one to the front or the back, or one step forward or backward; options.parentObjectId moves it into a group or frame (null = out to the scene) at options.index. It keeps its position on the canvas.
control_show
ChatGPTDrive the presentation on the user's screen: 'start' opens it (add fromStart to begin at the first scene instead of the current one) with its opening scene waiting for the first 'next' unless the show loops or its rules run without input, 'next' and 'previous' are the clicker — they hurry an in-flight transition onto its scene (it lands a moment later), then walk the scene's stop points, then cross to the next scene — 'goTo' jumps to sceneId, 'togglePlayback' holds the scene clock where it is or lets it run again, 'toggleCover' blanks the screen (cover black or white; again brings the deck back), 'endShow' ends on the closing card, and 'exit' returns to the editor. Everything but start needs a running show. The show opens in the editor's own window, since going fullscreen needs the user to do it — with pendingFullscreen it opens at screen size and the user's first click on it goes fullscreen. Nothing here changes the document, so none of it is undoable. The show is shared live by default: everyone who has the project's play link open follows it on their own device, so what it shows them can't be taken back. Entering a scene also runs the rules that fire on entry or on a timer: a fetch rule sends its request, an openURL rule opens its link. Returns the mode the editor ended up in and the scene now on screen; get_show_state reads the rest.
convert_to_path
ChatGPTReplace objects with editable paths of the same outline, as one undo step. A type the engine cannot convert is skipped with the reason.
create_object
ChatGPTCreate objects, in order, as one undo step (calling it again creates them again). Give each a FULL config — size, transform, style and its type's data — rather than creating it and then updating it; get_guide('apply') has the layout rules. A table is one object whose config.data.values (its cell texts by row) makes the grid (get_guide('table')). A config.id alias (a word such as "card1") lets a later entry use it as options.parentObjectId or as a connector end's objectId; the result maps each alias to the real id. With newScene, a new scene is added first and every object goes into it — a slide and its content in one undo step. Motion and interaction rules follow with set_motion and set_rules.
create_project
ChatGPTStart a new, empty project in this account and get back its projectId and the URL that opens it. Use it when list_projects shows the account has none. The project is empty until someone opens that URL: the editor tools need it open, and reading it before then says it has no saved document — so create it, hand the user the URL, and ask them to open it.
create_scene
ChatGPTAdd empty scenes (slides) as one undo step (calling it again adds them again); the result lists their ids for create_object. To add a slide together with its content, use create_object with newScene. A scene's background, motion and rules are set with set_style, set_motion and set_rules.
create_variable
ChatGPTAdd document variables as one undo step (calling it again adds them again). Text shows a variable as {{name}}, and interaction rules can change it.
delete_object
ChatGPTDelete objects as one undo step. A group or frame is deleted with its children.
delete_scene
ChatGPTDelete scenes with everything on them, as one undo step.
delete_table_columns
ChatGPTDelete columns of tables with their cells, as one undo step: count columns from index. A merged cell reaching past them shrinks; a table keeps at least one column.
delete_table_rows
ChatGPTDelete rows of tables with their cells, as one undo step: count rows from index. A merged cell reaching past them shrinks; a table keeps at least one row.
delete_variable
ChatGPTDelete variables as one undo step.
duplicate_object
ChatGPTCopy objects as one undo step (calling it again copies them again). A copy lands just above its original unless options place it; it keeps its position on the canvas. The result lists the copies.
duplicate_scene
ChatGPTCopy scenes with their content as one undo step (calling it again copies them again); the result lists the copies.
find_objects
ChatGPTFind objects by a substring of their name or text content — every scene (or one), nested children included — without paging get_scene. Up to 50 matches in scene order: id, sceneId, type, name, text.
get_fonts
ChatGPTFonts a text may name: the registerable catalog (family, languages, weights, hint) and the faces already registered in this project. A fontFamily outside both falls back to the system font — apply_actions warns when that happens.
get_guide
ChatGPTEngine guide for authoring actions. Read topic 'apply' once before your first edit — the protocol rules and action recipes (build each object fully in one create, set.style replaces, anchors, decks) — then fetch only the sections you need. Call with no topic for the outline: every section and subsection title; a topic matches any title (case-insensitive substring) and returns that section with its subsections, e.g. 'apply', 'text' (the text rules and F1–F17 formulas), 'style', 'motion', 'object types', 'deck' (a multi-slide recipe).
get_object
ChatGPTOne object's full serialized detail (style/motion/data; long asset src elided), the sceneId it lives in and its bounds on the canvas (x/y/width/height, document coordinates).
get_project_overview
ChatGPTCheap first read of one project: canvas size, scene list (id/name/visible/object count/type histogram), active scene, current selection, the viewport (the canvas area on the user's screen), variables (id/name/type/value), registered fonts (family/weights/styles), the media the project already holds (assets — reuse one of these asset:// uris instead of importing the same file again), the editing context (editor — which mode the user is in and whether a write will land as a keyframe; see get_guide('apply')), document notes. Drill into a scene with get_scene.
get_scene
ChatGPTOne scene: its own fields (name, description, notes, visible, style, data.clip, motion — what update_scene can set) and its object tree in compact form (engine defaults omitted, long text/path/src elided). Default = the active scene. Use get_object for one object's full detail.
get_screenshot
ChatGPTPNG snapshot of a scene (or one object) as rendered right now, with a text block naming the scene and the pixel size. The cheapest way to verify visual state after edits — prefer this over re-reading the scene tree. Any scene can be captured; time (ms) poses the ACTIVE scene at that point of its timeline (see motion.animations) before capturing. A small SSHOW mark in the bottom-right corner is the offline editor's own watermark, not a project object.
get_show_state
ChatGPTWhere the running presentation stands, as the presenter view sees it: the scene on stage (index / total over visible scenes, a beat ahead while a transition is in flight) and the next one, the speaker notes (scene and project), the scene clock (playing / waiting at a stop / at its end, time, stops passed), what the next clicker input will do (forecast: skipAhead, playToNextStop, playToEnd, nextScene, backToFirst, endOfShow, finishTransition, backToShow), the screen cover in effect, whether the audience window still owes a click for fullscreen, and the show timer. showing is false with only mode when no show is running. Read-only.
group_objects
ChatGPTGroup objects as one undo step: each entry wraps two or more objects of one scene in a new group. config.id is an alias the result maps to the new group id.
import_asset
ChatGPTBring an image, video or audio file into the project as an asset and get the asset:// src to put in create_object / update_object (data.src, image fills) — use it in your next apply_actions (an asset nothing references is garbage-collected). url is fetched by the user's editor in the browser: a data: URL always works; an https URL must allow cross-origin reads. Returns id, uri, type, mimeType, size, plus the media's width/height in pixels and a video/audio duration in seconds when the browser can read them — size the object from those or it keeps the 100x100 default and the media arrives squashed.
insert_table_columns
ChatGPTInsert columns into tables as one undo step: count columns at index (omit = after the last column), each new cell in its neighbor's text style, values each table row's texts of the new columns. A merged cell the columns land inside grows over them.
insert_table_rows
ChatGPTInsert rows into tables as one undo step: count rows at index (omit = after the last row), each new cell in its neighbor's text style, values their texts row by row. A merged cell the rows land inside grows over them.
list_projects
ChatGPTList the projects the user has open right now — each open editor is a target. Call this first to discover projectIds.
merge_table_cells
ChatGPTMerge a range of cells in tables into one cell, as one undo step: their texts join into the range's first cell, line by line. Every cell in the range holds text.
redo
ChatGPTRedo the apply_actions this agent last undid. Refused when the newest undone entry is the user's.
reorder_scene
ChatGPTMove scenes to another position in the deck, as one undo step.
reorder_variable
ChatGPTMove variables to another position in the list, as one undo step.
select_objects
ChatGPTSelect objects in the active scene to point the user at them (empty array clears selection). An id from another scene is refused with a pointer to that scene — call set_active_scene first.
set_active_scene
ChatGPTNavigate the user's editor to a scene (keeps their screen in sync with your edits). It is not a document change, so it is not undoable. The active scene is where an apply_actions op without sceneId lands and what get_scene and get_screenshot read when no scene is given; select_objects, and get_screenshot with objectId or time, work only in it. An unknown sceneId is refused. Returns the new activeSceneId.
set_canvas_size
ChatGPTSet the canvas size every scene shares, in pixels, as one undo step. Objects pinned to the canvas follow its new edges.
set_motion
ChatGPTSet motion on objects, or on a scene when id is left out, as one undo step: navigation transitions (guide §8) and the scene's timeline (guide §10). A scene's clock and its objects' tracks can go in one call; transitions and animations merge into what is already there.
set_rules
ChatGPTReplace the interaction rules of objects, or of a scene when id is left out, as one undo step (guide §13). Rules run in a show or the preview: an openURL rule opens its link and a fetch rule calls its web address. A fetch rule is written by hand in the editor, so send back the ones you read unchanged — a new or changed one is skipped.
set_style
ChatGPTReplace the style — fills, strokes and effects — of objects, or of a scene (its background) when id is left out, as one undo step. The whole block is replaced: always send all three arrays.
show_end
ChatGPTEnd the show on its closing card. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.
show_exit
ChatGPTLeave the show and return to the editor. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.
show_go_to
ChatGPTJump the show to a visible scene; a blanked screen comes down with the jump. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link.
show_next
ChatGPTAdvance the show the way the clicker does: a transition still in flight is hurried onto its scene, then the scene's stop points play one by one, then the next scene comes. While the screen is blanked it brings the deck back instead. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link.
show_previous
ChatGPTStep the show back the way the clicker's back button does. While the screen is blanked it brings the deck back instead. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link.
show_start
ChatGPTStart presenting the project in the editor's own window (fromStart = from the first scene). Going fullscreen needs the user's own click, so with pendingFullscreen it opens at screen size and their first click goes fullscreen. The opening scene waits for the first show_next unless the show loops or its rules run on their own. The show is shared live by default: everyone with the project's play link open follows it on their own device. Entering a scene runs its entry and timer rules: a fetch rule sends its request, an openURL rule opens its link. Returns the mode the editor is in and the scene on screen; get_show_state reads the rest.
show_toggle_cover
ChatGPTBlank the audience's screen black or white; the same color again brings the deck back, and the other color swaps the blank screen. The closing card is left alone. Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.
show_toggle_playback
ChatGPTHold the scene clock where it is if it is running, or let a held clock run on to its next stop; calling it again reverses it, and a scene without a timeline has nothing to hold. While the screen is blanked it brings the deck back instead. get_show_state reports which applies (transport.status, cover). Needs a running show (show_start). The show is shared live by default: everyone with the project's play link open follows it on their own device.
simulate_event
ChatGPTSend one input to the running show (or the editor's preview) and see what the document's rules did with it — the interaction counterpart of get_screenshot. type is the input: click, doubleClick, longPress, pointerDown, pointerUp, pointerEnter (the pointer moving onto objectId), pointerLeave (the pointer leaving the deck), swipe (+ direction), keyDown (+ key, ctrl/shift/alt), message (+ name, and payload for what a message rule's into reads). objectId is the object under the pointer — omit it for empty space, which the scene's own rules answer. Returns the rules that fired, the ones a condition or a failure held back (with the reason), consumed (a click no rule takes is reported, not passed to the clicker — control_show('next') advances the deck), the scene now on screen, and a screenshot taken once a scene transition the rules started has finished — add wait (ms) to let an animation play before the capture. Rules run only while a show or the preview is up: call control_show('start') first and 'exit' when done. Nothing here changes the document, but the rules it fires run for real: a fetch rule sends its request, an openURL rule opens its link, and a live show's audience sees the result.
style_text_range
ChatGPTGive words inside texts their own color or line, as one undo step: each entry finds its words in a text's data.text — every place they stand, or the occurrence-th from 0 — and gives them one solid color (fills) and/or a textDecoration; fills [] gives them the text's fill back.
undo
ChatGPTUndo this agent's last apply_actions. Refused (ok:false with the reason) when the newest history entry is the user's own edit — that one is theirs to undo.
ungroup
ChatGPTDissolve groups as one undo step; their children stay where they are on the canvas.
unmerge_table_cells
ChatGPTSplit every merged cell in a range of tables back into single cells, as one undo step; each keeps its text in its first cell.
update_document
ChatGPTChange the document's name, description or project notes, as one undo step.
update_object
ChatGPTChange existing objects as one undo step: send only the keys that change in set (transform, size, data and layout merge; distort replaces, null clears it). A table's set.data writes its cell texts, column widths, row heights and looks (get_guide('table')). Style, motion and interaction rules have their own tools: set_style, set_motion and set_rules.
update_scene
ChatGPTRename scenes, edit their presenter notes, show or hide them, or clip their content to the canvas, as one undo step.
update_variable
ChatGPTChange variables' name, description, type or value, as one undo step.
apply_actions
Claudecontrol_show
Claudecreate_project
Claudefind_objects
Claudeget_fonts
Claudeget_guide
Claudeget_object
Claudeget_project_overview
Claudeget_scene
Claudeget_screenshot
Claudeget_show_state
Claudeimport_asset
Claudelist_projects
Clauderedo
Claudeselect_objects
Claudeset_active_scene
Claudesimulate_event
Claudeundo
Claude