Slide Operations

Your AI assistant uses these tools to work with individual slides — adding new ones, inspecting what's on them, making copies, and removing slides you don't need.

A slide is a single page in a presentation. Each slide has a background color and contains elements like text, shapes, lines, and images. When you ask your assistant to modify specific slides, it uses these tools behind the scenes. For creating multiple slides at once, it uses slide_bulk_create instead.

Adding a Slide

When you ask for a new slide in a specific position (“add a blank slide after slide 2”), your assistant uses slide_create. It creates a single slide with an optional layout and returns the placeholder elements created by that layout (title, body, etc.), which can then be styled or filled with content.

Parameters

What It Returns

The default summary gives each slide a header and each element a short block:

• Slide header — the layout, the effective background (tagged(inherited) when the slide does not own it), the element count, the transition, and the build sequence as On arrival: [logo], what plays by itself as the slide comes in, Build steps: [a] → [b, c], one bracket per click, and Reveals: on click of oval-1: [label-1] → [label-2], one bracket per click on each trigger
• Element line —id: type [role] ←layout at (x, y) w×h · step N · morphKey k · link → target.←layout marks an element that came from the slide's layout; · step N is its build step and · on arrival a build that plays by itself as the slide comes in; · on click of X, step N is a reveal, hidden in present mode until the Nth click on element X, its trigger, itself marked · reveals on click; each marker takes with previous or after previous, the duration and the delay in parentheses where they are not the defaults (0.5 s, none): · step 2 (after previous, 3 s, delay 0.5 s); a text element built by paragraph carries · steps a–b by paragraph instead and a marker on each paragraph line; link → names the slideId or address a click on it follows in present mode, next slide, previous slide, first slide or last slide for a link worked out at the click, or deleted slide when its slide is gone; a line prints its two ends
• Paragraphs — one quoted line each, list prefixes kept, numbered¶0,¶1, … when there is more than one
• Style lines — only what is set: text style with each inherited member tagged(inherited), fill and stroke, corner radius, opacity, rotation, an image's crop, alt text and URL, a chart's series
• Tables — the element line reads table (5 rows × 3 columns) "Medium Style 2 – Accent 1" (medium-style-2-accent-1), naming the table style when it has one and then its slug, the name element_update_table takes. Below it come the style options that are on, then the first rows as Row 1: "a" | "b", counting from 1. A merged cell prints its span after its text, "Total" (spans 2 columns), and every other slot it covers prints (merged); the block ends with a note that rows and columns count from 1, as printed. With full it carries a table object: rows, columns, styleName, styleSlug, options, cells, each cell's plain text with null for a merged slot, and merges, each merged cell's top-left and span counting from 1

Withdetail: "full" each element comes back as one JSON object per line, with every field it has set; a key that is absent is not set. The slide line carries buildSteps, arrival when the slide has arrival builds, and reveals when it has reveals; an element's build is { step, startMode, durationMs?, delayMs?, trigger? }, where step 0 is on arrival, startMode is click, withPrevious or afterPrevious, and trigger names the element whose clicks play it, the step then counting those clicks. Pair it withelementIds to read just the elements you are about to restyle.

Example

// Get slides by number (1-based); detail defaults to "summary"
slide_get({
  deckId: "deck_abc123",
  slideNumbers: [1, 2]
})

// ## 2 Slides Retrieved
//
// ### Slide 1 (`slide_001`)
// Layout: Title Slide (`layout_title`) | Background: #1C2833 (inherited) | 2 elements
//
// - elem_a: text [title] ←layout at (80, 200) 1120×100
//   "Q4 Business Review"
//   Size: 44pt (inherited), Font: Inter (inherited), Color: #FFFFFF (inherited), Align: center
// - elem_b: text [subtitle] ←layout at (80, 320) 1120×60
//   "January 2026"
//   Size: 24pt, Font: Inter (inherited), Color: #AAB7B8, Align: center
//
// ### Slide 2 (`slide_002`)
// Layout: Title and Content (`layout_content`) | Background: #1C2833 (inherited) | 3 elements
// Build steps: [elem_d] → [elem_e]
// Elements marked `· step N` fade in on that click in present mode; unmarked elements are static.
//
// - elem_c: text [title] ←layout at (80, 60) 1120×80
//   "Highlights"
//   Size: 36pt (inherited), Font: Inter (inherited), Color: #FFFFFF (inherited), Align: left (inherited)
// - elem_d: text [body] ←layout at (80, 180) 640×300 · step 1
//   ¶0 "- Revenue up 18%"
//   ¶1 "- Two new regions"
//   ¶2 "  - LATAM"
//   ¶3 "  - APAC"
//   Size: 20pt (inherited), Font: Inter (inherited), Color: #FFFFFF (inherited), Align: left (inherited)
// - elem_e: rectangle at (800, 180) 400×300 · step 2
//   Fill: #2E4053, Stroke: none
//   Corner radius: 12

