@pascal-app/core 1.0.3 → 1.0.4

package/dist/agent-tools/search-materials.js

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+// The library's surfaces, named here so the contract stays free of the catalog it searches.
+const SURFACES = [
+    'floor',
+    'wall',
+    'ceiling',
+    'roof',
+    'furniture',
+    'outdoor',
+];
+export const searchMaterialsTool = {
+    name: 'search_materials',
+    title: 'Search materials',
+    description: "Search the material library (the finishes paint gives) by words, several queries in one call: find a library material's id here rather than guessing it. A query's words match the words of a material's id, name and kind, building words as the library writes them (timber is wood, weatherboard is siding, render is stucco), colour words by its shade (dark, light, white, grey) and surface words (roof, wall, floor, ceiling) by what it suits. Returns one group per query: each material's ref (library:<id>), name, kind, the surfaces it suits and its colour, best first, and the words no material answers (missing), so a finish the library lacks is said, not guessed.",
+    input: {
+        queries: z
+            .array(z.object({
+            query: z
+                .string()
+                .trim()
+                .min(1)
+                .describe('Search words, e.g. "white render", "grey metal roofing", "oak floor".'),
+            surface: z
+                .enum(SURFACES)
+                .optional()
+                .describe('Only materials that suit this surface; flat colours suit every one.'),
+        }))
+            .min(1)
+            .max(12)
+            .describe('One or more searches to run in one call.'),
+    },
+};

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

@@ -0,0 +1,86 @@
+import { z } from 'zod';
+export declare const measureStairTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        stairId: z.ZodString;
+        available: z.ZodOptional<z.ZodObject<{
+            width: z.ZodNumber;
+            length: z.ZodNumber;
+        }, z.core.$strip>>;
+    };
+};
+export declare const fitStairTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        stairId: z.ZodString;
+        fitRun: z.ZodDefault<z.ZodBoolean>;
+        layout: z.ZodOptional<z.ZodEnum<{
+            straight: "straight";
+            u: "u";
+            l: "l";
+        }>>;
+        turn: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        width: z.ZodOptional<z.ZodNumber>;
+        landingDepth: z.ZodOptional<z.ZodNumber>;
+        turningStrategy: z.ZodOptional<z.ZodEnum<{
+            landing: "landing";
+            winder: "winder";
+        }>>;
+        innerGap: z.ZodOptional<z.ZodNumber>;
+        walkingLineOffset: z.ZodOptional<z.ZodNumber>;
+        division: z.ZodOptional<z.ZodEnum<{
+            "equal-going": "equal-going";
+            "equal-angle": "equal-angle";
+        }>>;
+        targets: z.ZodOptional<z.ZodObject<{
+            maxRiserHeight: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            minimumGoing: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            targetGoing: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+            minimumHeadroom: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
+        }, z.core.$strip>>;
+    };
+};
+export declare const createStairTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        toLevelId: z.ZodOptional<z.ZodString>;
+        railingMode: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+            none: "none";
+            both: "both";
+        }>>;
+        materialPreset: z.ZodOptional<z.ZodString>;
+        name: z.ZodOptional<z.ZodString>;
+        createDestinationSlabOpening: z.ZodOptional<z.ZodBoolean>;
+        createSourceCeilingOpening: z.ZodOptional<z.ZodBoolean>;
+        destinationSlabId: z.ZodOptional<z.ZodString>;
+        sourceCeilingId: z.ZodOptional<z.ZodString>;
+        openingWidth: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingLength: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingOffset: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingCenter: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        openingRotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        x: z.ZodNumber;
+        z: z.ZodNumber;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        length: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        steps: z.ZodOptional<z.ZodNumber>;
+    };
+};
+export type MeasureStairInput = z.infer<z.ZodObject<typeof measureStairTool.input>>;
+export type FitStairInput = z.infer<z.ZodObject<typeof fitStairTool.input>>;
+//# sourceMappingURL=stairs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stairs.d.ts","sourceRoot":"","sources":["../../src/agent-tools/stairs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAS5B,CAAA;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkBxB,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAiF3B,CAAA;AAED,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,gBAAgB,CAAC,KAAK,CAAC,CAAC,CAAA;AACnF,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC,CAAA"}

package/dist/agent-tools/stairs.js

