Laioutr

Read one prop value off a section or block, addressed by the same `at` + `keyPath` shape as a `studio_set_static_props` write item. Returns just the addressed value — the targeted read-before-write counterpart of `studio_get_section` (which returns the whole 5–25 KB section payload). **When to use:** Use to read the current value of a prop before overwriting it with `studio_set_static_props`. Discover the entity id via `studio_get_page_tree`. For a translatable field `value` is the `{ <lang>: value }` map — edit the entries you want and write them back through a `studio_set_static_props` write item's `values` field (a write item's single `value` field writes one value, optionally fanned across `locales`, and does NOT accept the map). For a complex primitive (link/color/media/json) `value` is the subtype-tagged object, which a `studio_set_static_props` write item's `value` accepts directly — see the "Complex prop subtypes" section of the `studio_get_data_model` tool for each shape. `value: null` means there is no stored value at `keyPath` — covering BOTH a never-set prop AND an unknown field/path (this read is storage-direct and schema-unaware, so it cannot tell the two apart; validate field names with `studio_get_component_schemas`). A field that exists but is empty returns its stored value (e.g. `""` for a freshly-created text field), NOT `null`. And `null` means "not set in storage", not "renders nothing" — an unset field still renders its field type fallback, so do not infer the rendered value from `null`. **When NOT to use:** Don't use to read a section's whole prop set — use `studio_get_section`. Don't use to enumerate structure — use `studio_get_page_tree`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","at":{"blockId":"c3e5g7j9l1n3p5r7t9v1"},"keyPath":["cta","label"]}` **Response:** `{ value }` — the prop value at `keyPath` (primitive, subtype-tagged complex object, or `{ <lang>: value }` for a translatable field), or `null` when nothing is stored at `keyPath` — which covers a never-set prop AND an unknown field/path (this read is schema-unaware); a field that exists but is empty returns its stored value (e.g. `""`), not `null`. Typically well under 1 KB. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_get_prop

Return one section's full payload — component name, studio metadata, visibility, props, slots. Resolves either a local section (on a page variant) or a global section by id. **When to use:** Use to read the current value of a prop before deciding how to mutate it with `studio_set_static_props`, or to inspect a complex-primitive prop shape before overwriting it. Discover the `sectionId` via `studio_get_page_tree` first. **When NOT to use:** Don't use to enumerate sections — use `studio_get_page_tree`. Don't use to fetch a component's schema — use `studio_get_component_schemas`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","sectionId":"b8h2k4m6p0r3t5v7c9d1"}` **Response:** `{ sectionId, componentName, studioLabel?, scope: "local"|"global", payload, …plus pageVariantId+location when scope==="local" }` — 5-25 KB depending on props. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_get_section

Return the project's color palette (flattened to a single list) and icon catalog — `{ themeId, colors, icons }`. **When to use:** Use before setting a `color` prop (use a palette entry's `id` as `token` and its `value` as the hex) or an `icon` prop (use an icon `name`). Read the field's type from `studio_get_component_schemas` to know which applies. **When NOT to use:** Don't use to discover components — use `studio_list_components`. There is no media-library discovery; a `media` prop needs a source URL you already have. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g"}` **Response:** `{ themeId, colors: Array<{ id, label?, value, hint?, group? }>, icons: Array<{ name, label? }> }` — a few KB. Requires a reachable frontend; returns `FRONTEND_UNREACHABLE` when the project frontend is down. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_get_style_tokens

List the section and block components installed in this project — a thin `{ name, kind, label, description?, purpose?, tags? }` per entry (`purpose` is the agent-facing one-liner). Pass `kind` to list only sections or only blocks. **When to use:** Use to discover valid `componentName` values before `studio_add_section` / `studio_add_block`. Component names are arbitrary per-project strings (customers install different apps) — never guess them, read them here — then fetch one component's full usage detail (prop fields, slots, `ai` usage fields, `belongsIn`) with `studio_get_component_schemas`. **When NOT to use:** Don't use to read a component's prop fields, slots, or usage guidance — use `studio_get_component_schemas`. Don't use to list reusable global sections — use `studio_list_global_sections`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g"}` **Response:** `{ projectId, catalogVersion, components: Array<{ name, kind: "section"|"block", label, description?, purpose?, tags? }> }` — a few KB. `catalogVersion` is the catalog fingerprint (also surfaced in mutation error `detail.catalogVersion`) — re-list when it changes. Requires a reachable frontend; returns `FRONTEND_UNREACHABLE` when the project frontend is down. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_list_components

