@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-tools/project-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/agent-tools/project-files.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,oBAAoB;mBACzB,oBAAoB;oBACnB,oBAAoB;0BAEzB,8QAA8Q;;;;;;;;;;;;;;;;;;;;CASxQ,CAAA;AAEV,eAAO,MAAM,kBAAkB;aAC7B,IAAI,EAAE,kBAAkB;aACxB,KAAK,EAAE,mBAAmB;aAC1B,WAAW,EACT,2JAA2J;aAC7J,KAAK;;;;aACL,WAAW;;;;;;CACH,CAAA;AAEV,eAAO,MAAM,qBAAqB;mBAC1B,qBAAqB;oBACpB,qBAAqB;0BAE1B,ieAAie;;;;;;;;;;;;;;;;iBAuBje,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,qBAAqB;mBAC1B,qBAAqB;oBACpB,qBAAqB;0BAE1B,yHAAyH;;;;;;;iBAGzH,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,qBAAqB;aAChC,IAAI,EAAE,qBAAqB;aAC3B,KAAK,EAAE,qBAAqB;aAC5B,WAAW,EACT,uOAAuO;aACzO,KAAK;;;;aACL,WAAW;iBACT,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;CAEP,CAAA;AAEV,eAAO,MAAM,2BAA2B;mBArFhC,oBAAoB;oBACnB,oBAAoB;0BAEzB,8QAA8Q;;;;;;;;;;;;;;;;;;;;;mBAY1Q,kBAAkB;oBACjB,mBAAmB;0BAExB,2JAA2J;;;;;;;;;;;;mBAMvJ,qBAAqB;oBACpB,qBAAqB;0BAE1B,ieAAie;;;;;;;;;;;;;;;;iBAuBje,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;;mBAKT,qBAAqB;oBACpB,qBAAqB;0BAE1B,yHAAyH;;;;;;;iBAGzH,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;;mBAKT,qBAAqB;oBACpB,qBAAqB;0BAE1B,uOAAuO;;;;;;iBAGvO,YAAY;iBACZ,eAAe;iBACf,cAAc;iBACd,aAAa;;EAUP,CAAA;AACV,MAAM,MAAM,mBAAmB,GAAG,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAA"}

package/dist/agent-tools/project-files.js

