logopacker-canvas.vooncj.workers.dev

{
  "name": "inspect_canvas",
  "kind": "answer",
  "impl": "imperative",
  "description": "Returns an overview of the whole canvas: all artboards (id, name, size, position, object count) and total object count. Use this first to understand what exists.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "inspect_artboard",
  "kind": "answer",
  "impl": "imperative",
  "description": "Returns details of a single artboard and the objects it contains (compact views).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artboardId": {
        "type": "string",
        "description": "The artboard id."
      }
    },
    "required": [
      "artboardId"
    ]
  }
}

{
  "name": "list_objects",
  "kind": "answer",
  "impl": "imperative",
  "description": "Lists objects on the canvas as compact views. Optionally filter by artboardId, semanticRole, or type.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artboardId": {
        "type": "string"
      },
      "role": {
        "type": "string",
        "description": "Semantic role, e.g. logoSymbol or wordmark."
      },
      "type": {
        "type": "string",
        "enum": [
          "path",
          "text",
          "image"
        ]
      }
    }
  }
}

{
  "name": "get_object",
  "kind": "answer",
  "impl": "imperative",
  "description": "Returns the full compact view of a single object by id, including path data (d) for path objects.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "inspect_path",
  "kind": "answer",
  "impl": "imperative",
  "description": "Returns the vector path details of a path object: raw path data (d), fill, stroke, strokeWidth, opacity, semanticRole, and position.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "get_selection",
  "kind": "answer",
  "impl": "imperative",
  "description": "Returns what the human currently has selected on the canvas: the selected object ids and their compact views, or the selected artboard (object and artboard selection are mutually exclusive). Use this to resolve references like \"this\", \"the selected shape\", or \"make it blue\" to concrete object ids.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "select_objects",
  "kind": "act",
  "impl": "imperative",
  "description": "Selects objects on the canvas so the human can see what the agent is working on. Provide ids or a semanticRole.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "role": {
        "type": "string"
      }
    }
  }
}

{
  "name": "create_artboard",
  "kind": "act",
  "impl": "imperative",
  "description": "Creates a new artboard, auto-placed neatly to the right of existing artboards unless x/y are given. Returns the new artboard.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "name": {
        "type": "string"
      },
      "width": {
        "type": "number"
      },
      "height": {
        "type": "number"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      },
      "backgroundColor": {
        "type": "string"
      }
    }
  }
}

{
  "name": "fit_artboard_to_artwork",
  "kind": "act",
  "impl": "imperative",
  "description": "Resizes and repositions an artboard so it tightly wraps the artwork it contains (its objects). Objects stay visually in place. Optionally add uniform padding (canvas units) around the artwork. No-op for an empty artboard.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artboardId": {
        "type": "string",
        "description": "The artboard to fit."
      },
      "padding": {
        "type": "number",
        "description": "Optional uniform margin around the artwork, in canvas units. Defaults to 0 (tight crop)."
      }
    },
    "required": [
      "artboardId"
    ]
  }
}

{
  "name": "duplicate_object",
  "kind": "act",
  "impl": "imperative",
  "description": "Duplicates an object (optionally into a target artboard) with an offset. Returns the new object id.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "artboardId": {
        "type": "string",
        "description": "Optional target artboard for the copy."
      },
      "offsetX": {
        "type": "number"
      },
      "offsetY": {
        "type": "number"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "delete_object",
  "kind": "transact",
  "impl": "imperative",
  "description": "Deletes an object by id.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "move_object",
  "kind": "act",
  "impl": "imperative",
  "description": "Moves an object to a new local position (x, y) within its artboard, or by a relative delta (dx, dy).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      },
      "dx": {
        "type": "number"
      },
      "dy": {
        "type": "number"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "reparent_object",
  "kind": "act",
  "impl": "imperative",
  "description": "Moves an object into a different artboard while keeping it visually in place on the canvas (its local x/y are rebased to the new artboard). Pass artboardId=null to detach the object to the canvas. No-op if it already belongs to the target.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "artboardId": {
        "type": [
          "string",
          "null"
        ],
        "description": "Target artboard id, or null to detach the object from any artboard."
      }
    },
    "required": [
      "id",
      "artboardId"
    ]
  }
}

{
  "name": "set_fill",
  "kind": "act",
  "impl": "imperative",
  "description": "Sets the fill color of one or more objects. Target by ids or by semanticRole (e.g. role=\"logoSymbol\").",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "role": {
        "type": "string"
      },
      "fill": {
        "type": "string",
        "description": "CSS color, e.g. #000000, rgba(0, 0, 0, 0.5) for a translucent fill, or none."
      }
    },
    "required": [
      "fill"
    ]
  }
}