List the project's reusable global sections — `{ globalSectionId, componentName, studioLabel?, usageCount }` per entry, ids only, no block contents. **When to use:** Use to discover which global sections exist before placing one with `studio_add_global_section_reference`, then read a global's blocks via `studio_get_section` with its `globalSectionId`. Served straight from Storage — works even when the frontend is unreachable. **When NOT to use:** Don't use to read a global section's blocks — use `studio_get_section`. Don't use to list a project's installed component types — use `studio_list_components`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g"}` **Response:** `{ projectId, globalSections: Array<{ globalSectionId, componentName, studioLabel?, usageCount }> }` — ~1–2 KB. `usageCount` is how many page-variant references point at the global. An empty project returns `globalSections: []`, never an error. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_list_global_sections

List every page in the project with id, type, path, and each variant's `{ id, label }` — no section tree, no props. **When to use:** Use first to inventory pages and grab the `pageVariantId` you need to pass to `studio_get_page_tree` and any page-targeted mutation. **When NOT to use:** Don't use to read a page's structure — use `studio_get_page_tree`. Don't use to read a single section's props — use `studio_get_section`. Page and variant creation are not supported via this server — ask the human to create the page in Studio, then add sections/blocks to it with `studio_add_section`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g"}` **Response:** `{ projectId, pageCount, pages: PageSummary[] }` where `PageSummary = { id, type, path, variantCount, variants: { id, label }[] }` — usually under 2 KB. Each `PageSummary.type` is a stable token defined by the customer's frontend (typical values: `home`, `category`, `product`, `static`). Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_list_pages

List every Laioutr project the signed-in user has access to, across all organizations. Each row carries `mcpEnabled` — when `false`, project-scoped tools will reject calls with `MCP_NOT_ENABLED`. **When to use:** Use first, to find a `projectId` for any other tool. Cheap; no pagination. Re-call only if the human mentions a project that is not in the previous response. **When NOT to use:** Don't use to read a specific project's structure — once you have a `projectId`, switch to `studio_list_pages` / `studio_get_page_tree`. Don't use to enumerate organizations — this tool returns the org context per project already. **Example call:** `{}` **Response:** `{ projectCount, projects: Array<{ id, name, slug, organizationId, organizationName, organizationSlug, mcpEnabled, locales: Array<{ code, name, fallbacks }> }> }` — `locales` are the project's configured languages (the allowed values for `studio_set_static_props.writes[].locales`). Usually well under 5 KB.

project_list

Relocate a block to a LOCAL section's slot, or reorder it within its current slot — preserving the block id and all its props (unlike delete + re-add, which loses both). The destination block component must be allowed in the target slot — verify with `studio_get_component_schemas` for the target section. **When to use:** Use to reposition an existing block: move a CTA into a different section, or change a block's order within a slot (same `to.sectionId` + `to.slot`, different `to.atIndex`). Discover the `blockId` and target `sectionId`/slot with `studio_get_page_tree` / `studio_get_section`. **When NOT to use:** Don't use to add a new block — use `studio_add_block`. Don't use to move a SECTION — use `studio_move_section`. Targets are LOCAL sections only: global sections are read-only via this server, so neither the target nor a block currently INSIDE a global section is accepted (moving one out is rejected with `INVALID_INPUT`). NOTE: a block nested below a global-section *reference* on a page is detected as global only when it resides in the global's own storage; the source guard is best-effort. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","blockId":"c3e5g7j9l1n3p5r7t9v1","to":{"sectionId":"b8h2k4m6p0r3t5v7c9d1","slot":"items"}}` **Response:** `{ blockId, catalogVersion, warnings }` — `blockId` is the moved block (id unchanged). `catalogVersion` is the component-catalog fingerprint at write time. `SLOT_NOT_FOUND` (carries `detail.availableSlots`) means the target slot name does not exist on the section component; `BLOCK_NOT_ALLOWED_IN_SLOT` (carries `detail.catalogVersion` + `detail.refresh.tool`) means the slot exists but the block is not permitted in it. `QUERY_SCOPE_VIOLATION` means the move would orphan or import a query across the global/page boundary. `BLOCK_NOT_FOUND` / `SECTION_NOT_FOUND` mean the source block or target section id did not resolve. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_move_block

