@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-tools/notation-inventory.js

@@ -0,0 +1,105 @@
+import { z } from 'zod';
+/**
+ * The inventory behind the one-notation rule (`measurement()`, `roofPitch()`), for every set of
+ * contracts that keeps it: core's and each plugin's notation test read their fields through these,
+ * so the rule is enforced the same way wherever a tool is declared.
+ */
+/** The schema inside one optional, nullable, defaulted or preprocessed wrapper, if `schema` is one. */
+function inside(schema) {
+    if (schema instanceof z.ZodOptional ||
+        schema instanceof z.ZodNullable ||
+        schema instanceof z.ZodDefault)
+        return schema.unwrap();
+    // A nested argument some models send as a JSON string, parsed before it is read.
+    if (schema instanceof z.ZodPipe && schema.in instanceof z.ZodTransform)
+        return schema.out;
+}
+/** The schema a field holds once its wrappers are off. */
+function unwrap(schema) {
+    const inner = inside(schema);
+    return inner ? unwrap(inner) : schema;
+}
+/** The field at the end of `steps`, through whichever option of a union has the whole path. */
+function resolve(schema, steps) {
+    if (steps.length === 0)
+        return schema;
+    const inner = unwrap(schema);
+    if (inner instanceof z.ZodUnion)
+        return inner.options.reduce((found, option) => found ?? resolve(option, steps), undefined);
+    if (!(inner instanceof z.ZodObject))
+        return undefined;
+    const [step, ...rest] = steps;
+    const [name, ...arrays] = step.split('[]');
+    let field = inner.shape[name];
+    for (const _ of arrays) {
+        const list = field && unwrap(field);
+        field = list instanceof z.ZodArray ? list.element : undefined;
+    }
+    return field && resolve(field, rest);
+}
+/** The schema of one field of a contract, by its path: `patch.thickness`, `walls[].along[]`. */
+export function fieldSchema(contract, path) {
+    const field = resolve(z.object(contract.input), path.split('.'));
+    if (!field)
+        throw new Error(`${contract.name} has no field ${path}`);
+    return field;
+}
+/**
+ * The paths of the plain numbers a schema takes by name. A number in a list is left out (a point,
+ * a rectangle, an outline), not the named numbers of the objects a list holds; whole numbers
+ * (counts, pages, pixels) are `integer`, not `number`.
+ */
+function namedNumbers(schema, path, named) {
+    const options = schema.anyOf ?? schema.oneOf;
+    if (options)
+        return options.flatMap((option) => namedNumbers(option, path, named));
+    const types = [schema.type ?? []].flat();
+    if (types.includes('number'))
+        return named && !types.includes('string') && schema.const === undefined ? [path] : [];
+    const fields = Object.entries(schema.properties ?? {}).flatMap(([key, field]) => namedNumbers(field, path ? `${path}.${key}` : key, true));
+    const items = schema.items ? namedNumbers(schema.items, `${path}[]`, false) : [];
+    const values = typeof schema.additionalProperties === 'object'
+        ? namedNumbers(schema.additionalProperties, `${path}{}`, true)
+        : [];
+    return [...fields, ...items, ...values];
+}
+/**
+ * Every number the contracts take by name as a bare number, as `tool.path`: what is neither a
+ * `measurement()` nor a `roofPitch()`. Each must be a coordinate, a fraction or a ratio, which a
+ * notation test lists.
+ */
+export function bareNumberPaths(contracts) {
+    return contracts.flatMap((tool) => namedNumbers(z.toJSONSchema(z.object(tool.input), { io: 'input' }), '', true).map((path) => `${tool.name}.${path}`));
+}
+/** The defaulted fields of a schema, with their paths, at whatever depth of wrappers. */
+function defaults(schema, path) {
+    const own = schema instanceof z.ZodDefault ? [[path, schema]] : [];
+    const wrapped = inside(schema);
+    if (wrapped)
+        return [...own, ...defaults(wrapped, path)];
+    if (schema instanceof z.ZodObject)
+        return Object.entries(schema.shape).flatMap(([key, field]) => defaults(field, path ? `${path}.${key}` : key));
+    if (schema instanceof z.ZodArray)
+        return defaults(schema.element, `${path}[]`);
+    if (schema instanceof z.ZodUnion)
+        return schema.options.flatMap((option) => defaults(option, path));
+    return [];
+}
+/** Whether a description states this default: "Default 18 in.", "default: 6:12", "Default []". */
+function states(description, value) {
+    const said = typeof value === 'object' ? JSON.stringify(value) : String(value);
+    const escaped = said.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    return new RegExp(`\\bdefault:?\\s+${escaped}(?!\\w|\\.\\d)`, 'i').test(description);
+}
+/**
+ * Every defaulted field whose default the model is not shown, as `tool.path`: its input JSON
+ * Schema has no `default` (a field that converts loses it) and its description does not state it.
+ */
+export function unshownDefaultPaths(contracts) {
+    return contracts.flatMap((tool) => defaults(z.object(tool.input), '')
+        .filter(([, field]) => {
+        const json = z.toJSONSchema(field, { io: 'input' });
+        return json.default === undefined && !states(json.description ?? '', field.def.defaultValue);
+    })
+        .map(([path]) => `${tool.name}.${path}`));
+}

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

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const paintTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        targets: z.ZodArray<z.ZodString>;
+        role: z.ZodOptional<z.ZodString>;
+        color: z.ZodOptional<z.ZodString>;
+        material: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            id: z.ZodOptional<z.ZodString>;
+            preset: z.ZodOptional<z.ZodCatch<z.ZodEnum<{
+                brick: "brick";
+                concrete: "concrete";
+                custom: "custom";
+                glass: "glass";
+                marble: "marble";
+                metal: "metal";
+                plaster: "plaster";
+                tile: "tile";
+                white: "white";
+                wood: "wood";
+            }>>>;
+            properties: z.ZodOptional<z.ZodObject<{
+                color: z.ZodDefault<z.ZodString>;
+                roughness: z.ZodDefault<z.ZodNumber>;
+                metalness: z.ZodDefault<z.ZodNumber>;
+                opacity: z.ZodDefault<z.ZodNumber>;
+                transparent: z.ZodDefault<z.ZodBoolean>;
+                side: z.ZodDefault<z.ZodEnum<{
+                    back: "back";
+                    double: "double";
+                    front: "front";
+                }>>;
+            }, z.core.$strip>>;
+            texture: z.ZodOptional<z.ZodObject<{
+                url: z.ZodString;
+                repeat: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+                scale: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>]>>;
+        materialName: z.ZodOptional<z.ZodString>;
+        erase: z.ZodOptional<z.ZodLiteral<true>>;
+    };
+};
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/agent-tools/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvB,eAAO,MAAM,SAAS;IACpB,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,OAAO;QACP,IAAI;QACJ,KAAK;QAKL,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAMR,YAAY;QASZ,KAAK;;CAER,CAAA"}