{
  "name": "get_object_properties",
  "kind": "answer",
  "impl": "imperative",
  "description": "Returns the current values of every editable property for an object, plus the list of property names you may set for that object type. Call this before set_object_properties so you know which keys are valid. Common (all types): x, y, width, height, rotation, opacity, semanticRole, artboardId. path: d, fill, stroke, strokeWidth, strokeLinecap (butt|round|square), strokeLinejoin (miter|round|bevel), cornerRadius (rectangles only). text: text, fontFamily, fontSize, fontWeight, fill, align, tracking (letter spacing, 1/1000 em). image: href, sourceUrl, alt.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "set_object_properties",
  "kind": "act",
  "impl": "imperative",
  "description": "Sets any editable properties on one or more objects, targeted by ids or semanticRole. Pass a `properties` object with the keys to change; only keys valid for each object type are applied (unknown/invalid keys are ignored). Use get_object_properties first to see which keys are valid. Common (all types): x, y, width, height, rotation, opacity, semanticRole, artboardId. path: d, fill, stroke, strokeWidth, strokeLinecap (butt|round|square), strokeLinejoin (miter|round|bevel), cornerRadius (rectangles only, regenerates the path). text: text, fontFamily, fontSize, fontWeight, fill, align, tracking (letter spacing, 1/1000 em). image: href, sourceUrl, alt.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "role": {
        "type": "string",
        "description": "Semantic role, e.g. logoSymbol."
      },
      "properties": {
        "type": "object",
        "description": "Property key/value pairs to set. Keys are validated per object type."
      }
    },
    "required": [
      "properties"
    ]
  }
}

{
  "name": "set_path_data",
  "kind": "act",
  "impl": "imperative",
  "description": "Replaces the vector path data (d attribute) of a path object. Use inspect_path first to read the current d.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "d": {
        "type": "string",
        "description": "New SVG path data."
      }
    },
    "required": [
      "id",
      "d"
    ]
  }
}

{
  "name": "draw_svg",
  "kind": "act",
  "impl": "imperative",
  "description": "Draws new shapes by providing SVG markup. Pass either a full <svg>…</svg> document or a fragment of one or more <path> elements. Each <path> becomes a native, node-editable path object on the target artboard (fully editable afterwards by the other tools). Coordinates come from the SVG (its viewBox, or the path data if no viewBox). Use `x`/`y` to place the top-left of the artwork in artboard-local coordinates, and `scale` to resize uniformly. Only <path> geometry is converted — <rect>, <circle>, <text>, gradients and CSS-class styling are NOT supported; convert shapes to paths first. Fill/stroke are read from each path’s own attributes. Returns the created object ids.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "svg": {
        "type": "string",
        "description": "SVG markup: a full <svg> document or one or more <path> elements."
      },
      "artboardId": {
        "type": "string",
        "description": "Target artboard. Defaults to the first artboard."
      },
      "x": {
        "type": "number",
        "description": "Left position of the artwork, local to the artboard (default 0)."
      },
      "y": {
        "type": "number",
        "description": "Top position of the artwork, local to the artboard (default 0)."
      },
      "scale": {
        "type": "number",
        "description": "Uniform scale factor applied to the SVG coordinates (default 1)."
      },
      "semanticRole": {
        "type": "string",
        "description": "Semantic role for the created paths (default decorative)."
      }
    },
    "required": [
      "svg"
    ]
  }
}

{
  "name": "begin_agent_request",
  "kind": "act",
  "impl": "imperative",
  "description": "Call this FIRST at the start of a multi-step task. It snapshots the canvas so the entire request can be reverted with a single \"Undo Agent Changes\", and opens an activity group for progress. Pass a short title.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "title": {
        "type": "string",
        "description": "Short title of the request."
      }
    }
  }
}

{
  "name": "end_agent_request",
  "kind": "act",
  "impl": "imperative",
  "description": "Call this LAST when a multi-step task is complete. Marks the activity group done. Optionally arranges all artboards into a tidy grid.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "arrange": {
        "type": "boolean"
      },
      "columns": {
        "type": "number"
      }
    }
  }
}

{
  "name": "center_object",
  "kind": "act",
  "impl": "imperative",
  "description": "Centers an object horizontally and/or vertically within its artboard. Provide objWidth/objHeight for paths if known.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "horizontal": {
        "type": "boolean"
      },
      "vertical": {
        "type": "boolean"
      },
      "objWidth": {
        "type": "number"
      },
      "objHeight": {
        "type": "number"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "arrange_artboards",
  "kind": "act",
  "impl": "imperative",
  "description": "Arranges all artboards into a tidy grid for a clean presentation.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "columns": {
        "type": "number"
      },
      "gap": {
        "type": "number"
      }
    }
  }
}