Reorder a section within its container, or relocate it between containers (header/body/footer) and between page variants — preserving the section (and, for a global-section reference, its link to the global). Works for a LOCAL section OR a global-section reference placed on a page. **When to use:** Use to reposition an existing section: reorder it in its container (same variant + `location`, new `to.atIndex`), move it from body to header/footer, or move it onto another page variant (`to.pageVariantId`). Moving a global-section *reference* around a page is allowed — it edits the PAGE, not the global. Discover the `sectionId` and target variant/container with `studio_get_page_tree` / `studio_list_pages`. **When NOT to use:** Don't use to add a new section — use `studio_add_section`. Don't use to move a BLOCK — use `studio_move_block`. A query-bound (dynamic) LOCAL section cannot be moved to a different page variant (`QUERY_SCOPE_VIOLATION`): its page-scoped query would be orphaned. Reorders and same-page relocations are always fine; references move freely across pages. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","sectionId":"b8h2k4m6p0r3t5v7c9d1","to":{"location":"header","atIndex":0}}` **Response:** `{ sectionId, catalogVersion, warnings }` — `sectionId` is the moved section (id unchanged). `catalogVersion` is the component-catalog fingerprint at write time. `QUERY_SCOPE_VIOLATION` means a cross-page move would orphan the section's page query. `SECTION_NOT_FOUND` / `PAGE_VARIANT_NOT_FOUND` mean the source section or target variant id did not resolve. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_move_section

Write 1–50 static prop values on sections or blocks (local or inside a global section) in ONE atomic mutation. Each item in `writes` is a self-contained write: `at` + `keyPath` address the prop, and exactly one of `value` (one value, optionally fanned to several `locales`) or `values` (a per-locale map writing DIFFERENT text per locale) carries the payload. Mixed targets are fine — different sections/blocks, across page variants, in one call. The global section container itself cannot be targeted — only blocks within it, via their `blockId`. For complex primitives (link/color/media/json) build the subtype-tagged object documented in the "Complex prop subtypes" section of the `studio_get_data_model` tool, and read the current shape via `studio_get_prop` / `studio_get_section` before overwriting. **When to use:** Use to fill in copy, images, links, colors — any static values on existing entities. BATCH related edits: conceptually "set the props of this page" is ONE call, not one call per prop. Discover entity ids with `studio_get_page_tree`, inspect current props via `studio_get_section`, and read each field's `translatable` flag with `studio_get_component_schemas`: when `true`, pass the SAME value to several locales via `value` + `locales`, or DIFFERENT text per locale via the `values` map (which `studio_get_prop` returns ready to edit); when `false` `locales`/`values` are optional. `values` merges (only listed locales change; a `null` entry clears just that locale). Duplicate targets in one batch apply in order, last one wins. **When NOT to use:** Don't use to write a value bound to a query result — not yet available via this server (ask the human to wire it up in Studio). Don't use to rename or hide an entity — use `studio_update_section` / `studio_update_block`. Cap is 50 writes per call; split larger jobs across calls. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","writes":[{"at":{"blockId":"c3e5g7j9l1n3p5r7t9v1"},"keyPath":["cta","label"],"value":"Shop now","locales":["en","de"]},{"at":{"sectionId":"b8h2k4m6p0r3t5v7c9d1"},"keyPath":["heading"],"values":{"en":"Sale","de":"Angebot"}}]}` **Response:** `{ results, catalogVersion, warnings }` — `results` is index-aligned with `writes`, each `{ writtenLocales, warnings }`; `catalogVersion` is the component-catalog fingerprint at write time (once per batch); `warnings` is snapshot-level. On failure the whole batch is rejected atomically: the message is prefixed `writes[<i>]:` and `detail.itemIndex` (0-based) names the bad item. Catalog-drift errors (`COMPONENT_NOT_FOUND` / `BLOCK_NOT_ALLOWED_IN_SLOT`) carry `detail.catalogVersion` + `detail.refresh.tool`; locale errors (`MISSING_LOCALES` / `INVALID_LOCALES`) carry `detail.allowed` (the project locales). Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_set_static_props