// Before restyling an element, read its full record
slide_get({
  deckId: "deck_abc123",
  slideIds: ["slide_002"],
  detail: "full",
  elementIds: ["elem_e"]
})

// ## 1 Slide Retrieved
// ### Slide 2 (`slide_002`)
// {"slide":{"slideId":"slide_002","index":1,"layoutName":"Title and Content",...,"elementCount":3},"groups":[],"buildSteps":[["elem_d"],["elem_e"]]}
// {"elementId":"elem_e","type":"shape","shapeType":"rectangle","position":{"x":800,"y":180},"size":{"width":400,"height":300},"shapeStyle":{"fillColor":"#2E4053","cornerRadius":12},"build":{"step":2,"startMode":"click"}}

Updating a Slide Background and Transition

When you ask to change a slide's background after it exists — “make slide 2 dark”, “give the title slide a gradient” — your assistant uses slide_update. It sets a solid color, a gradient, or both. A gradient renders over the color, so setting only backgroundColor clears any existing gradient — that's how a gradient slide becomes a solid-color one.

A slide doesn't have to own a background. When it owns none it inherits its layout's, and failing that the master's, so recoloring the master recolors every slide that hasn't chosen its own. Passing backgroundColor: null puts a slide back on that chain, and slide_get reports the effective background, tagged (inherited) when the slide does not own it.

// Switch a slide to a solid dark background
slide_update({
  deckId: "deck_abc123",
  slideId: "slide_xyz789",
  backgroundColor: "#0E1116"
})

// Or apply a gradient (renders over the color)
slide_update({
  deckId: "deck_abc123",
  slideId: "slide_xyz789",
  backgroundGradient: {
    type: "linear",
    angle: 90,
    stops: [
      { position: 0, color: "#50BEBE" },
      { position: 100, color: "#0099CB" }
    ]
  }
})

// Or drop the slide's own background so it inherits the layout's, then the master's
slide_update({
  deckId: "deck_abc123",
  slideId: "slide_xyz789",
  backgroundColor: null
})

// Response:
// {
//   slideId: "slide_xyz789",
//   slideIndex: 2,
//   backgroundColor: "#0E1116",
//   backgroundGradient: null,
//   backgroundInherited: false,
//   transition: null
// }

Transitions

When you ask for a slide to fade, push or morph in — “make slide 5 morph from slide 4” — your assistant setstransition on the slide it should play on. It plays in present mode going forward from the slide before it, andtransition: nullgoes back to a cut.

• type —fade,push,morph, ornone (a cut, used with advanceAfterMsfor a timed slide)
• durationMs — 100 to 5000; 500 suits fade and push, 2000 suits morph
• direction — push only: left(the default), right,up ordown
• advanceAfterMs— advance on its own this long after the slide is in, restarting after each build step; omit it to wait for a click

Morph glides every element whosemorphKey (orelementId, when it has none) matches an element's on the previous slide, and fades the rest.slide_duplicategives every copy its source's key, so a morph stage is a duplicate that carries the transition, then a few element edits on the copy. SeePresent Mode, Builds & Transitionsfor what pairs.

// 1. Copy the slide as a morph stage: every copied element keeps its source's
//    morph key, and the copy moves on by itself a second after it is in
slide_duplicate({
  deckId: "deck_abc123",
  slideNumber: 4,
  transition: { type: "morph", durationMs: 2000, advanceAfterMs: 1000 }
})

// 2. Move things on the copy (element ids from the elementIdMap)
element_bulk_update({ deckId: "deck_abc123", updates: [ /* ... */ ] })

// slide_update sets or changes a transition later; transition: null goes back to a cut

Duplicating a Slide