@@ -0,0 +1,99 @@
+import { z } from 'zod';
+const project = {
+    projectId: z
+        .string()
+        .min(1)
+        .max(128)
+        .optional()
+        .describe('Hosted project ID. Omit to use the active project.'),
+};
+const file = { ...project, fileId: z.string().min(1).max(128) };
+const read = {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+};
+export const getProjectAssetsTool = {
+    name: 'get_project_assets',
+    title: 'List project files',
+    description: 'List and search the project file catalog: user uploads, plugin documents, snapshots, and completed Studio images, materials and videos. Returns file IDs, names, MIME types and download URLs. Threads and messages are not files. Follow nextCursor to retrieve more files.',
+    input: {
+        ...project,
+        type: z.enum(['scan', 'guide', 'image', 'document', 'other']).optional(),
+        query: z.string().max(300).optional(),
+        cursor: z.string().max(1000).optional(),
+        limit: z.number().int().min(1).max(200).optional(),
+    },
+    annotations: read,
+};
+export const getProjectFileTool = {
+    name: 'get_project_file',
+    title: 'Read project file',
+    description: 'Get one project file and its download URL by fileId from get_project_assets. Requires membership in the project workspace, including for public projects.',
+    input: file,
+    annotations: read,
+};
+export const uploadProjectFileTool = {
+    name: 'upload_project_file',
+    title: 'Upload project file',
+    description: 'Keep a deliverable or reference in the project file catalog. Use phase text with UTF-8 content for CSV, Markdown, JSON and other text files. For binary or large files, phase prepare with size returns a signedUrl: PUT the bytes there, then call phase complete with the same name, mimeType, size, returned fileId and storageKey. Limit 500 MB; SVG is refused. A file is listed only after completion. After a lost text-upload response, list files before retrying to avoid duplicates.',
+    input: {
+        ...project,
+        phase: z.enum(['text', 'prepare', 'complete']),
+        name: z.string().trim().min(1).max(400),
+        mimeType: z.string().min(1).max(200),
+        content: z
+            .string()
+            .max(2 * 1024 * 1024)
+            .optional(),
+        size: z
+            .number()
+            .int()
+            .min(0)
+            .max(500 * 1024 * 1024)
+            .optional(),
+        fileId: z
+            .string()
+            .regex(/^asset_[A-Za-z0-9_-]+$/)
+            .optional(),
+        storageKey: z.string().max(700).optional(),
+    },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false,
+    },
+};
+export const renameProjectFileTool = {
+    name: 'rename_project_file',
+    title: 'Rename project file',
+    description: 'Rename a file in the project catalog. The file ID and content URL stay stable; a Studio file is also renamed in Studio.',
+    input: { ...file, name: z.string().trim().min(1).max(400) },
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+};
+export const deleteProjectFileTool = {
+    name: 'delete_project_file',
+    title: 'Delete project file',
+    description: 'Remove a file from the project catalog. A Studio file is removed from Studio too. Only do this when the user requests deletion. Existing scene or chat references may still retain the bytes; this is not guaranteed storage erasure.',
+    input: file,
+    annotations: {
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+};
+export const PROJECT_FILE_TOOL_CONTRACTS = [
+    getProjectAssetsTool,
+    getProjectFileTool,
+    uploadProjectFileTool,
+    renameProjectFileTool,
+    deleteProjectFileTool,
+];

package/dist/agent-tools/refusal.d.ts

@@ -0,0 +1,20 @@
+/**
+ * A sane, expected failure of an agent operation: the request cannot be done as asked, and the
+ * message says why and what would work ("Wall wall_a is 0.80 m long, too short for a 0.90 m
+ * door."). Every surface answers it the same way, `{ error, code, ...details }`, and counts it by
+ * `code` — a refusal is information for the model, not a crash.
+ */
+export declare class AgentRefusal extends Error {
+    readonly code: string;
+    readonly details: Record<string, unknown>;
+    readonly name = "AgentRefusal";
+    constructor(code: string, message: string, details?: Record<string, unknown>);
+}
+export declare function isAgentRefusal(error: unknown): error is AgentRefusal;
+export declare function refuse(code: string, message: string, details?: Record<string, unknown>): never;
+/** The answer both surfaces return for a refusal. */
+export declare function refusalPayload(error: AgentRefusal): {
+    error: string;
+    code: string;
+};
+//# sourceMappingURL=refusal.d.ts.map

package/dist/agent-tools/refusal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"refusal.d.ts","sourceRoot":"","sources":["../../src/agent-tools/refusal.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,YAAa,SAAQ,KAAK;IAGnC,QAAQ,CAAC,IAAI,EAAE,MAAM;IAErB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAJ3C,SAAkB,IAAI,kBAAiB;IACvC,YACW,IAAI,EAAE,MAAM,EACrB,OAAO,EAAE,MAAM,EACN,OAAO,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAG/C;CACF;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAOpE;AAED,wBAAgB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,KAAK,CAE9F;AAED,qDAAqD;AACrD,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY;;;EAEjD"}

package/dist/agent-tools/refusal.js

@@ -0,0 +1,29 @@
+/**
+ * A sane, expected failure of an agent operation: the request cannot be done as asked, and the
+ * message says why and what would work ("Wall wall_a is 0.80 m long, too short for a 0.90 m
+ * door."). Every surface answers it the same way, `{ error, code, ...details }`, and counts it by
+ * `code` — a refusal is information for the model, not a crash.
+ */
+export class AgentRefusal extends Error {
+    code;
+    details;
+    name = 'AgentRefusal';
+    constructor(code, message, details = {}) {
+        super(message);
+        this.code = code;
+        this.details = details;
+    }
+}
+export function isAgentRefusal(error) {
+    return (error instanceof AgentRefusal ||
+        (error instanceof Error &&
+            error.name === 'AgentRefusal' &&
+            typeof error.code === 'string'));
+}
+export function refuse(code, message, details) {
+    throw new AgentRefusal(code, message, details);
+}
+/** The answer both surfaces return for a refusal. */
+export function refusalPayload(error) {
+    return { error: error.message, code: error.code, ...error.details };
+}

package/dist/agent-tools/retired.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MCP tools retired into another tool. A retired name is listed by no server and still answered at
+ * `tools/call`, wherever an older client or a saved script can send it: `tool_retired`, with the
+ * tool that replaced it and how to do the same with that one. A host keeps its own surfaces'
+ * retired tools beside these, answered the same way (Pascal's hosted catalogue reads this map).
+ */
+export type RetiredTool = {
+    /** The tool that does what this one did. */
+    replacement: string;
+    /** How to do with the replacement what this tool was called for, said to the model. */
+    how: string;
+};
+/** What a call to a retired name gets back: a refusal, as every surface gives one. */
+export type RetiredToolAnswer = {
+    code: 'tool_retired';
+    error: string;
+    replacement: string;
+};
+export declare function retiredToolRefusal(name: string, { replacement, how }: RetiredTool): RetiredToolAnswer;
+export declare const RETIRED_MCP_TOOLS: Readonly<Record<string, RetiredTool>>;
+//# sourceMappingURL=retired.d.ts.map

package/dist/agent-tools/retired.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"retired.d.ts","sourceRoot":"","sources":["../../src/agent-tools/retired.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,MAAM,MAAM,WAAW,GAAG;IACxB,4CAA4C;IAC5C,WAAW,EAAE,MAAM,CAAA;IACnB,uFAAuF;IACvF,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAED,sFAAsF;AACtF,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAA;AAE5F,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,MAAM,EACZ,EAAE,WAAW,EAAE,GAAG,EAAE,EAAE,WAAW,GAChC,iBAAiB,CAMnB;AAED,eAAO,MAAM,iBAAiB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAenE,CAAA"}

package/dist/agent-tools/retired.js

@@ -0,0 +1,29 @@
+/**
+ * MCP tools retired into another tool. A retired name is listed by no server and still answered at
+ * `tools/call`, wherever an older client or a saved script can send it: `tool_retired`, with the
+ * tool that replaced it and how to do the same with that one. A host keeps its own surfaces'
+ * retired tools beside these, answered the same way (Pascal's hosted catalogue reads this map).
+ */
+export function retiredToolRefusal(name, { replacement, how }) {
+    return {
+        code: 'tool_retired',
+        error: `${name} is retired, use ${replacement}: ${how}`,
+        replacement,
+    };
+}
+export const RETIRED_MCP_TOOLS = {
+    // The schema check, into the one scene check.
+    validate_scene: {
+        replacement: 'verify_scene',
+        how: "its valid is validate_scene's valid; each field a node's schema rejects is an issue of type schema_invalid with its nodeId, path and message, every one as validate_scene listed them; nodes of a kind no schema here knows (a plugin's), each an error there, are one issue schema_unknown_kind (severity info) per kind, with its count and a few nodeIds; a hidden site, validate_scene's warning, is the issue site_hidden (severity info).",
+    },
+    // The node finder and the node read, into the shared ones (slice Q).
+    find_nodes: {
+        replacement: 'find_by_type',
+        how: "it takes the same filters: type (any node kind, a plugin's too; it also finds item categories, lights and typed parts), levelId, parentId, zoneId, sourceId and sourceIdPrefix; without a type, every node they match. Each result gives the node's id, name, nodeType, levelId and parentId, with its metadata and provenance when it has them (one over 1 KB is named in omitted); get_node reads a node whole. A level, parent or zone that is not there is refused, where find_nodes found nothing; a type that names nothing is refused as before (unknown_type), with the kinds the scene holds. Past its limit, results are counted, not listed: truncated says so.",
+    },
+    describe_node: {
+        replacement: 'get_node',
+        how: "its node is describe_node's properties: the fields as stored, with a wall's resolvedHeight and heightIsExplicit (a ceiling's too), a level's or floor plate's displayName; its ancestorIds are describe_node's ancestryIds, parent first; a container's node lists its children as stored, and missingChildIds the ones that name no node (describe_node's childrenIds left them out). Its description's numbers are the node's own fields.",
+    },
+};

package/dist/agent-tools/roofs.d.ts

@@ -0,0 +1,100 @@
+import { z } from 'zod';
+export declare const createRoofTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        roofSystem: z.ZodDefault<z.ZodEnum<{
+            glazed: "glazed";
+            standard: "standard";
+        }>>;
+        glazing: z.ZodOptional<z.ZodObject<{
+            frameColor: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            glassColor: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+            glassOpacity: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            glassRoughness: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            glazedEnds: z.ZodOptional<z.ZodDefault<z.ZodBoolean>>;
+            panelType: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                empty: "empty";
+                glass: "glass";
+                solid: "solid";
+            }>>>;
+            panels: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodObject<{
+                face: z.ZodString;
+                column: z.ZodNumber;
+                row: z.ZodNumber;
+                type: z.ZodEnum<{
+                    empty: "empty";
+                    glass: "glass";
+                    solid: "solid";
+                }>;
+            }, z.core.$strip>>>>;
+            across: z.ZodOptional<z.ZodObject<{
+                layout: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                    count: "count";
+                    "fixed-spacing": "fixed-spacing";
+                    "maximum-spacing": "maximum-spacing";
+                }>>>;
+                count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                alignment: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                    center: "center";
+                    end: "end";
+                    start: "start";
+                }>>>;
+                spacing: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            }, z.core.$strip>>;
+            along: z.ZodOptional<z.ZodObject<{
+                layout: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                    count: "count";
+                    "fixed-spacing": "fixed-spacing";
+                    "maximum-spacing": "maximum-spacing";
+                }>>>;
+                count: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+                alignment: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
+                    center: "center";
+                    end: "end";
+                    start: "start";
+                }>>>;
+                spacing: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            }, z.core.$strip>>;
+            frameWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            frameDepth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            glassThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        }, z.core.$strip>>;
+        barrelRise: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        barrelSegments: z.ZodOptional<z.ZodNumber>;
+        wallThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        roofType: z.ZodOptional<z.ZodEnum<{
+            barrel: "barrel";
+            conical: "conical";
+            dutch: "dutch";
+            flat: "flat";
+            gable: "gable";
+            gambrel: "gambrel";
+            hip: "hip";
+            mansard: "mansard";
+            shed: "shed";
+        }>>;
+        pitch: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        overhang: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        depth: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        center: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        materialPreset: z.ZodOptional<z.ZodString>;
+        fasciaHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        fasciaMaterialPreset: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const moveRoofsToRoofLevelTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodString;
+    };
+};
+//# sourceMappingURL=roofs.d.ts.map