package/dist/agent-tools/paint.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { MaterialSchema } from '../schema/material.js';
+import { NodeId } from './node-id.js';
+export const paintTool = {
+    name: 'paint',
+    title: 'Paint',
+    description: "Give walls, slabs, ceilings, roofs, columns, fences, doors, windows, stairs, blocks, cabinets, shelves, items and the other built parts a finish in one call, as the editor's Paint does. Give one finish: color (#rrggbb, painted with the nearest of the library's flat colours, said with how near); material, a library:<id> (find it with search_materials) or scene:<id> ref, or a native material {properties: {color, roughness, metalness}} for an exact finish, kept as a scene material (materialName names a new one) and reused when the scene holds an equal one; or erase: true, back to the surface's default. role picks the surface: a wall's face a or b, or exterior and interior (the faces turned out of its rooms or into them, else by its stored sides; a partition is interior on both; a wall whose sides are unknown, or with rooms along only part of a face, is refused: name its face, a or b), its trims aSkirting, bSkirting, aCrown, bCrown, aChairRail, bChairRail (skirting, crown or chairRail: that trim on both faces), a curtain wall's curtain-frame, curtain-glass, curtain-solid; a slab's surface, side, edge, riser, underside or foundation; a ceiling's surface; a roof's top (the covering), edge (the gable ends and the trim band), wall (the soffit and the deck edge, and the fascia and rake boards unless they have their own) or fascia (the fascia and rake boards, a fascia band); a glazed roof's glazing-frame, glazing-glass or glazing-solid; a column's shaft, base, capital or frame; a fence's posts, infill, base or rail; a door's panel, frame, glass or hardware; a window's frame or glass; a stair's treads, body or railing; a block's body; a cabinet's front, carcass, countertop, plinth, hardware or glass; another part's own slots, which a refusal names; an item's surfaces by the names its model gives them (its painted ones are in get_node's slots), which paint cannot check. Without a role: both faces of a wall, a slab's or a ceiling's surface, a roof's top, a glazed roof's frame and solid panels, a column's shaft, a whole fence, a door's panel and frame, a window's frame, a block's body, a part's one surface. A roof shows one finish per surface: a segment's finish goes on its roof, and a roof's on all of its segments. A glazed segment holds its own glazing finishes: a roof's glazing roles go on its glazed segments, its other roles on the roof, and without a role both. A wall face is painted whole, over the wall finish of the room it faces; its painted parts keep their own, named in the note. A ceiling shows its finish's colour, not its texture. The result says the finish written, and the scene material when there is one. A target that is not in the scene, a role it lacks or an unknown material refuses the whole call: nothing is painted.",
+    input: {
+        targets: z.array(NodeId).min(1).max(200).describe('The nodes to paint.'),
+        role: z.string().min(1).optional().describe('The surface: see the description.'),
+        color: z
+            .string()
+            .regex(/^#[0-9a-fA-F]{6}$/)
+            .optional()
+            .describe('A colour, #rrggbb: painted with the nearest library colour.'),
+        material: z
+            .union([z.string().min(1), MaterialSchema])
+            .optional()
+            .describe('A library:<id> or scene:<id> ref, or a native material (properties color, roughness, metalness, and an existing texture) kept as a scene material.'),
+        materialName: z
+            .string()
+            .trim()
+            .min(1)
+            .max(120)
+            .optional()
+            .describe('The name of a new native material; an equal one already in the scene keeps its own.'),
+        erase: z.literal(true).optional().describe("Back to the surface's default."),
+    },
+};

package/dist/agent-tools/photo-elevation.d.ts

@@ -0,0 +1,32 @@
+import { z } from 'zod';
+export declare const straightenFacadePhotoTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        source: z.ZodString;
+        faces: z.ZodArray<z.ZodObject<{
+            name: z.ZodOptional<z.ZodString>;
+            wallIds: z.ZodArray<z.ZodString>;
+            edges: z.ZodObject<{
+                left: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+                right: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+            }, z.core.$strip>;
+            rows: z.ZodArray<z.ZodObject<{
+                levelId: z.ZodString;
+                points: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+                height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            }, z.core.$strip>>;
+            points: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                along: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+                height: z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
+                levelId: z.ZodOptional<z.ZodString>;
+                point: z.ZodArray<z.ZodNumber>;
+            }, z.core.$strip>>>;
+            lines: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber>>>>;
+        }, z.core.$strip>>;
+        focal35mm: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        verticals: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodArray<z.ZodNumber>>>>;
+    };
+};
+//# sourceMappingURL=photo-elevation.d.ts.map