{
  "name": "zoom_to_artboard",
  "kind": "act",
  "impl": "imperative",
  "description": "Zooms and pans the canvas viewport to frame a single artboard so it fills the view. Use this to focus on the artboard you are working on so the human can see it. Optionally add padding (a fraction of the artboard size, e.g. 0.1 for 10% margin on each side). Does nothing in headless environments without a live canvas.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artboardId": {
        "type": "string"
      },
      "padding": {
        "type": "number",
        "description": "Margin around the artboard as a fraction of its larger side (default 0.1)."
      }
    },
    "required": [
      "artboardId"
    ]
  }
}

{
  "name": "add_text",
  "kind": "act",
  "impl": "imperative",
  "description": "Adds a text object to an artboard. Provide the text content, target artboardId, position (x,y local to the artboard), and optional typography + semanticRole (e.g. headline, bodyText, wordmark).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "text": {
        "type": "string"
      },
      "artboardId": {
        "type": "string"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      },
      "fontFamily": {
        "type": "string"
      },
      "fontSize": {
        "type": "number"
      },
      "fontWeight": {
        "type": "number"
      },
      "fill": {
        "type": "string"
      },
      "align": {
        "type": "string",
        "enum": [
          "left",
          "center",
          "right"
        ]
      },
      "semanticRole": {
        "type": "string"
      }
    },
    "required": [
      "text"
    ]
  }
}

{
  "name": "search_pexels",
  "kind": "answer",
  "impl": "imperative",
  "description": "Searches Pexels for photos matching a natural-language description. Returns an array of results (id, alt, thumb, src, width, height). Review the results, choose one, then call add_image.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Natural-language image description."
      },
      "perPage": {
        "type": "number",
        "description": "How many results (1-24)."
      },
      "orientation": {
        "type": "string",
        "enum": [
          "landscape",
          "portrait",
          "square"
        ]
      }
    },
    "required": [
      "query"
    ]
  }
}

{
  "name": "add_image",
  "kind": "act",
  "impl": "imperative",
  "description": "Adds an image to an artboard. Provide a Pexels result (src/href, alt, width/height from search_pexels) plus the target artboardId and optional position/size. Returns the new image object id.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artboardId": {
        "type": "string"
      },
      "src": {
        "type": "string",
        "description": "Image URL (use the src from search_pexels)."
      },
      "href": {
        "type": "string"
      },
      "alt": {
        "type": "string"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      },
      "width": {
        "type": "number"
      },
      "height": {
        "type": "number"
      },
      "semanticRole": {
        "type": "string"
      }
    }
  }
}

{
  "name": "list_local_fonts",
  "kind": "answer",
  "impl": "imperative",
  "description": "Lists fonts actually installed on the user’s machine (via the browser Local Font Access API),Returns an array of { family, fullName, postscriptName, style }. Optionally filter with `query` (case-insensitive substring match on family/fullName) and cap the count with `limit`. ",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string",
        "description": "Case-insensitive substring to filter font family/name."
      },
      "limit": {
        "type": "number",
        "description": "Maximum number of fonts to return (default 50)."
      }
    }
  }
}

{
  "name": "read_assets",
  "kind": "act",
  "impl": "imperative",
  "description": "Opens a file picker (works in every browser) for the user to choose one or more image/SVG files, then adds each as an image object on an artboard. Use this to bring the user’s own logos/photos onto the canvas. Provide the target artboardId and optional position/size for the first image. Returns the created object ids.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "artboardId": {
        "type": "string"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      },
      "width": {
        "type": "number"
      },
      "height": {
        "type": "number"
      }
    }
  }
}

{
  "name": "save_export",
  "kind": "act",
  "impl": "imperative",
  "description": "Exports the canvas and downloads it as a file (works in every browser; the file goes to the browser’s downloads). scope: \"selection\" | \"artboard\" (needs artboardId) | \"all\". format: \"svg\" | \"png\". Optional: scale (PNG, default 1), transparent (default false), filename (defaults to a timestamped name). Returns { filename, failed }.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "scope": {
        "type": "string",
        "enum": [
          "selection",
          "artboard",
          "all"
        ]
      },
      "artboardId": {
        "type": "string"
      },
      "format": {
        "type": "string",
        "enum": [
          "svg",
          "png"
        ]
      },
      "scale": {
        "type": "number"
      },
      "transparent": {
        "type": "boolean"
      },
      "filename": {
        "type": "string"
      }
    },
    "required": [
      "scope",
      "format"
    ]
  }
}