When you say “copy slide 3” or “make a variation of this slide,” your assistant uses slide_duplicate. It creates a complete copy of the slide and all its elements at the specified position. The response includes a mapping of old element IDs to new ones, so the assistant can update specific elements in the copy without affecting the original.

Parameters

* At least one of slideId or slideNumber must be provided.

What It Returns

• newSlideId — the duplicated slide's ID
• newSlideNumber — position of the new slide (1-based)
• elementsCopied — number of elements duplicated
• elementIdMap — mapping of old element IDs to new ones, so the assistant can update specific elements in the copy
• totalSlideCount — total slides in the deck after duplication
• transition — the copy's transition, or null for a cut

The copy keeps the source's transition unless you pass one, and its builds. Each copied element gets the source element'smorphKey, so a copy with morph glides every element from the source. An element with a build does not pair, so clear a stage's builds with slide_set_build_sequence (steps: [] with arrival: [] and reveals: []) unless it should reveal something.

Example

slide_duplicate({
  deckId: "deck_abc123",
  slideNumber: 1,
  afterSlideNumber: -1    // -1 = end of deck
})

// Response:
// {
//   newSlideId: "slide_new456",
//   newSlideNumber: 9,
//   sourceSlideNumber: 1,
//   elementsCopied: 3,
//   elementIdMap: [
//     { oldElementId: "elem_a", newElementId: "elem_d", type: "text" },
//     { oldElementId: "elem_b", newElementId: "elem_e", type: "text" },
//     { oldElementId: "elem_c", newElementId: "elem_f", type: "shape" }
//   ],
//   totalSlideCount: 9
// }

Reordering Slides

When you say “move the summary to the front” or “put the pricing slide after the demo,” your assistant uses slide_reorder. The other slides shift to make room. Nothing is created or deleted, so element IDs stay the same and the change is one undo step in the editor.

Parameters

* Two shapes: a single move (slideId or slideNumber, plus newSlideNumber), or the whole order as slideIds. Not both.

Example

slide_reorder({
  deckId: "deck_abc123",
  slideNumber: 5,
  newSlideNumber: 2      // slide 5 becomes slide 2; 2–4 shift down
})

// Response:
// {
//   success: true,
//   changed: true,
//   slideId: "slide_xyz789",
//   fromSlideNumber: 5,
//   toSlideNumber: 2,
//   previousSlideIds: ["slide_a", "slide_b", "slide_c", "slide_d", "slide_xyz789"],
//   slideIds: ["slide_a", "slide_xyz789", "slide_b", "slide_c", "slide_d"],
//   totalSlideCount: 5
// }

What It Returns

• previousSlideIds and slideIds — the order before and after
• fromSlideNumber and toSlideNumber — for a single move, where the slide was and where it landed
• changed — false when the requested order already matched, in which case nothing was written

Deleting a Slide

When you ask to remove a slide, your assistant uses slide_delete. This permanently deletes the slide and all its elements — this action cannot be undone. A well-behaved assistant will inspect the slide contents first (using slide_get) to make sure it's deleting the right one.

Parameters

What It Returns

• success — confirmation the slide was deleted
• deletedElementCount — number of elements removed with the slide
• remainingSlideCount — total slides remaining in the deck

Example

slide_delete({
  deckId: "deck_abc123",
  slideId: "slide_xyz789"
})

// Response:
// {
//   success: true,
//   slideId: "slide_xyz789",
//   slideIndex: 2,
//   deletedElementCount: 4,
//   remainingSlideCount: 7
// }

Setting a Build Sequence

When you ask to animate a slide — “reveal the three cards one at a time” — your assistant uses slide_set_build_sequence. It takes the slide's entrance sequence as a list of steps, each the members revealed on one click in present mode, and the arrival members that play by themselves once the slide is in, before the first click, and reveals, what plays when the presenter clicks a particular element, its trigger, in any order with the slide's steps. Members of a step fade in together unless one waits for the members before it. See Present Mode, Builds & Transitions for how builds and reveals play.

Parameters

A member is an element ID, the whole element keeping the timing it has, or an object:

• The call replaces the whole sequence — every element left out is static, visible from the start, so send it complete; steps: [] with arrival: [] and reveals: [] clears every build.
• Timing is kept — a member that leaves out durationMs or delayMs keeps what the slide stores, so a reorder by plain IDs keeps imported timing; pass durationMs: 500 or delayMs: 0 to reset one.
• Every member is checked — each must name an element on this slide (not a layout element, not off the canvas) and may appear once across arrival, steps and reveals, and no step may be empty. A slide that has arrival builds refuses a write without arrival, and one that has reveals a write without reveals, naming them, so a write never drops them by accident. afterPrevious on a step's first member, and a duration or delay outside its bounds, are refused too. A violation is rejected naming the member, step or slide, and nothing is written.
• Every trigger is checked — it is an element of this slide, on the canvas, with no link (an element with a link follows it when clicked), not among its own members, and named once in reveals. A trigger hidden by a step or by another trigger is clickable once it has appeared, but two triggers can't reveal each other, directly or through a third, since neither would ever show. In present mode a click after a trigger's last step hides what it revealed and plays its first step again. A hotspot over part of a picture is a shape with fillColor: "transparent" and no stroke.
• Read it back with slide_get, which prints the sequence on the slide's On arrival, Build steps and Reveals lines, and check it with slide_screenshot at a step, which shows no reveal played; the finished slide shows everything.

What It Returns

• stepCount, steps , arrival and reveals — the sequence as stored, with revealCount, how many triggers have reveals
• changed — each element whose build was written, with its before and after. Sending the sequence the slide already has writes nothing and returns an empty list

Example

// Title first, then both cards together, then the chart
slide_set_build_sequence({
  deckId: "deck_abc123",
  slideId: "slide_xyz789",
  steps: [["title_1"], ["card_a", "card_b"], ["chart_1"]]
})

// Response:
// Slide 4 — 3 build steps: 1. title_1 · 2. card_a, card_b · 3. chart_1

// The title fades in by itself as the slide lands, over a second;
// one click then brings the cards in one after another
slide_set_build_sequence({
  deckId: "deck_abc123",
  slideId: "slide_xyz791",
  arrival: [{ elementId: "title_1", durationMs: 1000 }],
  steps: [[
    "card_a",
    { elementId: "card_b", afterPrevious: true },
    { elementId: "card_c", afterPrevious: true, delayMs: 500 }
  ]]
})

// Response:
// Slide 6 — on arrival: title_1 (1 s) · 1 build step: 1. card_a, card_b (after previous), card_c (after previous, delay 0.5 s)

// The title on the first click; each label when the presenter clicks
// its hotspot, in whatever order the room points
slide_set_build_sequence({
  deckId: "deck_abc123",
  slideId: "slide_xyz792",
  steps: [["title_1"]],
  reveals: [
    { trigger: "hotspot_wheel", steps: [["label_wheel"]] },
    { trigger: "hotspot_chain", steps: [["label_chain"], ["note_chain"]] }
  ]
})

// Response:
// Slide 7 — 1 build step: 1. title_1
// Reveals: on click of hotspot_wheel: 1. label_wheel; on click of hotspot_chain: 1. label_chain · 2. note_chain

// Clear every build on the slide
slide_set_build_sequence({
  deckId: "deck_abc123",
  slideId: "slide_xyz789",
  steps: [],
  arrival: [],
  reveals: []
})

Screenshotting a Slide

slide_screenshot captures a slide as a PNG at the deck's canvas size, so your assistant can look at what it built rather than reasoning from coordinates. Element data alone doesn't catch text sitting on top of text, a color that fights the theme, or whitespace that ended up lopsided.

Parameters

step is for checking an entrance sequence: step 1 and one intermediate step are enough. Layout and design checks want the finished slide, so omit it for those. A step past the last shows every element, and a layout or the master ignores it.

What It Returns

An image content part — a base64 PNG — plus a short status line. The call is read-only and changes nothing on the slide. It is best used after a series of edits, to check the finished result, rather than after every individual change.

Slide Numbering

When you refer to “slide 3” in conversation, your assistant maps that to the right slide behind the scenes. Here's how numbering works:

• slideNumber — always 1-based. Slide 1 is the first slide.
• afterSlideNumber — 1-based with special values: 0 = insert at the beginning, -1 = insert at the end.

Related

• Deck Operations — Create, find, and manage presentations (includes slide_bulk_create for multiple slides)
• Element Operations — Create and style shapes, text, lines, and images on slides
• Layouts — Where a deck's layouts come from and how to pick one
• Create a Presentation with AI — End-to-end guide for building slides with natural language