@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/construction-tools.js

@@ -1,21 +1,11 @@
-import { resolveStairTotalRise } from '@pascal-app/core';
-import { CeilingNode, getActiveRoofHeight, LevelNode, RoofNode, RoofSegmentNode, SlabNode, StairNode, StairSegmentNode, WallNode, } from '@pascal-app/core/schema';
+import { createZone, generateId } from '@pascal-app/core';
+import { roofLevelRefusal, unknownMaterialPresetRefusal } from '@pascal-app/core/agent-operations';
 import { z } from 'zod';
-import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { ADDITIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult } from './errors.js';
 import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
 import { measurement } from './measurement.js';
-import { NodeIdSchema, Vec2Schema, Vec3Schema } from './schemas.js';
-const ROOF_TYPES = [
-    'hip',
-    'gable',
-    'shed',
-    'gambrel',
-    'dutch',
-    'mansard',
-    'flat',
-    'conical',
-];
-const RAILING_MODES = ['none', 'left', 'right', 'both'];
+import { NodeIdSchema, Vec2Schema } from './schemas.js';
 export const createStoryShellInput = {
     levelId: NodeIdSchema,
     footprint: z.array(Vec2Schema).min(3),
@@ -27,9 +17,17 @@ export const createStoryShellInput = {
         positive: true,
         description: 'Wall thickness.',
     }).default(0.16),