{
  "name": "autosave",
  "kind": "act",
  "impl": "imperative",
  "description": "Saves the whole canvas as a portable .json document (the same Save the toolbar uses) and downloads it. This is the reloadable source document — all artboards, objects and layout — not a rendered image. Use save_export for SVG/PNG output. Returns { filename }.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "filename": {
        "type": "string",
        "description": "Optional .json filename."
      }
    }
  }
}

{
  "name": "set_view_mode",
  "kind": "act",
  "impl": "imperative",
  "description": "Switches the canvas between \"preview\" (normal rendering) and \"outline\" (every object as a thin unfilled wireframe, to inspect construction and overlaps).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "mode": {
        "type": "string",
        "enum": [
          "preview",
          "outline"
        ]
      }
    },
    "required": [
      "mode"
    ]
  }
}

{
  "name": "list_layers",
  "kind": "answer",
  "impl": "imperative",
  "description": "Lists the document layers (top first, with the active one marked), the groups, and every object front-to-back with its layer, group, name, type, artboard, hidden, locked and opacity.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "manage_layer",
  "kind": "act",
  "impl": "imperative",
  "description": "Document layers (Illustrator-style containers for artwork). action: add (new layer above the active one, becomes active), activate (new objects go into it), rename, hide/show, lock/unlock, move (to stack index, 0 = bottom), delete (removes the layer and its objects; the last layer stays), or move_objects (put objectIds into the layer).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "add",
          "activate",
          "rename",
          "hide",
          "show",
          "lock",
          "unlock",
          "move",
          "delete",
          "move_objects"
        ]
      },
      "layerId": {
        "type": "string",
        "description": "Target layer (not needed for add)."
      },
      "name": {
        "type": "string"
      },
      "index": {
        "type": "number"
      },
      "objectIds": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "action"
    ]
  }
}

{
  "name": "group_objects",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Group: groups objects so they select, move and transform together (members move next to the frontmost one and into its layer). Existing groups among them nest inside the new group. With ungroup: true, releases the outermost groups of the given objects instead.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "name": {
        "type": "string"
      },
      "ungroup": {
        "type": "boolean"
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "update_layer",
  "kind": "act",
  "impl": "imperative",
  "description": "Updates the layers-panel state of one object: rename, hide/show, lock/unlock, and/or move in paint order within its layer (exact index, 0 = backmost, or a step: forward/backward/front/back). Use manage_layer for document layers.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "name": {
        "type": "string",
        "description": "Empty string clears a custom name."
      },
      "hidden": {
        "type": "boolean"
      },
      "locked": {
        "type": "boolean"
      },
      "index": {
        "type": "number"
      },
      "move": {
        "type": "string",
        "enum": [
          "forward",
          "backward",
          "front",
          "back"
        ]
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "pathfinder",
  "kind": "act",
  "impl": "imperative",
  "description": "Combines 2+ path objects into one. unite = merge all (front style); minusFront = backmost minus everything in front (back style); intersect = only the area all share; exclude = areas covered an odd number of times. Replaces the sources.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "op": {
        "type": "string",
        "enum": [
          "unite",
          "minusFront",
          "intersect",
          "exclude"
        ]
      }
    },
    "required": [
      "ids",
      "op"
    ]
  }
}

{
  "name": "shape_builder_regions",
  "kind": "act",
  "impl": "imperative",
  "description": "Shape Builder step 1: splits the overlapping path objects into their distinct regions. Returns each region index with its canvas-space bounds, area and owning (frontmost covering) object. Use with shape_builder_apply.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "shape_builder_apply",
  "kind": "act",
  "impl": "imperative",
  "description": "Shape Builder step 2: merges the given region indices (from shape_builder_regions, same ids) into one shape, or deletes them with erase=true. Untouched regions become separate shapes; the source objects are replaced.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "regions": {
        "type": "array",
        "items": {
          "type": "number"
        }
      },
      "erase": {
        "type": "boolean"
      }
    },
    "required": [
      "ids",
      "regions"
    ]
  }
}