@@ -0,0 +1,103 @@
+import { z } from 'zod';
+import { StairDesignTargets } from '../schema/nodes/stair-design-targets.js';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+export const measureStairTool = {
+    name: 'measure_stair',
+    title: 'Measure stair',
+    description: 'Inspect actual flight risers, walking-line going, slope, arrival, uniformity, headroom against floors, ceilings and stair bodies, and design-target diagnostics without changing measured geometry.',
+    input: {
+        stairId: NodeId,
+        available: z.object({ width: z.number().positive(), length: z.number().positive() }).optional(),
+    },
+};
+export const fitStairTool = {
+    name: 'fit_stair',
+    title: 'Fit stair',
+    description: 'Explicitly replace stair riser proportions with uniform risers from design targets. Optionally fit going by changing flight runs or arc sweep; preserves landing elevations. Optional straight, L or U layout replaces the flight chain with width-sized turning landings or quarter-turn winders. Winder going is measured along the selected walking line. One atomic edit.',
+    input: {
+        stairId: NodeId,
+        fitRun: z.boolean().default(false),
+        layout: z.enum(['straight', 'l', 'u']).optional(),
+        turn: z.enum(['left', 'right']).optional(),
+        width: z.number().positive().optional(),
+        landingDepth: z.number().positive().optional(),
+        turningStrategy: z.enum(['landing', 'winder']).optional(),
+        innerGap: z.number().nonnegative().optional(),
+        walkingLineOffset: z.number().positive().optional(),
+        division: z.enum(['equal-going', 'equal-angle']).optional(),
+        targets: StairDesignTargets.partial().optional(),
+    },
+};
+export const createStairTool = {
+    name: 'create_stair',
+    title: 'Create stair',
+    description: "Create a straight staircase rising from a level to the level above, as the editor's stair tool does: it owns the floor opening it cuts in every floor it passes, and when no level stands above, a blank one is created for it. Refused with a code: a flight to or from a declared roof level, and a toLevelId that is not above the level it rises from.\n\nGEOMETRY (get this wrong and the stair pokes through a wall):\n- (x, z) is the BACK-CENTRE of the first (bottom) step, not the centre of the footprint.\n- The footprint is width × length: width side to side, length along the climb. At rotation 0 it covers x − width/2 .. x + width/2 and z .. z + length.\n- rotation in degrees about Y: 0 climbs toward +Z, 90 → +X, 180 → −Z, 270 → −X. Point the climb into the room, away from the wall the bottom step sits against.\n- Leave at least 0.5 m clear at the foot of the flight, and keep the whole footprint inside one room on both levels (a hall is typical): read the room's outline first (get_zones).\n\nOPENINGS: by default the stair owns the opening over its flight and keeps it as the flight moves (openingOffset widens it). An opening of another size, centre or turn, through a slab or ceiling you name, or through one of the two only, is cut as an opening the stair owns, as given.",
+    input: {
+        x: z.number().describe('X of the back-centre of the first step.'),
+        z: z.number().describe('Z of the back-centre of the first step.'),
+        rotation: measurement('angle', 'deg', {
+            description: 'The climb direction (default 0 = toward +Z; 90 = +X, 180 = −Z, 270 = −X).',
+        }).optional(),
+        width: measurement('length', 'm', {
+            positive: true,
+            description: 'Side-to-side width, across the climb (default 1.0 m).',
+        }).optional(),
+        length: measurement('length', 'm', {
+            positive: true,
+            description: "Horizontal run along the climb (default: from the stair's design targets, 0.28 m of going per riser, risers of at most 0.18 m).",
+        }).optional(),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: "Vertical rise. Omit it unless asked for a specific rise: the flight then follows the storey's floor-to-floor height and keeps tracking it.",
+        }).optional(),
+        steps: z
+            .number()
+            .int()
+            .min(3)
+            .optional()
+            .describe('Number of risers. Omit it to derive ~18 cm risers from the rise; pass it when the run was planned from a step count.'),
+        ...levelTarget,
+        toLevelId: NodeId.optional().describe('The level the flight arrives on. Default: the next level above, created when there is none.'),
+        railingMode: z
+            .enum(['none', 'left', 'right', 'both'])
+            .optional()
+            .describe('Which sides have a railing, looking up the flight (default both).'),
+        materialPreset: z
+            .string()
+            .optional()
+            .describe('A library material for the flight (library:<id>); an unknown one is refused.'),
+        name: z.string().optional().describe('Its name (default Staircase N).'),
+        createDestinationSlabOpening: z
+            .boolean()
+            .optional()
+            .describe('Cut the floor it arrives through (default true).'),
+        createSourceCeilingOpening: z
+            .boolean()
+            .optional()
+            .describe('Cut the ceiling of the floor it leaves (default true).'),
+        destinationSlabId: NodeId.optional().describe('The slab it arrives through. Default: the floor of the level it arrives on.'),
+        sourceCeilingId: NodeId.optional().describe('The ceiling it rises through. Default: the ceiling of the level it leaves.'),
+        openingWidth: measurement('length', 'm', {
+            positive: true,
+            description: 'The opening across the climb (default the flight width).',
+        }).optional(),
+        openingLength: measurement('length', 'm', {
+            positive: true,
+            description: 'The opening along the climb (default the run length).',
+        }).optional(),
+        openingOffset: measurement('length', 'm', {
+            min: 0,
+            description: 'A margin round the opening on every side (default 0.08 m).',
+        }).optional(),
+        openingCenter: z
+            .array(z.number())
+            .length(2)
+            .optional()
+            .describe('The opening centre (x, z). Default: the middle of the flight.'),
+        openingRotation: measurement('angle', 'deg', {
+            description: "The opening's turn (default the flight's).",
+        }).optional(),
+    },
+};