package/dist/agent-tools/roofs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roofs.d.ts","sourceRoot":"","sources":["../../src/agent-tools/roofs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAiCvB,eAAO,MAAM,cAAc;IACzB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,UAAU;;;;QACV,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACP,UAAU;QAIV,cAAc;QACd,aAAa;QAIb,OAAO;QAGP,KAAK;QACL,QAAQ;;;;;;;;;;;QAGR,KAAK;QAKL,QAAQ;QAKR,UAAU;QAIV,KAAK;QAKL,KAAK;QAIL,MAAM;QAKN,cAAc;QAEd,YAAY;QAKZ,oBAAoB;QAMpB,IAAI;;CAEP,CAAA;AAED,eAAO,MAAM,wBAAwB;IACnC,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;;CAEV,CAAA"}

package/dist/agent-tools/roofs.js

@@ -0,0 +1,96 @@
+import { z } from 'zod';
+import { CurtainGrid } from '../schema/nodes/curtain-wall.js';
+import { RoofGlazing, RoofSystemType } from '../schema/nodes/roof-glazing-config.js';
+import { RoofType } from '../schema/nodes/roof-types.js';
+import { measurement, roofPitch } from './measurement.js';
+import { NodeId } from './node-id.js';
+const glazingGrid = CurtainGrid.partial().extend({
+    spacing: measurement('length', 'm', {
+        min: 0.2,
+        max: 100,
+        description: 'Bar spacing, for the maximum-spacing and fixed-spacing layouts.',
+    }).optional(),
+});
+/** A roof's glazing as the node stores it, its lengths read in any unit. */
+const RoofGlazingInput = RoofGlazing.partial().extend({
+    across: glazingGrid.optional(),
+    along: glazingGrid.optional(),
+    frameWidth: measurement('length', 'm', {
+        positive: true,
+        description: 'Frame bar width.',
+    }).optional(),
+    frameDepth: measurement('length', 'm', {
+        positive: true,
+        description: 'Frame bar depth.',
+    }).optional(),
+    glassThickness: measurement('length', 'm', {
+        positive: true,
+        description: 'Glass pane thickness.',
+    }).optional(),
+});
+export const createRoofTool = {
+    name: 'create_roof',
+    title: 'Create roof',
+    description: "Cap a storey with a roof over its footprint (its walls' outline, else its floor plates, else its rooms), swept in the building's own axes into rectangles, one roof segment each. Without a roofType: a gable for one rectangle, hips for a few wings, flat for a large block. The roof goes on the building's roof level above the top storey (the empty level directly above when it is the only one; made, named Roof, when there is none), and stands on the storey's wall tops, so exploded and solo level views lift it off the plan. Glazed construction supports gable, straight shed and barrel. Barrel depth is the span; barrelRise is at most half the span. glazing controls frame, glass, grids and panels. Paint glazing-frame, glazing-glass or glazing-solid. Call it once the storeys and their exterior walls stand. Refused with a code: storey_above (another storey stands above: a roof caps the top one; a lower wing's roof is drawn with the Roof tool), building_required (no level named on a site of several buildings: pass a level of the one to roof), roof_exists (the storey already has a roof: edit it, or delete_node it first when the person asked for a new one), no_rooms (no rooms or closed walls on any level of the building: pass width and depth to roof a rectangle of your own).",
+    input: {
+        roofSystem: RoofSystemType.default('standard'),
+        glazing: RoofGlazingInput.optional(),
+        barrelRise: measurement('length', 'm', {
+            positive: true,
+            description: 'Barrel arch rise, at most half each segment span.',
+        }).optional(),
+        barrelSegments: z.number().int().min(4).max(32).optional(),
+        wallThickness: measurement('length', 'm', {
+            positive: true,
+            description: 'Roof wall thickness.',
+        }).optional(),
+        levelId: NodeId.optional().describe('The storey to cover, by an id list_levels returned. Default: the top storey with rooms. A level without rooms stands for the highest storey of its building that has some.'),
+        level: NodeId.optional().describe('Same as levelId.'),
+        roofType: RoofType.optional().describe('The shape of every segment. Default: chosen from the footprint.'),
+        pitch: roofPitch('deg', {
+            min: 0,
+            max: 85,
+            description: 'Slope of the roof planes (default 40°).',
+        }).optional(),
+        overhang: measurement('length', 'm', {
+            min: 0,
+            description: 'Eave overhang: how far the eaves reach past the walls in plan (a segment stores it along its slope). Read it from the photo: a deep modern overhang is 1–2 m. Default 0.3.',
+        }).optional(),
+        wallHeight: measurement('length', 'm', {
+            min: 0,
+            description: 'Knee walls under the eaves (default 0: the roof starts at the wall tops).',
+        }).optional(),
+        width: measurement('length', 'm', {
+            positive: true,
+            description: 'With depth: roof a rectangle of your own instead of the footprint (a wing, or walls drawn without rooms), along x.',
+        }).optional(),
+        depth: measurement('length', 'm', {
+            positive: true,
+            description: "The rectangle's depth, along z.",
+        }).optional(),
+        center: z
+            .array(z.number())
+            .length(2)
+            .optional()
+            .describe("The rectangle's centre [x, z] in metres (default [0, 0])."),
+        materialPreset: z.string().optional().describe('The roof finish, a library material.'),
+        // A flat roof's fascia band (often about 0.3 m tall), which only apply_patch could draw before.
+        fasciaHeight: measurement('length', 'm', {
+            positive: true,
+            description: "A fascia band of that height round the roof's eaves and rakes; on a flat roof it reaches the roof's top, a coping over its edge. Absent (and no fasciaMaterialPreset): no band.",
+        }).optional(),
+        fasciaMaterialPreset: z
+            .string()
+            .optional()
+            .describe("The band's finish, a library material (a black fascia: library:preset-nearblack); the roof's wall finish when absent."),
+        name: z.string().max(120).optional().describe('What the user would call it (default "Roof").'),
+    },
+};
+export const moveRoofsToRoofLevelTool = {
+    name: 'move_roofs_to_roof_level',
+    title: 'Move roofs to the roof level',
+    description: "Move the roofs a storey holds on its own walls to the level the roof rule gives them, as a roof's panel does by hand (Move to the roof level): over the top storey, the building's roof level (made, named Roof, when there is none); under an upper storey, that storey. Each roof stands exactly where it stood, its segments, finishes and id kept: only the level holding it changes, so exploded and solo level views show the storey's plan with no roof over it. For a project built before roofs had their own level, when verify_scene reports roof_mixed_in_storey. Refused with a code: level_not_found, no_roof_on_walls (the storey holds no roof standing on its walls; a porch roof on its beam and a lower wing's roof on the storey above already sit where they belong). Returns the roofs moved (roofIds), the level they went to (roofLevelId) and the roof level made for them (createdRoofLevelId).",
+    input: {
+        levelId: NodeId.describe('The storey whose roofs move, by an id list_levels returned.'),
+    },
+};