{
  "name": "set_gradient_fill",
  "kind": "act",
  "impl": "imperative",
  "description": "Gives paths/text a linear or radial gradient fill (replacing the solid fill), or removes it with clear=true. Stops are {offset 0-1, color (hex or rgba)}. Linear direction via angle in degrees (0 = left→right, 90 = top→bottom) or explicit x1,y1,x2,y2 in 0-1 bounding-box fractions; radial is centered on x1,y1 with radius to x2,y2.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "type": {
        "type": "string",
        "enum": [
          "linear",
          "radial"
        ]
      },
      "stops": {
        "type": "array",
        "items": {
          "type": "object",
          "properties": {
            "offset": {
              "type": "number"
            },
            "color": {
              "type": "string"
            }
          },
          "required": [
            "offset",
            "color"
          ]
        }
      },
      "angle": {
        "type": "number"
      },
      "x1": {
        "type": "number"
      },
      "y1": {
        "type": "number"
      },
      "x2": {
        "type": "number"
      },
      "y2": {
        "type": "number"
      },
      "clear": {
        "type": "boolean"
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "vectorize_image",
  "kind": "act",
  "impl": "imperative",
  "description": "Image Trace: converts an image object into editable vector paths laid over it (the image is hidden, not deleted). Fewer colors give a flatter, logo-like result.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "colors": {
        "type": "number",
        "description": "Palette size 2-16 (default 4)."
      },
      "detail": {
        "type": "number",
        "description": "0 smooth .. 1 detailed (default 0.5)."
      },
      "removeWhite": {
        "type": "boolean",
        "description": "Drop near-white background shapes (default true)."
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "capture_sketch_from_phone",
  "kind": "act",
  "impl": "imperative",
  "description": "Opens the phone capture dialog (QR code) so the designer can photograph a paper sketch with their phone. The designer finishes cleanup and placement in the dialog; nothing is returned to the agent.",
  "inputSchema": {
    "type": "object",
    "properties": {}
  }
}

{
  "name": "clean_up_sketch",
  "kind": "act",
  "impl": "imperative",
  "description": "Cleans a photographed sketch already on the canvas (an image object): straightens the paper (auto-detected), removes shadows/glare, smooths paper texture, optionally drops colored lines and screen moiré, then binarizes to black on white. Places the result over the original (which is hidden), traced to vector paths when vectorize=true.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string",
        "description": "Image object id."
      },
      "vectorize": {
        "type": "boolean",
        "description": "Trace into black vector paths (default true)."
      },
      "straighten": {
        "type": "boolean",
        "description": "Auto-detect and straighten the paper (default true)."
      },
      "colorFilter": {
        "type": "string",
        "enum": [
          "none",
          "darkInk",
          "removeBlue",
          "removeRed"
        ]
      },
      "moire": {
        "type": "boolean"
      },
      "removeShadows": {
        "type": "boolean"
      },
      "smoothing": {
        "type": "number",
        "description": "0-1"
      },
      "sensitivity": {
        "type": "number",
        "description": "0-1, higher keeps fainter strokes"
      },
      "despeckle": {
        "type": "number",
        "description": "0-1"
      },
      "strokeAdjust": {
        "type": "number",
        "description": "-2..2 thin/thicken strokes"
      }
    },
    "required": [
      "id"
    ]
  }
}

{
  "name": "create_outlines",
  "kind": "act",
  "impl": "imperative",
  "description": "Converts text objects into vector paths (Type > Create Outlines): one compound path per text object, keeping its fill, so the wordmark no longer depends on the font and its letters can be reshaped. Needs the font file: bundled Inter always works; other fonts need installed-font access or an added font file.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "reflect_objects",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Transform > Reflect: mirrors objects horizontally (left-right) or vertically (top-bottom) across the center of their combined bounds. Paths have their geometry mirrored; text and images are flipped.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "axis": {
        "type": "string",
        "enum": [
          "horizontal",
          "vertical"
        ]
      }
    },
    "required": [
      "ids",
      "axis"
    ]
  }
}

{
  "name": "join_paths",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Path > Join: joins two open paths at their nearest endpoints into one path (endpoints that nearly touch merge into one anchor; otherwise a straight segment bridges them), or closes a single open path. The result takes the front path's style.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "One or two open path ids."
      },
      "tolerance": {
        "type": "number",
        "description": "Merge distance in canvas units (default: 8 screen pixels)."
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "repeat_objects",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Repeat, live: \"radial\" turns copies around a center (the art's top points outward), \"grid\" lays out columns × rows, \"mirror\" adds a left–right reflection. The selection becomes a symbol, so editing any copy edits all of them. action \"make\" (ids, kind) creates one; \"set\" (repeatId plus options) changes it — radial: count, radius; grid: cols, rows, gapX, gapY; mirror: gap (lengths in the art's own units); \"release\" turns the copies into plain groups. Returns the repeat group id and its options.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "make",
          "set",
          "release"
        ]
      },
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "kind": {
        "type": "string",
        "enum": [
          "radial",
          "grid",
          "mirror"
        ]
      },
      "repeatId": {
        "type": "string"
      },
      "count": {
        "type": "number"
      },
      "radius": {
        "type": "number"
      },
      "cols": {
        "type": "number"
      },
      "rows": {
        "type": "number"
      },
      "gapX": {
        "type": "number"
      },
      "gapY": {
        "type": "number"
      },
      "gap": {
        "type": "number"
      }
    },
    "required": [
      "action"
    ]
  }
}