package/dist/agent-tools/verify-scene.d.ts

@@ -0,0 +1,13 @@
+import type { z } from 'zod';
+/** Adds inputs and a sentence of description to verify_scene, for a check registered with it. */
+export declare function extendVerifyScene(extension: {
+    input: Record<string, z.ZodType>;
+    description: string;
+}): void;
+export declare const verifySceneTool: {
+    name: string;
+    title: string;
+    readonly description: string;
+    readonly input: Record<string, z.ZodType>;
+};
+//# sourceMappingURL=verify-scene.d.ts.map

package/dist/agent-tools/verify-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/verify-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAS5B,iGAAiG;AACjG,wBAAgB,iBAAiB,CAAC,SAAS,EAAE;IAC3C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,CAAA;IAChC,WAAW,EAAE,MAAM,CAAA;CACpB,QAEA;AAKD,eAAO,MAAM,eAAe;;;;oBAMb,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC;CAGvC,CAAA"}

package/dist/agent-tools/verify-scene.js

@@ -0,0 +1,21 @@
+/**
+ * `verify_scene`'s contract. Other modules extend it with an input and a sentence for the check
+ * they register (the photo's: `photo`), so it stays one tool agents know, with one contract on
+ * both surfaces, and imports none of them.
+ */
+const extensions = [];
+/** Adds inputs and a sentence of description to verify_scene, for a check registered with it. */
+export function extendVerifyScene(extension) {
+    extensions.push(extension);
+}
+const DESCRIPTION = 'Check the whole scene after complex edits, and before retrying a failed tool: per-level content and roles (storey, roof-only, support), then every problem found, each with a type: empty levels, walls with no room or door, rooms with no floor or ceiling, storeys with no stair, roof levels misused, openings off their wall, stairs off their slab or blocked, furniture blocking a door or overlapping, nodes their schema rejects.';
+export const verifySceneTool = {
+    name: 'verify_scene',
+    title: 'Verify scene',
+    get description() {
+        return [DESCRIPTION, ...extensions.map((extension) => extension.description)].join(' ');
+    },
+    get input() {
+        return Object.assign({}, ...extensions.map((extension) => extension.input));
+    },
+};

package/dist/agent-tools/view-scene.d.ts

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+export declare const VIEW_SIDES: readonly ["north", "north-east", "east", "south-east", "south", "south-west", "west", "north-west", "above"];
+export declare const viewSceneTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        target: z.ZodOptional<z.ZodString>;
+        interior: z.ZodOptional<z.ZodObject<{
+            levelId: z.ZodString;
+        }, z.core.$strip>>;
+        from: z.ZodOptional<z.ZodEnum<{
+            above: "above";
+            north: "north";
+            "north-east": "north-east";
+            east: "east";
+            "south-east": "south-east";
+            south: "south";
+            "south-west": "south-west";
+            west: "west";
+            "north-west": "north-west";
+        }>>;
+        elevation: z.ZodOptional<z.ZodNumber>;
+        eyeHeight: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        projection: z.ZodOptional<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        camera: z.ZodOptional<z.ZodObject<{
+            position: z.ZodArray<z.ZodNumber>;
+            target: z.ZodArray<z.ZodNumber>;
+            fov: z.ZodNumber;
+            aspect: z.ZodNumber;
+        }, z.core.$loose>>;
+        photo: z.ZodOptional<z.ZodObject<{
+            source: z.ZodString;
+            region: z.ZodArray<z.ZodNumber>;
+        }, z.core.$loose>>;
+    };
+};
+//# sourceMappingURL=view-scene.d.ts.map

package/dist/agent-tools/view-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-scene.d.ts","sourceRoot":"","sources":["../../src/agent-tools/view-scene.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,UAAU,8GAUb,CAAA;AAEV,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA6EzB,CAAA"}