package/dist/agent-tools/photo-elevation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"photo-elevation.d.ts","sourceRoot":"","sources":["../../src/agent-tools/photo-elevation.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAWvB,eAAO,MAAM,yBAAyB;IACpC,IAAI;IACJ,KAAK;IACL,WAAW;IAEX,KAAK;QACH,MAAM;QACN,KAAK;;;;;;;;;;;;;;;;;;;;QAgEL,SAAS;QAMT,SAAS;;CAQZ,CAAA"}

package/dist/agent-tools/photo-elevation.js

@@ -0,0 +1,73 @@
+import { z } from 'zod';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const fraction = z.number().min(0).max(1);
+const point = z
+    .array(fraction)
+    .length(2)
+    .describe('A point of the photo as [across, down], fractions of its width and height (0 to 1).');
+const segment = z.array(point).length(2);
+export const straightenFacadePhotoTool = {
+    name: 'straighten_facade_photo',
+    title: 'Straighten a facade photo',
+    description: "Straighten faces of a building photo into elevations at a known scale, to measure the facade instead of guessing it: bay pitch, pier and window widths, pane grids, side panels, spandrels, sill and head heights. Pass every face the photo shows in one call: they share the photo's camera, found from the lines picked on them, so each elevation is metric from its walls' width and the storey height is measured from the photo rather than taken from the scene. Per face: its vertical edges (two points on each, top and bottom as seen), the same feature on at least two storeys (the window heads of a low and a high floor, say: two points far apart along each, with that storey's level), and the face's walls on one storey (their extent is the width). A face whose far edge leaves the photo gives only the corner it shares with another face. Points are fractions of the photo, [0,0] its top left and [1,1] its bottom right. Returns per face the straightened elevation with a metre grid and the scene's storeys drawn at the picked feature, a close-up of each picked corner to check (call again with corrected points if one is off), the photo pixels per metre at each side, the fit error and the photo's storey height beside the scene's; and the camera: its focal length (a phone's main camera is about 26 mm), its tilt, what it assumes, and its pose in the scene (position, target, up, vertical fov, the photo's aspect): view_scene from that pose shows the scene as the photo does. One face seen square on (a frontal photo) gives a pose too, its focal length taken from focal35mm when it cannot be read from the photo. A single face with both edges is fitted from its own picks, its heights from the storeys. Only what lies on the wall plane measures true: balconies, overhangs and anything standing proud are smeared, and a face seen at a grazing angle has too few pixels per metre for panes.",
+    input: {
+        source: z.string().describe("The photo: its attachment URL, as the user's message gives it."),
+        faces: z
+            .array(z.object({
+            name: z.string().optional().describe('What the face is, e.g. "east, corner to recess".'),
+            wallIds: z
+                .array(NodeId)
+                .min(1)
+                .max(32)
+                .describe('The walls of this face on one storey, end to end (get_walls).'),
+            edges: z
+                .object({ left: segment.optional(), right: segment.optional() })
+                .describe('Two points on each vertical edge of the face as seen in the photo. When its far edge leaves the photo, give only the corner it shares with another face of this call, picked the same on both: the shared camera places the face from that corner, and its walls give the rest of its width.'),
+            rows: z
+                .array(z.object({
+                levelId: NodeId,
+                points: segment,
+                height: measurement('length', 'm', {
+                    min: 0,
+                    max: 20,
+                    description: "The feature's height above that storey's floor when you know it (window heads about 2.1 m): it sets the camera's height. With heights, two rows on one storey are enough (the floor line at 0 and the eaves at the wall's height), which a single-storey house needs. Without it the edges' foot is taken for the ground.",
+                }).optional(),
+            }))
+                .min(2)
+                .max(8)
+                .describe('The same feature on several storeys (window heads, spandrel tops): two points far apart along it on each, and the level it belongs to. Their lines meet where the face recedes, which fixes the camera: long lines on storeys far apart hold it steadier.'),
+            points: z
+                .array(z.object({
+                along: measurement('length', 'm', {
+                    description: "Metres along the face from its left end as seen (the walls' extent).",
+                }),
+                height: measurement('length', 'm', {
+                    description: 'Metres up from the floor of levelId.',
+                }),
+                levelId: NodeId.optional().describe("The floor it is measured from. Default: the face walls'."),
+                point: point,
+            }))
+                .max(40)
+                .optional()
+                .describe("Points at places you know on the face: a window's or a door's corners from the scene (get_walls), an eave's end. On one face seen square on they steady the camera's pose most: two edges and two lines alone move it metres for a few pixels of error."),
+            lines: z
+                .array(segment)
+                .max(8)
+                .optional()
+                .describe('More horizontal lines on this face, no level needed: sills, heads, spandrel or storey lines, two points far apart along each. They steady the camera: on two short rows a pick a pixel off can move a measure by several per cent, with two more lines it stays within a few.'),
+        }))
+            .min(1)
+            .max(4),
+        focal35mm: measurement('length', 'mm', {
+            min: 8,
+            max: 800,
+            description: "The camera's focal length on a 36 × 24 mm frame, when you know it (the photo's metadata, or a render's camera): a face seen square on does not show it, and the pose then takes a phone's 26 mm and says so (focalAssumed).",
+        }).optional(),
+        verticals: z
+            .array(segment)
+            .max(12)
+            .optional()
+            .describe("Vertical lines on the building besides the face edges (pier sides, window jambs, another corner), two points far apart on each. They give the camera's tilt and roll more surely than the face edges alone."),
+    },
+};