{
  "name": "offset_path",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Path > Offset Path: adds a path offset from each given path — positive grows outward (placed behind the original: outlines, badge rings), negative insets (placed in front: inlines). Open paths offset to the outline around them. joins: miter (default), round or bevel. One undo step. Returns the new ids.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "offset": {
        "type": "number",
        "description": "Canvas units; negative = inside."
      },
      "joins": {
        "type": "string",
        "enum": [
          "miter",
          "round",
          "bevel"
        ]
      }
    },
    "required": [
      "ids",
      "offset"
    ]
  }
}

{
  "name": "transform_again",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Transform > Transform Again (Cmd/Ctrl+D): repeats the last move, rotation, scale or reflection on the selection — on a copy when the last one made a copy. With nothing to repeat it duplicates the selection 20 units down-right. Optionally first set what to repeat: move (dx, dy), rotate (deg), scale (fx, fy), with copy.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "set": {
        "type": "string",
        "enum": [
          "move",
          "rotate",
          "scale"
        ]
      },
      "dx": {
        "type": "number"
      },
      "dy": {
        "type": "number"
      },
      "deg": {
        "type": "number"
      },
      "fx": {
        "type": "number"
      },
      "fy": {
        "type": "number"
      },
      "copy": {
        "type": "boolean"
      },
      "times": {
        "type": "number",
        "description": "How many times to repeat (default 1, max 100)."
      }
    }
  }
}

{
  "name": "mockup_studio",
  "kind": "act",
  "impl": "imperative",
  "description": "Window > Mockup Studio: photo mockups (business card, card in hand, ID badge, three t-shirts, tote, laptop and phone screens, plus the person's own photos saved in this browser under \"My photos\") with the logo printed in perspective, shaded by the photo, product recolor, full-resolution PNG export and placing on the canvas. action \"list\" lists the templates; \"open\" opens the studio on templateId for the person to place, style and download.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "list",
          "open"
        ]
      },
      "templateId": {
        "type": "string"
      }
    },
    "required": [
      "action"
    ]
  }
}

{
  "name": "make_logo_set",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Make Logo Set: splits the logo (ids, or the selection) into its mark and wordmark, makes each a symbol, and lays out four lockups on new artboards — Horizontal, Stacked, Icon and Wordmark — built from symbol instances, so editing the mark or wordmark anywhere updates every lockup. The split: with two groups/objects the squarer one is the mark; live text beside other art is the wordmark; otherwise the widest gap. Returns the symbol ids and the artboard id of each lockup.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    }
  }
}

{
  "name": "manage_symbol",
  "kind": "act",
  "impl": "imperative",
  "description": "Symbols: artwork used in many places that stays in sync (an instance is a group; editing any member of any instance updates every instance, while moving/scaling/rotating an instance as a whole is just its placement). Actions: \"make\" turns ids into a symbol (they stay as its first instance); \"place\" adds an instance of symbolId with its top-left at canvas x,y (optional scale, artboardId); \"break\" turns instance groups (groupIds) into plain groups; \"rename\" renames symbolId to name; \"delete\" removes symbolId (instances become plain groups); \"list\" lists symbols with their instance group ids.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "make",
          "place",
          "break",
          "rename",
          "delete",
          "list"
        ]
      },
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "symbolId": {
        "type": "string"
      },
      "groupIds": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "name": {
        "type": "string"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      },
      "scale": {
        "type": "number"
      },
      "artboardId": {
        "type": "string"
      }
    },
    "required": [
      "action"
    ]
  }
}

{
  "name": "check_logo",
  "kind": "answer",
  "impl": "imperative",
  "description": "Window > Logo Check: tests the logo (ids, or the selection / whole document when omitted) the way it will be used — rasterized at 16–128 px to find thin parts that disappear and gaps that close up (returns the smallest size where every detail holds), and checks its colors: contrast with the background (under 3:1), colors that merge in grayscale, color count, and gradients/patterns/images/transparency that one-color printing loses. Each warning lists the object ids involved.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    }
  }
}

