keyframe-mcp 0.2.1 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # keyframe-mcp
 
-Create, inspect and export 2D skeletal animations in [Keyframe.it](https://www.keyframe.it.com/) from any MCP client.
+Create, inspect and export 2D skeletal animations in [Keyframe.it](https://www.keyframe.it.com/), and rig, animate, play-test and export pixel-art sprites in [Sprite Puppeteer](https://www.keyframe.it.com/sprite-puppeteer), from any MCP client.
 
 ## Install
 
@@ -18,6 +18,10 @@ Other clients:
 
 Version 0.2.0 adds persistent projects, named tools with validated schemas, complete clip creation, animation checks, editable image layers and file exports. Restart the MCP client after updating. For a local checkout, run `npm ci` in `mcp/`, then configure `node` with the absolute path to `mcp/server.mjs`.
 
+Version 0.2.1 adds ownership metadata for the official MCP Registry, where the server is listed as `io.github.kendall8388/keyframe`.
+
+Version 0.3.0 adds 18 `puppeteer_*` tools for Sprite Puppeteer: sample and your own characters, camera sets and directions, contact sheets, keyframed moves, and sheet, Godot, Unity, GameMaker, PNG-frame, Spine, GIF and project exports.
+
 ## Workflow
 
 1. `keyframe_open` resumes a dedicated Chrome profile and waits for saved projects to restore.
@@ -58,6 +62,40 @@ Read `keyframe_session` and pass its `projectId` and `revision` in `expected` to
 
 Every named tool advertises its JSON Schema. Errors use MCP `isError:true` and `{ok:false,error}`. The generic call tool remains available for rigging, slicing, meshes, physics and other advanced methods.
 
+## Sprite Puppeteer
+
+[Sprite Puppeteer](https://www.keyframe.it.com/sprite-puppeteer) rigs and animates pixel-art sprites and lets you play-test them in an arena. It opens as a second page in the same connector profile. There are two kinds of character: **rigged** (one image with a skeleton, built-in moves plus moves you create) and **sprite-sheet** (every frame already drawn, in camera sets such as side, isometric and top-down, with up to eight directions).
+
+1. `puppeteer_open` (optionally `{sample:"orc"}` or `{sample:"golem"}`), or `puppeteer_load_image {path:"/abs/path/hero.png"}` for your own art (PNG, GIF, WebP, JPEG, Aseprite or PSD; the skeleton auto-fits).
+2. `puppeteer_state` lists moves, camera sets and directions (or views), and settings.
+3. Judge motion with `puppeteer_contact_sheet {move:"walk"}`; pick angles with `puppeteer_set_view {set:"iso8", dir:"S"}`.
+4. Rigged characters: read `puppeteer_move_guide`, then `puppeteer_create_move` with keys that list only the channels that change. Check it with a contact sheet and refine with `replace`.
+5. `puppeteer_export {format:"godot", moves:"all", dirs:"8"}` (or sheet, unity, gm, frames, spine, gif, project) writes the file and returns a resource link and local path.
+6. `puppeteer_open_result` shows the page in visible Chrome.
+
+Example move for the sample golem (`puppeteer_open {sample:"golem"}` first):
+
+```json
+{"spec":{"name":"Overhead slam","dur":1.1,"loop":false,"keys":[{"t":0,"pose":{}},{"t":0.35,"ease":"out","pose":{"y":18,"torso":-12,"uarmR":150,"uarmL":150}},{"t":0.55,"ease":"snap","pose":{"y":6,"torso":30,"uarmR":-40,"uarmL":-40}},{"t":1.1,"pose":{}}],"events":[{"t":0.55,"type":"slam"}]}}
+```
+
+| Tool | Purpose |
+| --- | --- |
+| `puppeteer_open` | Open Sprite Puppeteer, optionally with a sample |
+| `puppeteer_methods` / `puppeteer_call` | Every scripting method, and a generic call |
+| `puppeteer_state` | Character, moves, camera or views, settings |
+| `puppeteer_play_move` | Show a move on the stage |
+| `puppeteer_set_view` | Camera set and direction (sheets), view (rigged), facing |
+| `puppeteer_settings` | Background, fps, pixel scale, speed, effects, export options |
+| `puppeteer_move_guide` / `puppeteer_create_move` | Pose channels and conventions; add or replace a keyframed move |
+| `puppeteer_contact_sheet` / `puppeteer_render_frame` | Frames as images |
+| `puppeteer_load_image` | Your sprite from disk as a new rigged character |
+| `puppeteer_export` | Sheet, Godot, Unity, GameMaker, PNG frames, Spine, GIF or project file |
+| `puppeteer_list_projects` / `puppeteer_open_project` / `puppeteer_save` | Projects in the connector profile |
+| `puppeteer_screenshot` / `puppeteer_open_result` | The page, and handoff to visible Chrome |
+
+The page's API is `window.spritePuppeteer`; any browser automation can call it directly. See [llms.txt](https://www.keyframe.it.com/llms.txt).
+
 ## Storage and handoff
 
 The connector uses **its own Chrome profile**, not existing personal Chrome tabs. Projects belong to that profile and site origin. Export project JSON and import it in your usual browser to transfer work. Existing projects from version 0.1.0's temporary browser profile cannot be recovered unless previously exported.
@@ -75,4 +113,4 @@ Close or Apply the human image editor before agent layer edits. Layers retain te
 
 `npm test` runs schema, protocol, persistence, serialization, error and file-resource tests with a fake browser. `../e2e/agent-workflow.html` exercises the real editor API, canvas renders, layer compositing, exports and save/reload through a Vite dev server.
 
-MIT — see LICENSE. This license covers the connector; the editor is a separate hosted application.
+MIT — see LICENSE. This license covers the connector; the editor is a separate hosted application.

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "keyframe-mcp",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "mcpName": "io.github.kendall8388/keyframe",
   "repository": { "type": "git", "url": "https://github.com/kendall8388/Keyframe-it.git", "directory": "mcp" },
-  "description": "MCP server for Keyframe.it — let Claude (or any MCP client) rig, animate and export 2D skeletal animations by driving the free Keyframe.it editor in your browser.",
+  "description": "MCP server for Keyframe.it — let Claude (or any MCP client) rig, animate and export 2D skeletal animations in the free Keyframe.it editor, and rig, animate, play-test and export pixel-art sprites in Sprite Puppeteer, by driving them in your browser.",
   "type": "module",
   "bin": {
     "keyframe-mcp": "server.mjs"
@@ -38,6 +38,10 @@
     "spine",
     "pixi-spine",
     "game-development",
+    "pixel-art",
+    "sprite-sheet",
+    "godot",
+    "unity",
     "gamedev",
     "sprite",
     "slot-symbols",

package/runner.mjs

@@ -1,7 +1,7 @@
 import Ajv from 'ajv'
-import { mkdir, writeFile, readFile } from 'node:fs/promises'
+import { mkdir, writeFile, readFile, stat } from 'node:fs/promises'
 import { homedir } from 'node:os'
-import { join, resolve } from 'node:path'
+import { join, resolve, basename, extname } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import { randomUUID } from 'node:crypto'
 import { definitions } from './tools.mjs'
@@ -15,6 +15,17 @@ export function toContent(result) {
   }
   return { content: [{ type: 'text', text: JSON.stringify(result) ?? 'null' }], ...(result && typeof result === 'object' && !Array.isArray(result) ? { structuredContent: result } : {}), ...(result?.ok === false ? { isError: true } : {}) }
 }
+/* Sprite Puppeteer loads art from the user's disk: images, Aseprite and PSD only, as a data URL the page can read */
+const ART_TYPES = { '.png': 'image/png', '.gif': 'image/gif', '.webp': 'image/webp', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.aseprite': 'application/octet-stream', '.ase': 'application/octet-stream', '.psd': 'image/vnd.adobe.photoshop' }
+const ART_MAX = 40 * 1024 * 1024
+export async function artDataUrl(path) {
+  const type = ART_TYPES[extname(path).toLowerCase()]
+  if (!type) throw new Error(`Sprite Puppeteer loads ${Object.keys(ART_TYPES).join(', ')} files`)
+  const info = await stat(path)
+  if (!info.isFile()) throw new Error(`${path} is not a file`)
+  if (info.size > ART_MAX) throw new Error('That file is over 40 MB')
+  return `data:${type};base64,${(await readFile(path)).toString('base64')}`
+}
 export class ToolRunner {
   constructor(session, outputDir = process.env.KEYFRAME_EXPORT_DIR || join(homedir(), '.keyframe-mcp', 'exports')) {
     this.session = session
@@ -32,6 +43,7 @@ export class ToolRunner {
     const definition = registered.get(name)
     if (!definition) throw new Error(`Unknown tool: ${name}`)
     if (!definition.validate(args)) throw new Error(`Invalid arguments: ${ajv.errorsText(definition.validate.errors)}`)
+    if (definition.target === 'puppeteer') return this.dispatchPuppeteer(name, definition, args)
     const page = await this.session.open(name === 'keyframe_open' ? args.url : undefined)
     if (name === 'keyframe_open_result') return toContent(await this.session.handoff())
     if (name === 'keyframe_screenshot') return { content: [{ type: 'image', mimeType: 'image/png', data: (await page.screenshot({ type: 'png' })).toString('base64') }] }
@@ -46,6 +58,24 @@ export class ToolRunner {
     if (result?.artifact && result.ok !== false) return this.writeArtifact(result)
     return toContent(result)
   }
+  /* Sprite Puppeteer: a second page in the same profile, driven through window.spritePuppeteer */
+  async dispatchPuppeteer(name, definition, args) {
+    const page = await this.session.openPuppeteer()
+    if (name === 'puppeteer_open_result') return toContent(await this.session.puppeteerHandoff())
+    if (name === 'puppeteer_screenshot') return { content: [{ type: 'image', mimeType: 'image/png', data: (await page.screenshot({ type: 'png' })).toString('base64') }] }
+    let method = definition.method, callArgs
+    if (name === 'puppeteer_call') { method = args.method; callArgs = args.args ?? [] }
+    else if (name === 'puppeteer_open') { method = args.sample ? 'loadSample' : 'getState'; callArgs = args.sample ? [args.sample] : [] }
+    else if (name === 'puppeteer_load_image') callArgs = [await artDataUrl(resolve(args.path)), { name: args.name || basename(args.path) }]
+    else callArgs = definition.args(args)
+    const result = await this.session.invokePuppeteer(method, callArgs)
+    if (result?.ok !== false) {
+      try { await this.session.savePuppeteer() }
+      catch (e) { return toContent({ ok: false, error: `The command changed the character, but saving failed: ${e.message}. Retry puppeteer_save, or export a project file.`, applied: true }) }
+    }
+    if (result?.artifact && result.ok !== false) return this.writeArtifact(result)
+    return toContent(name === 'puppeteer_open' ? { ...result, profile: this.session.profile, visible: !this.session.headless, handoffTool: 'puppeteer_open_result' } : result)
+  }
   async writeArtifact(result) {
     const artifact = result.artifact
     const match = artifact.dataUrl?.match(/^data:([^;,]*)(?:;[^,]*)?;base64,(.*)$/s)
@@ -57,7 +87,7 @@ export class ToolRunner {
     await writeFile(path, bytes, { flag: 'wx' })
     const resource = { uri: pathToFileURL(path).href, name: safeName, mimeType: artifact.mimeType || match[1], size: bytes.length }
     this.artifacts.set(resource.uri, { resource, path })
-    const metadata = { ok: true, projectId: result.projectId, path, ...resource }
+    const metadata = { ok: true, projectId: result.projectId, path, ...resource, ...(result.detail ? { detail: result.detail } : {}) }
     return { content: [{ type: 'text', text: JSON.stringify(metadata) }, { type: 'resource_link', ...resource }], structuredContent: metadata }
   }
   resources() { return [...this.artifacts.values()].map(a => a.resource) }

package/server.mjs

@@ -10,7 +10,7 @@ import { advertisedTools } from './tools.mjs'
 
 export function createServer(session = new EditorSession(chromium)) {
   const runner = new ToolRunner(session)
-  const server = new Server({ name: 'keyframe-mcp', version: '0.2.1' }, { capabilities: { tools: {}, resources: {} } })
+  const server = new Server({ name: 'keyframe-mcp', version: '0.3.0' }, { capabilities: { tools: {}, resources: {} } })
   server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: advertisedTools }))
   server.setRequestHandler(CallToolRequestSchema, req => runner.call(req.params.name, req.params.arguments ?? {}))
   server.setRequestHandler(ListResourcesRequestSchema, async () => ({ resources: runner.resources() }))
@@ -32,4 +32,4 @@ if (process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href)
   process.on('SIGTERM', shutdown)
   process.stdin.on('end', shutdown)
   await server.connect(new StdioServerTransport())
-}
+}

package/session.mjs

@@ -5,6 +5,16 @@ export function editorUrl(value) {
   if (url.username || url.password || !(url.protocol === 'https:' || (url.protocol === 'http:' && ['localhost', '127.0.0.1', '[::1]'].includes(url.hostname)))) throw new Error('Use HTTPS, or HTTP on localhost, for the editor URL')
   return url.href
 }
+/* Call a method on a page's scripting API (globalThis.keyframe or globalThis.spritePuppeteer). */
+function callApi(page, global, method, args) {
+  return page.evaluate(async ({ global, method, args }) => {
+    const api = globalThis[global]
+    if (!api || !Object.prototype.hasOwnProperty.call(api, method) || typeof api[method] !== 'function') return { ok: false, error: `Unknown API method ${method}; check the methods tool and update the page if needed` }
+    try { return (await api[method](...args)) ?? { ok: true } }
+    catch (e) { return { ok: false, error: String(e?.message ?? e) } }
+  }, { global, method, args })
+}
+/* One persistent Chrome profile with up to two pages: the Keyframe.it editor and Sprite Puppeteer. */
 export class EditorSession {
   constructor(chromium, env = process.env) {
     this.chromium = chromium
@@ -13,14 +23,19 @@ export class EditorSession {
     this.headless = env.KEYFRAME_HEADLESS !== '0'
     this.context = null
     this.page = null
+    this.pp = null
   }
-  async open(url) {
-    const target = url ? editorUrl(url) : this.url
-    if (this.page && !this.page.isClosed() && this.page.url() !== target) await this.save()
+  async ensureContext() {
     if (!this.context) {
       this.context = await this.chromium.launchPersistentContext(this.profile, { channel: 'chrome', headless: this.headless, viewport: { width: 1440, height: 900 } })
-      this.context.on('close', () => { this.context = null; this.page = null })
+      this.context.on('close', () => { this.context = null; this.page = null; this.pp = null })
     }
+    return this.context
+  }
+  async open(url) {
+    const target = url ? editorUrl(url) : this.url
+    if (this.page && !this.page.isClosed() && this.page.url() !== target) await this.save()
+    await this.ensureContext()
     if (!this.page || this.page.isClosed()) this.page = this.context.pages().find(p => p.url() === target) ?? await this.context.newPage()
     if (this.page.url() !== target) await this.page.goto(target, { waitUntil: 'domcontentloaded' })
     this.url = target
@@ -30,14 +45,7 @@ export class EditorSession {
     this.url = this.page.url()
     return this.page
   }
-  async invoke(method, args = []) {
-    return this.page.evaluate(async ({ method, args }) => {
-      const api = globalThis.keyframe
-      if (!api || !Object.prototype.hasOwnProperty.call(api, method) || typeof api[method] !== 'function') return { ok: false, error: `Unknown API method ${method}; check keyframe_methods and update the editor if needed` }
-      try { return (await api[method](...args)) ?? { ok: true } }
-      catch (e) { return { ok: false, error: String(e?.message ?? e) } }
-    }, { method, args })
-  }
+  invoke(method, args = []) { return callApi(this.page, 'keyframe', method, args) }
   async save() {
     if (!this.page || this.page.isClosed()) return
     const saved = await this.invoke('saveProject')
@@ -51,5 +59,35 @@ export class EditorSession {
     await this.page.bringToFront()
     return { ok: true, ...saved, url: this.url, visible: true, profile: this.profile, note: 'Continue editing in the opened Chrome window. This dedicated profile is separate from your usual browser. Export project JSON to transfer it.' }
   }
-  async close() { try { await this.save() } finally { await this.context?.close() } }
+
+  /* ---------- Sprite Puppeteer (same site, /sprite-puppeteer) ---------- */
+  puppeteerUrl() { return new URL('/sprite-puppeteer', this.url).href }
+  async openPuppeteer() {
+    await this.ensureContext()
+    const target = this.puppeteerUrl()
+    if (!this.pp || this.pp.isClosed()) this.pp = this.context.pages().find(p => p.url().startsWith(target)) ?? await this.context.newPage()
+    if (!this.pp.url().startsWith(target)) await this.pp.goto(target, { waitUntil: 'domcontentloaded' })
+    await this.pp.waitForFunction(() => !!globalThis.spritePuppeteer, undefined, { timeout: 60000 })
+    const status = await this.invokePuppeteer('ready')
+    if (status?.ok === false) throw new Error(status.error)
+    return this.pp
+  }
+  invokePuppeteer(method, args = []) { return callApi(this.pp, 'spritePuppeteer', method, args) }
+  /* save only when the character changed: a sample nobody touched stays a sample, as it does for people */
+  async savePuppeteer() {
+    if (!this.pp || this.pp.isClosed()) return
+    const info = await this.invokePuppeteer('sessionInfo')
+    if (!info?.dirty) return info
+    const saved = await this.invokePuppeteer('saveProject')
+    if (saved?.ok === false) throw new Error(saved.error)
+    return saved
+  }
+  async puppeteerHandoff() {
+    await this.openPuppeteer()
+    const saved = await this.savePuppeteer()
+    if (this.headless) { await this.context.close(); this.headless = false; await this.openPuppeteer() }
+    await this.pp.bringToFront()
+    return { ok: true, ...saved, url: this.pp.url(), visible: true, profile: this.profile, note: 'Sprite Puppeteer is open in the connector\'s Chrome window. Its projects live in this dedicated profile; use puppeteer_export {format:"project"} to move a character to your usual browser.' }
+  }
+  async close() { try { await this.save(); await this.savePuppeteer() } finally { await this.context?.close() } }
 }

package/tools.mjs

@@ -42,4 +42,36 @@ export const definitions = [
   tool('keyframe_edit_image_layers', 'Atomically add text or embedded image layers, edit properties/text, reorder or delete layers. Updates composite and editable layers. Close the human image editor first.', object({ asset: str, operations: { type: 'array', minItems: 1, maxItems: 100, items: layerChange }, expected }, ['asset', 'operations']), 'editImageLayers', a => [a.asset, a.operations, a.expected]),
   tool('keyframe_open_result', 'Save the project and show it in visible Chrome with the connector profile. Export project JSON to transfer to your usual browser.'),
 ]
-export const advertisedTools = definitions.map(({ method, args, ...definition }) => definition)
+/* ---------- Sprite Puppeteer (www.keyframe.it.com/sprite-puppeteer): pixel-art sprites, rigged or sprite-sheet ---------- */
+const pp = (name, description, inputSchema = object(), method, args = () => []) => ({ ...tool(name, description, inputSchema, method, args), target: 'puppeteer' })
+const dir8 = { enum: ['N', 'NE', 'E', 'SE', 'S', 'SW', 'W', 'NW'] }
+const ppKey = object({ t: number(0, 6), ease: { enum: ['io', 'out', 'in', 'lin', 'snap', 'back', 'hold'] }, pose: { type: 'object', additionalProperties: { type: 'number' } } }, ['t'])
+const ppEvent = object({ t: number(0, 6), type: { enum: ['impact', 'slam', 'cast', 'step', 'launch', 'land', 'cheer'] }, at: str }, ['t', 'type'])
+const ppSettings = { ...object({
+  bg: { enum: ['crypt', 'checker', 'plain', 'green'] }, fps: integer(1, 60), scale: integer(1, 8), speed: number(0.25, 2), intensity: number(0.4, 1.6), glow: number(0, 1.5),
+  hitStop: number(0, 0.16), overshoot: number(0, 1), follow: number(0, 1), fx: bool, smear: bool, stepped: bool, bones: bool, exportFx: bool, dummy: bool,
+  format: { enum: ['sheet', 'godot', 'unity', 'gm', 'frames', 'spine'] }, which: { enum: ['one', 'all'] }, dirs: { enum: ['view', '4', '8'] },
+  outline: { enum: ['off', 'repair', 'add'] }, rotsprite: { enum: ['auto', 'on', 'off'] }, facing: { enum: [1, -1] },
+}), minProperties: 1 }
+definitions.push(
+  pp('puppeteer_open', 'Open Sprite Puppeteer (pixel-art sprite rigging, animation and play-testing) in the connector profile; optionally load a sample: "orc" (sprite sheets: side, isometric, top-down) or "golem" (rigged). Returns the character state. Call first.', object({ sample: { enum: ['orc', 'golem'] } })),
+  pp('puppeteer_methods', 'List every Sprite Puppeteer scripting method with arguments, plus recipes. Reach methods without a named tool through puppeteer_call.', object(), 'help'),
+  pp('puppeteer_call', 'Call any window.spritePuppeteer method with positional arguments. Read puppeteer_methods first. Image results appear inline; exports become files.', object({ method: str, args: { type: 'array' } }, ['method'])),
+  pp('puppeteer_state', 'Current character: kind (rigged or sprite-sheet), moves, camera set and direction or views, settings, project.', object(), 'getState'),
+  pp('puppeteer_play_move', 'Show a move on the stage, optionally from a time or paused.', object({ move: str, time: number(0, 60), play: bool }, ['move']), 'playMove', a => [a.move, { time: a.time, play: a.play }]),
+  pp('puppeteer_set_view', 'Sprite sheets: camera set (side, iso8, topdown8, topdown4…) and direction (S = facing down). Rigged: drawn view (side, front, back, fq, bq). Both: facing 1 (right) or -1 (left).', { ...object({ set: str, dir: dir8, view: str, facing: { enum: [1, -1] } }), minProperties: 1 }, 'setView', a => [a]),
+  pp('puppeteer_settings', 'Change settings through the panel: background (checker is transparent in exports), fps, pixel scale, speed, exaggeration, effects, export format, one/all moves, 4/8 directions.', ppSettings, 'setSettings', a => [a]),
+  pp('puppeteer_move_guide', 'Rigged characters: pose channels with units, ranges and rest values, animation conventions, eases, events and the JSON shape for puppeteer_create_move. Read before creating a move.', object(), 'moveGuide'),
+  pp('puppeteer_create_move', 'Rigged characters: add a keyframed move. keys list only channels that differ from rest; a loop flows back to its first key. replace: an existing custom move id to overwrite (keeps its id and hotkey).', object({
+    spec: object({ name: str, dur: number(0.2, 6), loop: bool, keys: { type: 'array', minItems: 1, maxItems: 64, items: ppKey }, events: { type: 'array', maxItems: 32, items: ppEvent } }, ['dur', 'keys']), replace: str }, ['spec']), 'createMove', a => [a.spec, { replace: a.replace }]),
+  pp('puppeteer_contact_sheet', 'A labelled grid of a move\'s frames (cells about 220 px): the way to judge a move. Defaults to the current move.', object({ move: str, samples: integer(1, 36), scale: number(0.1, 6), columns: integer(1, 12) }), 'renderContactSheet', a => [a]),
+  pp('puppeteer_render_frame', 'One frame of a move as a PNG, transparent unless background:true.', object({ move: str, frame: integer(0, 9999), time: number(0, 60), scale: integer(1, 8), background: bool }), 'renderFrame', a => [a]),
+  pp('puppeteer_load_image', 'Load a sprite from the local disk as a new rigged character (PNG, GIF, WebP, JPEG, .aseprite/.ase or .psd; layers keep their names). The skeleton auto-fits; check with puppeteer_contact_sheet.', object({ path: str, name: str }, ['path']), 'loadImage'),
+  pp('puppeteer_export', 'Write an export to disk: sheet (PNG + Aseprite-style JSON), godot, unity, gm (GameMaker), frames (PNG zip), spine (rigged only), gif (one move) or project (.puppet.json). moves: current or all; dirs: view, 4 or 8.', object({ format: { enum: ['sheet', 'godot', 'unity', 'gm', 'frames', 'spine', 'gif', 'project'] }, move: str, moves: { enum: ['current', 'all'] }, dirs: { enum: ['view', '4', '8'] } }, ['format']), 'exportFile', a => [a]),
+  pp('puppeteer_list_projects', 'List Sprite Puppeteer projects saved in this connector profile.', object(), 'listProjects'),
+  pp('puppeteer_open_project', 'Open a saved Sprite Puppeteer project by ID.', object({ projectId: str }, ['projectId']), 'openProject', a => [a.projectId]),
+  pp('puppeteer_save', 'Save the current character as a project, optionally naming it.', object({ name: str }), 'saveProject', a => [{ name: a.name }]),
+  pp('puppeteer_screenshot', 'Show the Sprite Puppeteer page. Prefer puppeteer_contact_sheet to judge motion.'),
+  pp('puppeteer_open_result', 'Save and show Sprite Puppeteer in visible Chrome with the connector profile, so the user can keep working.'),
+)
+export const advertisedTools = definitions.map(({ method, args, target, ...definition }) => definition)