package/dist/agent-tools/place-in-room.d.ts

@@ -0,0 +1,35 @@
+import { z } from 'zod';
+export declare const placeInRoomTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        assetId: z.ZodString;
+        zoneId: z.ZodOptional<z.ZodString>;
+        polygon: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodNumber>>>;
+        edge: z.ZodOptional<z.ZodNumber>;
+        rotationDeg: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        facing: z.ZodOptional<z.ZodEnum<{
+            in: "in";
+            out: "out";
+        }>>;
+        align: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            end: "end";
+            start: "start";
+        }>>;
+        offset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        inset: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        clearanceAreas: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            minX: z.ZodNumber;
+            maxX: z.ZodNumber;
+            minZ: z.ZodNumber;
+            maxZ: z.ZodNumber;
+        }, z.core.$strip>>>;
+        allowDuplicate: z.ZodOptional<z.ZodBoolean>;
+    };
+};
+//# sourceMappingURL=place-in-room.d.ts.map

package/dist/agent-tools/place-in-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-in-room.d.ts","sourceRoot":"","sources":["../../src/agent-tools/place-in-room.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmE3B,CAAA"}

package/dist/agent-tools/place-in-room.js

@@ -0,0 +1,61 @@
+import { z } from 'zod';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+export const placeInRoomTool = {
+    name: 'place_in_room',
+    title: 'Place an item in a room',
+    description: 'Put one floor-standing catalog item in a room where it fits, without working out a position. Wall/ceiling-attached assets need a host: place_items accepts targetNodeId and, for a wall, y for the bottom height. A wall-bound floor piece (fridge, counter, stove, sink, TV stand, dresser, wardrobe, sofa, bed, bedside table, toilet, bath, shower, bookcase, cabinet) stands against a wall, centred in the widest free stretch of that wall (clear of every door and every other item), its front toward the room; it is never put in the middle, and when no wall has room the answer says how wide the widest free stretch is. A free-standing piece (dining table, rug, coffee table, plant, armchair) takes the middle of the room, or goes with what it belongs with: a coffee table and an armchair face the sofa. A chair goes around its table, one call per chair, facing the table, and is refused when the room has no table. Explicit edge, align, offset or inset instead requests a wall free run for any floor piece. Name the room by its zoneId (create_room, get_zones), or by its polygon and level. The item is a catalog id from search_assets. To furnish a whole room by its type in one call, use furnish_room.',
+    input: {
+        assetId: z.string().min(1).describe('A known catalog id; search_assets can find it.'),
+        zoneId: NodeId.optional().describe('The room: zoneId from create_room, or an id from get_zones.'),
+        ...levelTarget,
+        polygon: z
+            .array(z.array(z.number()).length(2))
+            .min(3)
+            .optional()
+            .describe("The room's corners as [x, z] in metres, when there is no zoneId."),
+        edge: z
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe('Stand it against this polygon edge (i → i + 1) instead of the best one.'),
+        rotationDeg: measurement('angle', 'deg', {
+            description: 'World yaw in degrees, overriding the automatic inward, group or table-facing yaw.',
+        }).optional(),
+        facing: z
+            .enum(['in', 'out'])
+            .optional()
+            .describe('In by default. Out adds 180 degrees after any explicit rotationDeg.'),
+        align: z
+            .enum(['center', 'start', 'end'])
+            .optional()
+            .describe('Desired wall alignment, clamped into a valid free run. Defaults to the widest run’s center.'),
+        offset: measurement('length', 'm', {
+            description: 'Signed metres along the wall from the desired alignment; defaults to zero.',
+        }).optional(),
+        inset: measurement('length', 'm', {
+            description: 'Normal gap in metres between the rotated footprint and the wall centerline; defaults to 0.1 m.',
+        }).optional(),
+        clearanceAreas: z
+            .array(z
+            .object({
+            id: z.string().min(1),
+            minX: z.number().finite(),
+            maxX: z.number().finite(),
+            minZ: z.number().finite(),
+            maxZ: z.number().finite(),
+        })
+            .refine((area) => area.minX <= area.maxX && area.minZ <= area.maxZ, {
+            message: 'Clearance rectangles must have minX <= maxX and minZ <= maxZ.',
+        }))
+            .max(128)
+            .optional()
+            .describe('Existing clearance rectangles, in world metres, to keep free before placing.'),
+        allowDuplicate: z
+            .boolean()
+            .optional()
+            .describe('Place it even though the room already has this item. Off by default (a second toilet or stove is a mistake); chairs are always allowed.'),
+    },
+};