package/dist/agent-tools/view-scene.js

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+const point = z.array(z.number()).length(3);
+export const VIEW_SIDES = [
+    'north',
+    'north-east',
+    'east',
+    'south-east',
+    'south',
+    'south-west',
+    'west',
+    'north-west',
+    'above',
+];
+export const viewSceneTool = {
+    name: 'view_scene',
+    title: 'Look at the scene',
+    description: "Look at the building in 3D from a viewpoint you pick and get the picture back. Use it to compare what you built with a reference and say what differs before you fix it: the facade from the photo's own camera (camera: its position, aim, field of view and aspect), rendered at the photo's aspect to lay beside it; or from the photo's side at street height (from, eyeHeight 1.7); one face square on (projection orthographic); the massing from above. North is the plan's top edge (z grows south, x east). The view frames the target (a building, a level, a wall or a zone; the whole building by default) from outside, unless you place the eye yourself with position or camera. To see inside a floor, give interior {levelId}: the other floors and that floor's roofs and ceilings are left out of the picture, and everything on it, walls, openings and furniture alike, is cut at 0.65 of the storey's height (about two thirds), so a tall wardrobe or a door head is cut, not short; a roof level has no inside; with no eye given it looks down into the floor, or into the room or zone you target. The live view is not changed. A door, a window or an item on a floor frames at detail scale, an opening seen from its outside face: a close-up to lay beside the photo's crop of the same element, to see what differs. Over the MCP the user's editor tab open on the project renders the picture: with none open it is refused (editor_tab_required), and a tab in the background must be brought to the front (editor_tab_hidden). A picture is not a measure: take sizes and counts from the tools.",
+    input: {
+        target: z
+            .string()
+            .optional()
+            .describe('A building, level, wall, zone, door, window or floor item id to frame. Default: every wall in the scene.'),
+        interior: z
+            .object({ levelId: z.string().min(1) })
+            .optional()
+            .describe('Look inside this floor (a level id): the other floors and its roofs and ceilings are left out of the picture, everything on it (walls, openings, furniture) cut at 0.65 of the storey height. Default framing looks down into it; camera or position still wins.'),
+        from: z
+            .enum(VIEW_SIDES)
+            .optional()
+            .describe('The side the eye stands on, as a compass on the plan. Default south-west.'),
+        elevation: z
+            .number()
+            .min(-10)
+            .max(89)
+            .optional()
+            .describe('Degrees above the horizon the eye looks down from. Default 12.'),
+        eyeHeight: z
+            .number()
+            .min(0)
+            .optional()
+            .describe('Metres above the ground for a street view (1.7), instead of elevation.'),
+        // Arrays of three, not tuples: a tuple's list-form schema is refused by some clients.
+        position: point
+            .optional()
+            .describe('The eye exactly, [x, height, z] in metres; it looks at the target.'),
+        fov: z
+            .number()
+            .min(10)
+            .max(100)
+            .optional()
+            .describe('Vertical field of view in degrees for a perspective view. Default 45.'),
+        projection: z
+            .enum(['perspective', 'orthographic'])
+            .optional()
+            .describe('orthographic for a square-on elevation of a face, no perspective.'),
+        camera: z
+            .looseObject({
+            position: point,
+            target: point,
+            fov: z.number().min(5).max(120),
+            aspect: z.number().min(0.2).max(5),
+        })
+            .optional()
+            .describe("A photo's camera (position, target, fov, aspect): the render takes its eye, aim and field of view at the photo's aspect. Not with from, position, elevation, eyeHeight, fov or projection."),
+        photo: z
+            .looseObject({
+            source: z
+                .string()
+                .min(1)
+                .max(8_000_000)
+                .describe('The photo as a data:image/...;base64 URL (read the file and encode it); in the chat, the URL of a file the user attached works too.'),
+            region: z
+                .array(z.number().min(0))
+                .length(4)
+                .describe("[left, top, right, bottom] in the photo's pixels: the element to compare."),
+        })
+            .optional()
+            .describe("The photo's crop of the element the view frames, returned beside it in the same call: a door's glass, a lamp's shape, a window's panes, at detail scale, to say what differs."),
+    },
+};

package/dist/agent-tools/wall-openings.d.ts