Update a block's studio metadata (label), visibility decorator, or rules. Pass only the top-level keys (`studio`, `visibility`, `rules`) you want to touch — omitted keys are preserved. `visibility` and `rules` are absolute-state: each provided object replaces the stored one in full. `studio` is shallow-merged: the studio keys you provide overwrite their stored values, other studio keys are preserved. **When to use:** Use to rename a block in the layer tree, change its visibility condition, or update its rules. Discover the `blockId` with `studio_get_page_tree`. **When NOT to use:** Don't use to change component props — use `studio_set_static_props`. Don't use to remove the block — use `studio_delete_block`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","blockId":"c3e5g7j9l1n3p5r7t9v1","data":{"studio":{"label":"Primary CTA"}}}` **Response:** `{ blockId, catalogVersion, warnings }` — `catalogVersion` is the component-catalog fingerprint at write time. Catalog-related errors carry `detail.catalogVersion` + `detail.refresh.tool`; re-list with `studio_list_components` when either changes. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_update_block

Update a page variant's SEO metadata (`title`, `description`) and/or its Studio layer-tree `label`. SEO fields are localized via the same `value` / `values` / `locales` contract as a `studio_set_static_props` write item (always translatable), and merge per-locale — writing `en` never clobbers an existing `de`. Pass the fields under `data`; omitted keys are preserved. This edits PAGE-level metadata; it does not touch section/block props. **When to use:** Use to set or rewrite a page's SEO title/description, or to rename a variant in the layer tree. Read the current values first from `studio_get_page_tree` (its `seo` block returns the `{ <locale>: value }` maps ready to edit). SEO is stored PER VARIANT — on a localized site, update each locale's variant (or pass every locale via `values`). **When NOT to use:** Don't use to edit a section or block's component props — use `studio_set_static_props`. Page and variant creation are not supported — ask the human to create them in Studio. Setting `robots` is not yet exposed. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","pageVariantId":"a1b2c3d4e5f6g7h8j9k0","data":{"seo":{"title":{"value":"Best Running Shoes","locales":["en"]},"description":{"values":{"en":"Shop our range.","de":"Entdecke unser Sortiment."}}}}}` **Response:** `{ pageVariantId, writtenLocales, catalogVersion, warnings }` — `writtenLocales` is `{ title?: string[]; description?: string[] }`, the locales written per SEO field touched (absent for a label-only change). `PAGE_VARIANT_NOT_FOUND` means the id did not resolve; `INVALID_LOCALES` / `MISSING_LOCALES` carry `detail.allowed` (the project locales); `INVALID_INPUT` means `data` had no actionable key or a field set both `value` and `values`. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_update_page_variant

Update a section's studio metadata (label) or visibility decorator. Pass the fields under `data` — `data.studio` (label) and/or `data.visibility` — that you want to touch; omitted keys are preserved. `visibility` is absolute-state: the provided object replaces the stored one in full. `studio` is shallow-merged: the studio keys you provide overwrite their stored values, other studio keys are preserved. **When to use:** Use to rename a section in the layer tree or change its visibility conditions. Read the current value with `studio_get_section` first so the overwrite is informed. **When NOT to use:** Don't use to change the section's component props — use `studio_set_static_props`. Don't use to remove a section — use `studio_delete_section`. **Example call:** `{"projectId":"9m4e2mr0ui3e8a215n4g","sectionId":"b8h2k4m6p0r3t5v7c9d1","data":{"studio":{"label":"Above-the-fold hero"}}}` **Response:** `{ sectionId, catalogVersion, warnings }` — `catalogVersion` is the component-catalog fingerprint at write time. Catalog-related errors carry `detail.catalogVersion` + `detail.refresh.tool`; re-list with `studio_list_components` when either changes. Scoped to `projectId`. IDs (sectionId, blockId, pageVariantId, …) from one project are not valid in another.

studio_update_section