package/dist/agent-tools/place-items.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const placeItemsTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        items: z.ZodArray<z.ZodObject<{
+            assetId: z.ZodString;
+            x: z.ZodNumber;
+            z: z.ZodNumber;
+            y: z.ZodOptional<z.ZodNumber>;
+            targetNodeId: z.ZodOptional<z.ZodString>;
+            rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        }, z.core.$strip>>;
+    };
+};
+//# sourceMappingURL=place-items.d.ts.map

package/dist/agent-tools/place-items.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"place-items.d.ts","sourceRoot":"","sources":["../../src/agent-tools/place-items.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAKvB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;CA+B1B,CAAA"}

package/dist/agent-tools/place-items.js

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+export const placeItemsTool = {
+    name: 'place_items',
+    title: 'Place items',
+    description: 'Place one or more catalog items (furniture, fixtures, plants, art, lights) in one call. Each assetId is a known catalog id, available from search_assets results or existing scene item data, never guessed. Positions are level (x, z) metres. An item stands on the floor of the level, or on the host it names (targetNodeId): a wall (art, a sconce: y is the height of its bottom above the floor, required; it goes on the side of the wall the point is on), a ceiling (a pendant, a downlight: it hangs flush under it), or an item standing on the floor (a lamp on a nightstand: it rests on its top; on an object built with add_object it rests on the real surface under the point, such as a porch landing, or a ceiling item hangs from the underside above it, such as a sloped vault, and the result names it in restingOn). A room, a slab or a level as the target means its floor. Each item is placed or refused on its own (asset_not_found; outside_rooms: an indoor item on the floor outside every room of a level that has rooms — garden and outdoor items may stand outside; height_required, item_too_tall, unsupported_host, host_not_found, host_not_on_level; blocks_door: a floor item standing where a door needs space, with a spot in its room that clears every door; too_large_for_room: a floor item its room cannot hold in any turn).',
+    input: {
+        items: z
+            .array(z.object({
+            assetId: z.string().min(1).describe('A known catalog id; search_assets can find it.'),
+            x: z.number().describe('X in level coordinates (metres).'),
+            z: z.number().describe('Z in level coordinates (metres).'),
+            y: z
+                .number()
+                .optional()
+                .describe("Height above the floor (metres): on a wall, of the item's bottom (required: art centred at eye level is 1.5 − its height / 2, a sconce about 1.5); on an item, a resting height you set rather than its top. Not used on a floor or a ceiling."),
+            targetNodeId: NodeId.optional().describe("The host: a wall, a ceiling or an item standing on the floor; a room, a slab or a level means its floor. Default: the level's floor."),
+            rotation: measurement('angle', 'deg', {
+                description: 'Turn about the vertical (default 0).',
+            }).optional(),
+        }))
+            .min(1)
+            .max(64)
+            .describe('The items to place.'),
+        ...levelTarget,
+    },
+};

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