-    createSlab: z.boolean().default(true),
-    createCeiling: z.boolean().default(true),
-    slabElevation: measurement('length', 'm', { description: 'Slab elevation.' }).default(0.1),
+    createSlab: z
+        .boolean()
+        .default(true)
+        .describe('Floor intent for the rooms inside the shell. False records hasFloor: false.'),
+    createCeiling: z
+        .boolean()
+        .default(true)
+        .describe('Ceiling intent for the rooms inside the shell. False records hasCeiling: false.'),
+    slabElevation: measurement('length', 'm', {
+        description: "Walking surface of the derived plate, stored as the room's floor elevation.",
+    }).default(0.1),
     ceilingHeight: measurement('length', 'm', {
         positive: true,
         description: 'Ceiling height.',
@@ -42,86 +40,15 @@ export const createStoryShellInput = {
 export const createStoryShellOutput = {
     levelId: z.string(),
     wallIds: z.array(z.string()),
+    /** Zones the reconciler derived for the enclosed faces. */
+    zoneIds: z.array(z.string()),
+    /** Derived floor plate. `null` when floors were declined or nothing reconciled. */
     slabId: z.string().nullable(),
+    /** Derived ceiling. `null` when ceilings were declined or nothing reconciled. */
     ceilingId: z.string().nullable(),
     createdIds: z.array(z.string()),
     ...liveSyncOutput,
 };
-export const createRoofInput = {
-    levelId: NodeIdSchema,
-    roofLevelId: NodeIdSchema.optional(),
-    useDedicatedRoofLevel: z.boolean().default(true),
-    roofLevelLabel: z.string().default('Roof'),
-    // A level ordinal (story index), not a length — kept numeric.
-    roofLevelElevation: z.number().optional(),
-    roofLevelHeight: measurement('length', 'm', {
-        positive: true,
-        description: 'Roof level height.',
-    }).optional(),
-    center: Vec3Schema.optional(),
-    width: measurement('length', 'm', { positive: true, description: 'Roof width.' }),
-    depth: measurement('length', 'm', { positive: true, description: 'Roof depth.' }),
-    roofType: z.enum(ROOF_TYPES).default('hip'),
-    pitch: measurement('angle', 'deg', { min: 0, max: 85, description: 'Roof pitch.' }).default(35),
-    wallHeight: measurement('length', 'm', { min: 0, description: 'Knee-wall height.' }).default(0.35),
-    wallThickness: measurement('length', 'm', {
-        positive: true,
-        description: 'Wall thickness.',
-    }).default(0.16),
-    overhang: measurement('length', 'm', { min: 0, description: 'Eave overhang.' }).default(0.45),
-    materialPreset: z.string().optional(),
-    name: z.string().optional(),
-};
-export const createRoofOutput = {
-    referenceLevelId: z.string(),
-    roofLevelId: z.string(),
-    createdRoofLevelId: z.string().nullable(),
-    roofId: z.string(),
-    roofSegmentId: z.string(),
-    ...liveSyncOutput,
-};
-export const createStairBetweenLevelsInput = {
-    fromLevelId: NodeIdSchema,
-    toLevelId: NodeIdSchema,
-    position: Vec3Schema,
-    rotation: measurement('angle', 'rad', { description: 'Y-axis rotation.' }).default(0),
-    width: measurement('length', 'm', { positive: true, description: 'Stair width.' }).default(1),
-    runLength: measurement('length', 'm', {
-        positive: true,
-        description: 'Horizontal run length.',
-    }).default(3),
-    totalRise: measurement('length', 'm', {
-        positive: true,
-        description: 'Total vertical rise.',
-    }).optional(),
-    stepCount: z.number().int().positive().default(14),
-    railingMode: z.enum(RAILING_MODES).default('both'),
-    destinationSlabId: NodeIdSchema.optional(),
-    sourceCeilingId: NodeIdSchema.optional(),
-    createDestinationSlabOpening: z.boolean().default(true),
-    createSourceCeilingOpening: z.boolean().default(true),
-    openingWidth: measurement('length', 'm', {
-        positive: true,
-        description: 'Floor opening width.',
-    }).optional(),
-    openingLength: measurement('length', 'm', {
-        positive: true,
-        description: 'Floor opening length.',
-    }).optional(),
-    openingOffset: measurement('length', 'm', { min: 0, description: 'Opening offset.' }).default(0),
-    openingCenter: Vec2Schema.optional(),
-    openingRotation: measurement('angle', 'rad', { description: 'Opening rotation.' }).optional(),
-    materialPreset: z.string().optional(),
-    name: z.string().optional(),
-};
-export const createStairBetweenLevelsOutput = {
-    stairId: z.string(),
-    stairSegmentId: z.string(),
-    destinationSlabId: z.string().nullable(),
-    sourceCeilingId: z.string().nullable(),
-    openingPolygon: z.array(Vec2Schema),
-    ...liveSyncOutput,
-};
 function textResult(payload) {
     return {
         content: [{ type: 'text', text: JSON.stringify(payload) }],
@@ -136,310 +63,124 @@ function assertNode(bridge, id, type) {
         throw new Error(`Node ${id} is a ${node.type}, expected ${type}`);
     return node;
 }
-function getBuildingIdForLevel(bridge, levelId) {
-    const building = bridge.getAncestry(levelId).find((node) => node.type === 'building');
-    if (!building) {
-        throw new Error(`Building ancestor not found for level: ${levelId}`);
-    }
-    return building.id;
+/** Room zones that appeared on the level while this tool call ran. */
+function newRoomZoneIds(bridge, levelId, before) {
+    return Object.values(bridge.getNodes())
+        .filter((node) => node.type === 'zone' &&
+        node.parentId === levelId &&
+        node.spaceRole === 'room' &&
+        !before.has(node.id))
+        .map((node) => node.id)
+        .sort();
 }
-function isRoofLevel(level) {
-    return (level.type === 'level' &&
-        typeof level.metadata === 'object' &&
-        level.metadata !== null &&
-        'role' in level.metadata &&
-        level.metadata.role === 'roof');
-}
-function nextLevelIndex(bridge, buildingId, referenceLevel) {
-    const existing = bridge
-        .getChildren(buildingId)
-        .filter((node) => node.type === 'level')
-        .map((level) => level.level);
-    const referenceIndex = referenceLevel.type === 'level' ? referenceLevel.level : 0;
-    const candidate = referenceIndex + 1;
-    return existing.includes(candidate) ? Math.max(candidate, ...existing) + 1 : candidate;
-}
-function nodesOnLevel(bridge, levelId) {
-    return Object.values(bridge.getNodes()).filter((node) => node.id !== levelId && bridge.resolveLevelId(node.id) === levelId);
-}
-function firstNodeOnLevel(bridge, levelId, type) {
-    return nodesOnLevel(bridge, levelId).find((node) => node.type === type) ?? null;
-}
-function rotatePoint(x, z, rotation) {
-    const cos = Math.cos(rotation);
-    const sin = Math.sin(rotation);
-    return [x * cos + z * sin, -x * sin + z * cos];
-}
-function rectangularOpening(args) {
-    const width = args.width + args.offset * 2;
-    const length = args.length + args.offset * 2;
-    const center = args.center ?? [
-        args.position[0],
-        args.position[2] + args.length / 2,
-    ];
-    const rotation = args.openingRotation ?? args.rotation;
-    const halfW = width / 2;
-    const halfL = length / 2;
-    const local = [
-        [-halfW, -halfL],
-        [halfW, -halfL],
-        [halfW, halfL],
-        [-halfW, halfL],
-    ];
-    return local.map(([x, z]) => {
-        const [rx, rz] = rotatePoint(x, z, rotation);
-        return [center[0] + rx, center[1] + rz];
-    });
-}
-function withHole(surface, hole) {
-    return {
-        holes: [...(surface.holes ?? []), hole],
-        holeMetadata: [...(surface.holeMetadata ?? []), { source: 'manual' }],
-    };
+function derivedShellSurfaces(bridge, levelId, zoneIds) {
+    const children = Object.values(bridge.getNodes()).filter((node) => node.parentId === levelId);
+    const plate = children
+        .filter((node) => node.type === 'slab')
+        .sort((a, b) => Number(a.plateRole === 'base') - Number(b.plateRole === 'base'))
+        .find((node) => node.type === 'slab' &&
+        node.boundary === 'auto' &&
+        (node.zoneIds ?? []).some((id) => zoneIds.includes(id)));
+    const ceiling = children.find((node) => node.type === 'ceiling' && node.boundary === 'auto' && zoneIds.includes(node.zoneId ?? ''));
+    return { slabId: plate?.id ?? null, ceilingId: ceiling?.id ?? null };
 }
 export function registerConstructionTools(server, bridge) {
     server.registerTool('create_story_shell', {
         title: 'Create story shell',
-        description: 'Create one level-owned building shell from a footprint: perimeter walls plus optional slab and ceiling. Use once per story; do not make first-floor walls span multiple stories.',
-        inputSchema: createStoryShellInput,
-        outputSchema: createStoryShellOutput,
+        description: 'Create one level-owned building shell from a footprint: the perimeter walls. The floor plate and the ceiling are DERIVED from the rooms the walls enclose — never author a slab or a ceiling here, and never pass boundary/autoFromWalls; createSlab / createCeiling / slabElevation are recorded as room intent instead. Use once per story; do not make first-floor walls span multiple stories.',
+        inputSchema: z.object(createStoryShellInput),
+        outputSchema: z.object(createStoryShellOutput),
         annotations: ADDITIVE_TOOL_ANNOTATIONS,
     }, async ({ levelId, footprint, wallHeight, wallThickness, createSlab, createCeiling, slabElevation, ceilingHeight, namePrefix, wallMaterialPreset, slabMaterialPreset, ceilingMaterialPreset, }) => {
-        const level = assertNode(bridge, levelId, 'level');
-        if (isRoofLevel(level)) {
-            throw new Error(`Cannot create a story shell on roof support level ${levelId}; create or choose an occupied story level instead`);
-        }
+        const preset = unknownMaterialPresetRefusal({
+            wallMaterialPreset,
+            slabMaterialPreset,
+            ceilingMaterialPreset,
+        });
+        if (preset)
+            throw new Error(preset);
+        assertNode(bridge, levelId, 'level');
+        const onRoofLevel = roofLevelRefusal(bridge.getNodes(), levelId, 'a story shell');
+        if (onRoofLevel)
+            return refusalResult(onRoofLevel);
         const points = footprint;
-        const wallIds = [];
-        const patches = [];
-        for (let i = 0; i < points.length; i++) {
-            const wall = WallNode.parse({
-                name: namePrefix ? `${namePrefix} Wall ${i + 1}` : undefined,
-                start: points[i],
-                end: points[(i + 1) % points.length],
+        const before = new Set(Object.keys(bridge.getNodes()));
+        const plan = createZone(bridge.getNodes(), {
+            levelId,
+            polygon: points,
+            name: namePrefix ?? 'Room',
+            enclose: true,
+            mintId: generateId,
+            wall: {
                 thickness: wallThickness,
                 ...(wallHeight !== undefined ? { height: wallHeight } : {}),
-                frontSide: 'exterior',
-                backSide: 'interior',
-                ...(wallMaterialPreset ? { materialPreset: wallMaterialPreset } : {}),
-                metadata: { role: 'exterior', storyShell: true },
-            });
-            wallIds.push(wall.id);
-            patches.push({ op: 'create', node: wall, parentId: levelId });
-        }
-        let slabId = null;
-        if (createSlab) {
-            const slab = SlabNode.parse({
-                name: namePrefix ? `${namePrefix} Slab` : undefined,
-                polygon: points,
-                elevation: slabElevation,
-                // Grounded solid: underside on the level plane, so the created
-                // story slab occupies [0, slabElevation] like the legacy
-                // extrude-from-zero model.
-                thickness: Math.max(slabElevation, 0),
-                recessed: slabElevation < 0,
-                ...(slabMaterialPreset ? { materialPreset: slabMaterialPreset } : {}),
-                metadata: { role: 'story-slab' },
-            });
-            slabId = slab.id;
-            patches.push({ op: 'create', node: slab, parentId: levelId });
-        }
-        let ceilingId = null;
-        if (createCeiling) {
-            // Height-less unless the caller pinned one: a new story ceiling
-            // follows the level top automatically.
-            const explicitCeilingHeight = ceilingHeight ?? wallHeight;
-            const ceiling = CeilingNode.parse({
-                name: namePrefix ? `${namePrefix} Ceiling` : undefined,
-                polygon: points,
-                ...(explicitCeilingHeight !== undefined ? { height: explicitCeilingHeight } : {}),
-                ...(ceilingMaterialPreset ? { materialPreset: ceilingMaterialPreset } : {}),
-                metadata: { role: 'story-ceiling' },
-            });
-            ceilingId = ceiling.id;
-            patches.push({ op: 'create', node: ceiling, parentId: levelId });
-        }
-        const result = bridge.applyPatch(patches);
-        const persistence = await publishLiveSceneSnapshot(bridge, 'create_story_shell');
-        return textResult({
-            levelId,
-            wallIds,
-            slabId,
-            ceilingId,
-            createdIds: result.createdIds,
-            ...persistencePayload(persistence),
-        });
-    });
-    server.registerTool('create_roof', {
-        title: 'Create roof',
-        description: 'Create a roof container with one roof segment. By default creates a dedicated roof level above the reference level so exploded/solo level views can isolate the roof.',
-        inputSchema: createRoofInput,
-        outputSchema: createRoofOutput,
-        annotations: ADDITIVE_TOOL_ANNOTATIONS,
-    }, async ({ levelId, roofLevelId, useDedicatedRoofLevel, roofLevelLabel, roofLevelElevation, roofLevelHeight, center, width, depth, roofType, pitch, wallHeight, wallThickness, overhang, materialPreset, name, }) => {
-        const effectiveWidth = roofType === 'conical' ? Math.max(width, depth) : width;
-        const effectiveDepth = roofType === 'conical' ? effectiveWidth : depth;
-        // Peak height is derived from pitch + footprint + type; we still
-        // need it to size the auto-generated roof level container below.
-        const peakHeight = getActiveRoofHeight({
-            roofType,
-            pitch,
-            width: effectiveWidth,
-            depth: effectiveDepth,
-        });
-        const referenceLevel = assertNode(bridge, levelId, 'level');
-        const patches = [];
-        let targetRoofLevelId = levelId;
-        let createdRoofLevelId = null;
-        if (roofLevelId !== undefined) {
-            const roofLevel = assertNode(bridge, roofLevelId, 'level');
-            if (!isRoofLevel(roofLevel)) {
-                throw new Error(`roofLevelId ${roofLevelId} must reference a dedicated roof level with metadata.role = "roof"; omit roofLevelId to create one automatically`);
-            }
-            targetRoofLevelId = roofLevelId;
-        }
-        else if (useDedicatedRoofLevel && !isRoofLevel(referenceLevel)) {
-            const buildingId = getBuildingIdForLevel(bridge, levelId);
-            const roofLevel = LevelNode.parse({
-                name: roofLevelLabel,
-                level: roofLevelElevation ?? nextLevelIndex(bridge, buildingId, referenceLevel),
-                height: roofLevelHeight ?? Math.max(wallHeight + peakHeight, 0.2),
-                children: [],
-                metadata: {
-                    role: 'roof',
-                    label: roofLevelLabel,
-                    referenceLevelId: levelId,
-                },
-            });
-            targetRoofLevelId = roofLevel.id;
-            createdRoofLevelId = roofLevel.id;
-            patches.push({ op: 'create', node: roofLevel, parentId: buildingId });
-        }
-        const segment = RoofSegmentNode.parse({
-            roofType,
-            width: effectiveWidth,
-            depth: effectiveDepth,
-            wallHeight,
-            pitch,
-            wallThickness,
-            overhang,
-            ...(materialPreset ? { materialPreset } : {}),
-        });
-        const roof = RoofNode.parse({
-            name: name ?? 'Roof',
-            position: center ?? [0, 0, 0],
-            children: [segment.id],
-            ...(materialPreset ? { materialPreset } : {}),
-            metadata: {
-                referenceLevelId: levelId,
-                roofLevelId: targetRoofLevelId,
-            },
-        });
-        bridge.applyPatch([
-            ...patches,
-            { op: 'create', node: roof, parentId: targetRoofLevelId },
-            { op: 'create', node: segment, parentId: roof.id },
-        ]);
-        const persistence = await publishLiveSceneSnapshot(bridge, 'create_roof');
-        return textResult({
-            referenceLevelId: levelId,
-            roofLevelId: targetRoofLevelId,
-            createdRoofLevelId,
-            roofId: roof.id,
-            roofSegmentId: segment.id,
-            ...persistencePayload(persistence),
-        });
-    });
-    server.registerTool('create_stair_between_levels', {
-        title: 'Create stair between levels',
-        description: 'Create a straight stair and a single rectangular manual opening in the destination slab/source ceiling. This disables stair auto-opening mode to avoid duplicate or irregular holes.',
-        inputSchema: createStairBetweenLevelsInput,
-        outputSchema: createStairBetweenLevelsOutput,
-        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
-    }, async ({ fromLevelId, toLevelId, position, rotation, width, runLength, totalRise, stepCount, railingMode, destinationSlabId, sourceCeilingId, createDestinationSlabOpening, createSourceCeilingOpening, openingWidth, openingLength, openingOffset, openingCenter, openingRotation, materialPreset, name, }) => {
-        const fromLevel = assertNode(bridge, fromLevelId, 'level');
-        const toLevel = assertNode(bridge, toLevelId, 'level');
-        if (isRoofLevel(fromLevel) || isRoofLevel(toLevel)) {
-            throw new Error('Roof support levels are not occupied stories; create a separate occupied attic/story level if a stair-accessible attic is required');
-        }
-        const stairDraft = StairNode.parse({
-            name: name ?? 'Stair',
-            position: position,
-            rotation,
-            stairType: 'straight',
-            fromLevelId,
-            toLevelId,
-            slabOpeningMode: 'none',
-            openingOffset,
-            width,
-            ...(totalRise !== undefined ? { totalRise } : {}),
-            stepCount,
-            railingMode,
-            children: [],
-            ...(materialPreset ? { materialPreset } : {}),
-            metadata: {
-                openingManaged: 'manual-rectangular',
             },
-        });
-        const riseNodes = {
-            ...bridge.getNodes(),
-            [fromLevel.id]: {
-                ...fromLevel,
-                children: [...fromLevel.children, stairDraft.id],
+            intent: {
+                floor: { elevation: slabElevation },
+                hasFloor: createSlab,
+                hasCeiling: createCeiling,
             },
-            [stairDraft.id]: stairDraft,
-        };
-        const resolvedTotalRise = resolveStairTotalRise(stairDraft, riseNodes);
-        const segment = StairSegmentNode.parse({
-            segmentType: 'stair',
-            width,
-            length: runLength,
-            height: resolvedTotalRise,
-            stepCount,
-            ...(materialPreset ? { materialPreset } : {}),
         });
-        const stair = { ...stairDraft, children: [segment.id] };
-        const openingPolygon = rectangularOpening({
-            position: position,
-            rotation,
-            width: openingWidth ?? width,
-            length: openingLength ?? runLength,
-            offset: openingOffset,
-            center: openingCenter,
-            openingRotation,
+        const wallIds = plan.changes.flatMap((change) => change.op === 'create' && change.node.type === 'wall' ? [change.node.id] : []);
+        bridge.runAsSingleHistoryStep(() => {
+            bridge.applyPatch(plan.changes.map((change) => change.op === 'create'
+                ? {
+                    ...change,
+                    parentId: change.node.parentId,
+                    node: change.node.type === 'wall'
+                        ? {
+                            ...change.node,
+                            ...(namePrefix
+                                ? { name: `${namePrefix} Wall ${wallIds.indexOf(change.node.id) + 1}` }
+                                : {}),
+                            ...(wallMaterialPreset ? { materialPreset: wallMaterialPreset } : {}),
+                            metadata: { role: 'exterior', storyShell: true },
+                        }
+                        : change.node,
+                }
+                : change));
+            bridge.deriveStructure([levelId]);
         });
-        const patches = [
-            { op: 'create', node: stair, parentId: fromLevelId },
-            { op: 'create', node: segment, parentId: stair.id },
+        const zoneIds = newRoomZoneIds(bridge, levelId, before);
+        // Finishes and an explicit ceiling height stay editable on derived
+        // construction, so they are applied to whatever the reconciler built.
+        const derived = derivedShellSurfaces(bridge, levelId, zoneIds);
+        const explicitCeilingHeight = ceilingHeight ?? wallHeight;
+        const finishes = [
+            ...(derived.slabId && slabMaterialPreset
+                ? [
+                    {
+                        op: 'update',
+                        id: derived.slabId,
+                        data: {
+                            ...(slabMaterialPreset ? { materialPreset: slabMaterialPreset } : {}),
+                        },
+                    },
+                ]
+                : []),
+            ...(derived.ceilingId && (ceilingMaterialPreset || explicitCeilingHeight !== undefined)
+                ? [
+                    {
+                        op: 'update',
+                        id: derived.ceilingId,
+                        data: {
+                            ...(ceilingMaterialPreset ? { materialPreset: ceilingMaterialPreset } : {}),
+                            ...(explicitCeilingHeight !== undefined ? { height: explicitCeilingHeight } : {}),
+                        },
+                    },
+                ]
+                : []),
         ];
-        const destinationSlab = destinationSlabId !== undefined
-            ? assertNode(bridge, destinationSlabId, 'slab')
-            : firstNodeOnLevel(bridge, toLevelId, 'slab');
-        if (createDestinationSlabOpening && destinationSlab?.type === 'slab') {
-            patches.push({
-                op: 'update',
-                id: destinationSlab.id,
-                data: withHole(destinationSlab, openingPolygon),
-            });
-        }
-        const sourceCeiling = sourceCeilingId !== undefined
-            ? assertNode(bridge, sourceCeilingId, 'ceiling')
-            : firstNodeOnLevel(bridge, fromLevelId, 'ceiling');
-        if (createSourceCeilingOpening && sourceCeiling?.type === 'ceiling') {
-            patches.push({
-                op: 'update',
-                id: sourceCeiling.id,
-                data: withHole(sourceCeiling, openingPolygon),
-            });
-        }
-        bridge.applyPatch(patches);
-        const persistence = await publishLiveSceneSnapshot(bridge, 'create_stair_between_levels');
+        if (finishes.length > 0)
+            bridge.applyPatch(finishes);
+        const persistence = await publishLiveSceneSnapshot(bridge, 'create_story_shell');
         return textResult({
-            stairId: stair.id,
-            stairSegmentId: segment.id,
-            destinationSlabId: destinationSlab?.id ?? null,
-            sourceCeilingId: sourceCeiling?.id ?? null,
-            openingPolygon,
+            levelId,
+            wallIds,
+            zoneIds,
+            slabId: derived.slabId,
+            ceilingId: derived.ceilingId,
+            createdIds: Object.keys(bridge.getNodes()).filter((id) => !before.has(id)),
             ...persistencePayload(persistence),
         });
     });

package/dist/tools/create-unit.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import { z } from 'zod';
 import type { SceneOperations } from '../operations/index.js';
 export declare const createUnitInput: {
@@ -6,18 +6,20 @@ export declare const createUnitInput: {
     name: z.ZodString;
     kind: z.ZodOptional<z.ZodDefault<z.ZodEnum<{
         apartment: "apartment";
-        "hotel-room": "hotel-room";
         commercial: "commercial";
         common: "common";
+        "hotel-room": "hotel-room";
     }>>>;
     color: z.ZodOptional<z.ZodString>;
     memberZoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
 };
 export declare const createUnitOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
     persistence: z.ZodOptional<z.ZodObject<{
         status: z.ZodEnum<{
-            unbound: "unbound";
             events_unsupported: "events_unsupported";
+            unbound: "unbound";
         }>;
         warning: z.ZodString;
     }, z.core.$strip>>;

package/dist/tools/create-unit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create-unit.d.ts","sourceRoot":"","sources":["../../src/tools/create-unit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;;;;;;;;;;;CAM3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;CAG5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuBnF"}
+{"version":3,"file":"create-unit.d.ts","sourceRoot":"","sources":["../../src/tools/create-unit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAG7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAMpD,eAAO,MAAM,eAAe;IAC1B,UAAU;IACV,IAAI;IACJ,IAAI;;;;;;IACJ,KAAK;IACL,aAAa;CACd,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;CAG5B,CAAA;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAuBnF"}

package/dist/tools/create-unit.js

@@ -19,8 +19,8 @@ export function registerCreateUnit(server, bridge) {
     server.registerTool('create_unit', {
         title: 'Create unit',
         description: 'Create a named unit in a building, optionally referencing zones across its levels.',
-        inputSchema: createUnitInput,
-        outputSchema: createUnitOutput,
+        inputSchema: z.object(createUnitInput),
+        outputSchema: z.object(createUnitOutput),
         annotations: ADDITIVE_TOOL_ANNOTATIONS,
     }, async ({ buildingId, name, kind, color, memberZoneIds }) => {
         const members = validateUnitMembers(bridge, buildingId, memberZoneIds ?? []);

package/dist/tools/errors.d.ts

@@ -1,9 +1,9 @@
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
+import { ProtocolError, ProtocolErrorCode } from '@modelcontextprotocol/server';
 /**
- * Throw a structured MCP error. The SDK translates `McpError` into a
+ * Throw a structured MCP error. The SDK translates `ProtocolError` into a
  * JSON-RPC error response automatically.
  */
-export declare function throwMcpError(code: ErrorCode, message: string, data?: unknown): never;
+export declare function throwMcpError(code: ProtocolErrorCode, message: string, data?: unknown): never;
 /**
  * Return a non-throwing tool error payload — used for structured failures that
  * we want the client to see inline in `content` rather than as a protocol
@@ -16,5 +16,16 @@ export declare function toolError(message: string, data?: Record<string, unknown
     }[];
     isError: true;
 };
-export { ErrorCode, McpError };
+/**
+ * A core operation's refusal (`AgentRefusal`) as the same `{ error, code, ...details }` answer the
+ * hosted chat returns; anything else is a real failure and is rethrown.
+ */
+export declare function refusalResult(error: unknown): {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError: true;
+};
+export { ProtocolError, ProtocolErrorCode };
 //# sourceMappingURL=errors.d.ts.map

package/dist/tools/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/tools/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,oCAAoC,CAAA;AAExE;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAErF;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,EAAE,IAAI,CAAA;CACd,CAUA;AAED,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAA"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/tools/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA;AAG/E;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,iBAAiB,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,OAAO,GAAG,KAAK,CAE7F;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE,CAAA;IACzC,OAAO,EAAE,IAAI,CAAA;CACd,CAUA;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO;aAlBjC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,EAAE;aAChC,IAAI;EAoBd;AAED,OAAO,EAAE,aAAa,EAAE,iBAAiB,EAAE,CAAA"}