{
  "name": "check_print_colors",
  "kind": "answer",
  "impl": "imperative",
  "description": "Logo Check > Print: how the logo's colors print in CMYK, using LogoPacker's own conversion (U.S. Web Coated SWOP, as its CMYK export). Per color: CMYK inks, the printed color, ΔE2000 and the hue/saturation shift (gamut warnings at ≥ 3 and ≥ 6), total ink over 300%, and multi-ink or rich-black color on fine detail at the smallest print width.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "minWidthMm": {
        "type": "number",
        "description": "Smallest printed width of the logo in mm (default 25)."
      }
    }
  }
}

{
  "name": "make_print_safe",
  "kind": "act",
  "impl": "imperative",
  "description": "Logo Check > Make print-safe copy: copies the logo onto a new \"Print-safe colors\" artboard with every color that prints visibly different replaced by the color it actually prints as. The original is unchanged. One undo step.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    }
  }
}

{
  "name": "simplify_paths",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Path > Simplify: refits paths with fewer anchors while keeping their shape — cleans up traced, sketched or jittery paths. Sharp corners (inner angle below cornerAngle) stay corners; everything between becomes smooth Béziers, or straight segments with straight: true. Shapes and compound paths work too (a rectangle or ellipse becomes an editable path). One undo step. Returns anchor counts before and after.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        },
        "description": "Path ids."
      },
      "amount": {
        "type": "number",
        "description": "0–1: 0 keeps the path as is, 1 removes the most anchors. Default 0.5."
      },
      "cornerAngle": {
        "type": "number",
        "description": "Corner angle threshold in degrees (0–180, default 135)."
      },
      "straight": {
        "type": "boolean",
        "description": "Straight segments only."
      },
      "auto": {
        "type": "boolean",
        "description": "Pick the amount automatically (ignores amount)."
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "suggest_fonts",
  "kind": "act",
  "impl": "imperative",
  "description": "Suggest Fonts: copies the logo (ids; groups are widened to whole groups) onto a new \"Font suggestions\" artboard several times, each with its main text set in a similar typeface — Google Fonts plus installed fonts when font access is granted — sized to the original width and captioned with the font name and licence. Needs live text. Returns the fonts chosen.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "count": {
        "type": "number",
        "description": "1–9, default 6."
      },
      "describe": {
        "type": "string",
        "description": "Optional style to steer toward, e.g. \"more geometric\", \"playful rounded\". Picks the closest fonts to the logo among those matching it."
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "search_fonts",
  "kind": "answer",
  "impl": "imperative",
  "description": "Semantic font search over Google Fonts: describe a style in words (\"geometric\", \"crooked and playful\", \"elegant serif, not script\", \"heavy condensed techno\") and get matching families with the style tags that matched. \"not/no/without X\" excludes X. Use load: true on a result family name to add it to the font menus.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "query": {
        "type": "string"
      },
      "limit": {
        "type": "number",
        "description": "Default 12, max 40."
      },
      "load": {
        "type": "string",
        "description": "A family name from the results to load into the font menus."
      }
    },
    "required": [
      "query"
    ]
  }
}

{
  "name": "make_pattern",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Pattern > Make, without the editing mode: turns objects into a pattern swatch (the objects stay as they are). tileType: grid | brickRow | brickColumn | hexColumn | hexRow; brickOffset as [numerator, denominator] (e.g. [1, 2]); the tile is the art plus hSpacing/vSpacing unless width/height are given; overlapH left|right, overlapV top|bottom. Returns the pattern id to use with apply_pattern.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "name": {
        "type": "string"
      },
      "tileType": {
        "type": "string",
        "enum": [
          "grid",
          "brickRow",
          "brickColumn",
          "hexColumn",
          "hexRow"
        ]
      },
      "brickOffset": {
        "type": "array",
        "items": {
          "type": "number"
        }
      },
      "width": {
        "type": "number"
      },
      "height": {
        "type": "number"
      },
      "hSpacing": {
        "type": "number"
      },
      "vSpacing": {
        "type": "number"
      },
      "overlapH": {
        "type": "string",
        "enum": [
          "left",
          "right"
        ]
      },
      "overlapV": {
        "type": "string",
        "enum": [
          "top",
          "bottom"
        ]
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "apply_pattern",
  "kind": "act",
  "impl": "imperative",
  "description": "Paints objects with a pattern swatch: kind fill (paths and text) or stroke (paths). patternId null removes it. Optional scale (1 = 100%), rotation (degrees) and x/y offset place the pattern inside each object. Lists swatches when called with ids [] (returns the patterns).",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "patternId": {
        "type": [
          "string",
          "null"
        ]
      },
      "kind": {
        "type": "string",
        "enum": [
          "fill",
          "stroke"
        ]
      },
      "scale": {
        "type": "number"
      },
      "rotation": {
        "type": "number"
      },
      "x": {
        "type": "number"
      },
      "y": {
        "type": "number"
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "expand_pattern",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Expand for patterns: each object's pattern fill becomes a clipping group of real copies of the tile artwork, clipped by the shape; a pattern stroke is outlined first, then expanded. Returns the new ids.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "clipping_mask",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Clipping Mask. make: the frontmost path among ids clips the rest (it loses its fill and stroke). release: the clip groups of ids become plain groups.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "action": {
        "type": "string",
        "enum": [
          "make",
          "release"
        ]
      }
    },
    "required": [
      "ids",
      "action"
    ]
  }
}