@@ -0,0 +1,189 @@
+import { z } from 'zod';
+export declare const getProjectAssetsTool: {
+    readonly name: 'get_project_assets';
+    readonly title: 'List project files';
+    readonly 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.';
+    readonly input: {
+        readonly projectId: z.ZodOptional<z.ZodString>;
+        readonly type: z.ZodOptional<z.ZodEnum<{
+            document: "document";
+            guide: "guide";
+            image: "image";
+            other: "other";
+            scan: "scan";
+        }>>;
+        readonly query: z.ZodOptional<z.ZodString>;
+        readonly cursor: z.ZodOptional<z.ZodString>;
+        readonly limit: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+};
+export declare const getProjectFileTool: {
+    readonly name: 'get_project_file';
+    readonly title: 'Read project file';
+    readonly 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.';
+    readonly input: {
+        projectId: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodString;
+    };
+    readonly annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+};
+export declare const uploadProjectFileTool: {
+    readonly name: 'upload_project_file';
+    readonly title: 'Upload project file';
+    readonly 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.';
+    readonly input: {
+        readonly projectId: z.ZodOptional<z.ZodString>;
+        readonly phase: z.ZodEnum<{
+            complete: "complete";
+            prepare: "prepare";
+            text: "text";
+        }>;
+        readonly name: z.ZodString;
+        readonly mimeType: z.ZodString;
+        readonly content: z.ZodOptional<z.ZodString>;
+        readonly size: z.ZodOptional<z.ZodNumber>;
+        readonly fileId: z.ZodOptional<z.ZodString>;
+        readonly storageKey: z.ZodOptional<z.ZodString>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: false;
+        readonly idempotentHint: false;
+        readonly openWorldHint: false;
+    };
+};
+export declare const renameProjectFileTool: {
+    readonly name: 'rename_project_file';
+    readonly title: 'Rename project file';
+    readonly description: 'Rename a file in the project catalog. The file ID and content URL stay stable; a Studio file is also renamed in Studio.';
+    readonly input: {
+        readonly projectId: z.ZodOptional<z.ZodString>;
+        readonly fileId: z.ZodString;
+        readonly name: z.ZodString;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: true;
+        readonly idempotentHint: true;
+        readonly openWorldHint: false;
+    };
+};
+export declare const deleteProjectFileTool: {
+    readonly name: 'delete_project_file';
+    readonly title: 'Delete project file';
+    readonly 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.';
+    readonly input: {
+        projectId: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodString;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: true;
+        readonly idempotentHint: true;
+        readonly openWorldHint: false;
+    };
+};
+export declare const PROJECT_FILE_TOOL_CONTRACTS: readonly [{
+    readonly name: 'get_project_assets';
+    readonly title: 'List project files';
+    readonly 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.';
+    readonly input: {
+        readonly projectId: z.ZodOptional<z.ZodString>;
+        readonly type: z.ZodOptional<z.ZodEnum<{
+            document: "document";
+            guide: "guide";
+            image: "image";
+            other: "other";
+            scan: "scan";
+        }>>;
+        readonly query: z.ZodOptional<z.ZodString>;
+        readonly cursor: z.ZodOptional<z.ZodString>;
+        readonly limit: z.ZodOptional<z.ZodNumber>;
+    };
+    readonly annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+}, {
+    readonly name: 'get_project_file';
+    readonly title: 'Read project file';
+    readonly 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.';
+    readonly input: {
+        projectId: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodString;
+    };
+    readonly annotations: {
+        readOnlyHint: boolean;
+        destructiveHint: boolean;
+        idempotentHint: boolean;
+        openWorldHint: boolean;
+    };
+}, {
+    readonly name: 'upload_project_file';
+    readonly title: 'Upload project file';
+    readonly 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.';
+    readonly input: {
+        readonly projectId: z.ZodOptional<z.ZodString>;
+        readonly phase: z.ZodEnum<{
+            complete: "complete";
+            prepare: "prepare";
+            text: "text";
+        }>;
+        readonly name: z.ZodString;
+        readonly mimeType: z.ZodString;
+        readonly content: z.ZodOptional<z.ZodString>;
+        readonly size: z.ZodOptional<z.ZodNumber>;
+        readonly fileId: z.ZodOptional<z.ZodString>;
+        readonly storageKey: z.ZodOptional<z.ZodString>;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: false;
+        readonly idempotentHint: false;
+        readonly openWorldHint: false;
+    };
+}, {
+    readonly name: 'rename_project_file';
+    readonly title: 'Rename project file';
+    readonly description: 'Rename a file in the project catalog. The file ID and content URL stay stable; a Studio file is also renamed in Studio.';
+    readonly input: {
+        readonly projectId: z.ZodOptional<z.ZodString>;
+        readonly fileId: z.ZodString;
+        readonly name: z.ZodString;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: true;
+        readonly idempotentHint: true;
+        readonly openWorldHint: false;
+    };
+}, {
+    readonly name: 'delete_project_file';
+    readonly title: 'Delete project file';
+    readonly 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.';
+    readonly input: {
+        projectId: z.ZodOptional<z.ZodString>;
+        fileId: z.ZodString;
+    };
+    readonly annotations: {
+        readonly readOnlyHint: false;
+        readonly destructiveHint: true;
+        readonly idempotentHint: true;
+        readonly openWorldHint: false;
+    };
+}];
+export type ProjectFileToolName = (typeof PROJECT_FILE_TOOL_CONTRACTS)[number]['name'];
+//# sourceMappingURL=project-files.d.ts.map