@@ -0,0 +1,163 @@
+import { z } from 'zod';
+export declare const addDoorTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        doorType: z.ZodOptional<z.ZodEnum<{
+            double: "double";
+            hinged: "hinged";
+            french: "french";
+            folding: "folding";
+            pocket: "pocket";
+            barn: "barn";
+            sliding: "sliding";
+            "garage-sectional": "garage-sectional";
+            "garage-rollup": "garage-rollup";
+            "garage-tiltup": "garage-tiltup";
+        }>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            glass: "glass";
+            french: "french";
+            barn: "barn";
+            panel: "panel";
+            shaker: "shaker";
+            modern: "modern";
+            "paneled-glass": "paneled-glass";
+            "six-panel": "six-panel";
+            craftsman: "craftsman";
+            "half-louvered": "half-louvered";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        code: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodEnum<{
+            three: "three";
+            bpy: "bpy";
+        }>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+        openingShape: z.ZodOptional<z.ZodEnum<{
+            rectangle: "rectangle";
+            rounded: "rounded";
+            arch: "arch";
+        }>>;
+        archHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        cornerRadius: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        openingKind: z.ZodOptional<z.ZodEnum<{
+            door: "door";
+            opening: "opening";
+        }>>;
+        hingesSide: z.ZodOptional<z.ZodEnum<{
+            left: "left";
+            right: "right";
+        }>>;
+        swingDirection: z.ZodOptional<z.ZodEnum<{
+            inward: "inward";
+            outward: "outward";
+        }>>;
+        t: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodNumber>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        wallId: z.ZodOptional<z.ZodString>;
+        nodeId: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const addWindowTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        windowType: z.ZodOptional<z.ZodEnum<{
+            fixed: "fixed";
+            sliding: "sliding";
+            casement: "casement";
+            awning: "awning";
+            hopper: "hopper";
+            "single-hung": "single-hung";
+            "double-hung": "double-hung";
+            bay: "bay";
+            bow: "bow";
+            louvered: "louvered";
+        }>>;
+        columns: z.ZodOptional<z.ZodNumber>;
+        rows: z.ZodOptional<z.ZodNumber>;
+        style: z.ZodOptional<z.ZodEnum<{
+            sliding: "sliding";
+            casement: "casement";
+            "double-hung": "double-hung";
+            single: "single";
+            grid: "grid";
+            "triple-hung": "triple-hung";
+            "tall-grid": "tall-grid";
+            "wide-grid": "wide-grid";
+            "horizontal-bands": "horizontal-bands";
+            transom: "transom";
+            picture: "picture";
+        }>>;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        category: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        code: z.ZodOptional<z.ZodString>;
+        language: z.ZodOptional<z.ZodEnum<{
+            three: "three";
+            bpy: "bpy";
+        }>>;
+        params: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodNumber, z.ZodBoolean, z.ZodString]>>>;
+        openingShape: z.ZodOptional<z.ZodEnum<{
+            rectangle: "rectangle";
+            rounded: "rounded";
+            arch: "arch";
+        }>>;
+        archHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        cornerRadius: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        t: z.ZodOptional<z.ZodNumber>;
+        position: z.ZodOptional<z.ZodNumber>;
+        force: z.ZodOptional<z.ZodBoolean>;
+        wallId: z.ZodOptional<z.ZodString>;
+        nodeId: z.ZodOptional<z.ZodString>;
+    };
+};
+export declare const addDoorOutput: {
+    ok: z.ZodLiteral<true>;
+    wallId: z.ZodString;
+    localX: z.ZodNumber;
+    t: z.ZodNumber;
+    wallLength: z.ZodNumber;
+    clamped: z.ZodBoolean;
+    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
+    message: z.ZodString;
+    achieved: z.ZodObject<{
+        created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        updated: z.ZodNumber;
+        deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        unchanged: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
+    doorId: z.ZodString;
+};
+export declare const addWindowOutput: {
+    sillHeight: z.ZodOptional<z.ZodNumber>;
+    ok: z.ZodLiteral<true>;
+    wallId: z.ZodString;
+    localX: z.ZodNumber;
+    t: z.ZodNumber;
+    wallLength: z.ZodNumber;
+    clamped: z.ZodBoolean;
+    coordinateSystem: z.ZodLiteral<"wall-local-meters">;
+    message: z.ZodString;
+    achieved: z.ZodObject<{
+        created: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        updated: z.ZodNumber;
+        deleted: z.ZodRecord<z.ZodString, z.ZodNumber>;
+        unchanged: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
+    windowId: z.ZodString;
+};
+//# sourceMappingURL=wall-openings.d.ts.map

package/dist/agent-tools/wall-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-openings.d.ts","sourceRoot":"","sources":["../../src/agent-tools/wall-openings.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAwDvB,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0CvB,CAAA;AAED,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA+CzB,CAAA;AAkBD,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;CAA2C,CAAA;AAErE,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;CAI3B,CAAA"}