{
  "name": "opacity_mask",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Opacity Mask, a layer mask for vector art. make: the frontmost object among ids (whole groups count as one) masks the rest — mode \"luminance\" (default): white shows, black hides, grays and gradients fade; \"alpha\": the mask's own opacity decides. clip (default true) hides what is outside the mask's shape; invert swaps shown and hidden. The mask keeps its paint (that is what it reads) but is not drawn. set: change mode / clip / invert on the masked group (groupId, or any id in it). release: the mask is painted again as an ordinary object. Returns the masked group id and its mask id.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "action": {
        "type": "string",
        "enum": [
          "make",
          "set",
          "release"
        ]
      },
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      },
      "groupId": {
        "type": "string"
      },
      "mode": {
        "type": "string",
        "enum": [
          "luminance",
          "alpha"
        ]
      },
      "clip": {
        "type": "boolean"
      },
      "invert": {
        "type": "boolean"
      }
    },
    "required": [
      "action"
    ]
  }
}

{
  "name": "insert_construction_grid",
  "kind": "act",
  "impl": "imperative",
  "description": "Pastes a construction grid as stroke-only paths, grouped, in a \"Grids\" layer on top: golden = golden rectangle (1:φ) divided into squares with the golden spiral; circles = circles whose diameters step down by φ, side by side; keyline = 24-unit icon keyline grid (unit grid, diagonals, centre lines, keyline circle/square/portrait/landscape). Sized to box (canvas coordinates) if given, else to the selected objects, else to the artboard.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "kind": {
        "type": "string",
        "enum": [
          "golden",
          "circles",
          "keyline"
        ]
      },
      "box": {
        "type": "object",
        "properties": {
          "x": {
            "type": "number"
          },
          "y": {
            "type": "number"
          },
          "width": {
            "type": "number"
          },
          "height": {
            "type": "number"
          }
        }
      }
    },
    "required": [
      "kind"
    ]
  }
}

{
  "name": "expand_appearance",
  "kind": "act",
  "impl": "imperative",
  "description": "Object > Expand Appearance: converts the strokes of path objects into filled outline shapes (miter joins, butt caps, like the rendered stroke). A path with a fill keeps it and gets a separate outline object above it; a stroke-only path is replaced by its outline.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "ids": {
        "type": "array",
        "items": {
          "type": "string"
        }
      }
    },
    "required": [
      "ids"
    ]
  }
}

{
  "name": "style_letters",
  "kind": "act",
  "impl": "imperative",
  "description": "Styles individual letters of a text object: the characters [start, end) (0-based, end exclusive) get their own fill color and/or letter spacing (tracking, 1/1000 em after each letter). reset: true removes those letters' own styles instead. Use update_objects with tracking for the whole text.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "id": {
        "type": "string"
      },
      "start": {
        "type": "number"
      },
      "end": {
        "type": "number"
      },
      "fill": {
        "type": "string",
        "description": "Color as #RRGGBB or rgba()."
      },
      "tracking": {
        "type": "number"
      },
      "reset": {
        "type": "boolean"
      }
    },
    "required": [
      "id",
      "start",
      "end"
    ]
  }
}

{
  "name": "text_on_path",
  "kind": "act",
  "impl": "imperative",
  "description": "Type on a path: converts a path object into the guide of a new text object whose glyphs flow along it (e.g. curved/circular wordmarks). The path is replaced by the text.",
  "inputSchema": {
    "type": "object",
    "properties": {
      "pathId": {
        "type": "string"
      },
      "text": {
        "type": "string"
      },
      "fontSize": {
        "type": "number"
      },
      "fontFamily": {
        "type": "string"
      },
      "fontWeight": {
        "type": "number"
      },
      "fill": {
        "type": "string"
      },
      "offset": {
        "type": "number",
        "description": "Start offset along the path, percent 0-100."
      }
    },
    "required": [
      "pathId",
      "text"
    ]
  }
}