@pascal-app/mcp 1.0.4 → 1.0.6

package/dist/tools/apply-patch.js

@@ -1,8 +1,10 @@
 import { isAgentRefusal } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, McpError, refusalResult, throwMcpError } from './errors.js';
+import { ProtocolError, ProtocolErrorCode, refusalResult, throwMcpError } from './errors.js';
 import './honest-patch-guard.js';
+import './level-height-guard.js';
+import './roof-level-guard.js';
 import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
 import { assertPatchKeepsIdentity, PatchRefusedError, runPatchGuards } from './patch-guards.js';
 import { PatchSchema } from './schemas.js';
@@ -13,14 +15,16 @@ export const applyPatchOutput = {
     appliedOps: z.number(),
     deletedIds: z.array(z.string()),
     createdIds: z.array(z.string()),
+    /** What the server changed in the patch before writing it, one line each. */
+    notes: z.array(z.string()).optional(),
     ...liveSyncOutput,
 };
 export function registerApplyPatch(server, bridge) {
     server.registerTool('apply_patch', {
         title: 'Apply patch',
-        description: "Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls. A create whose id already exists fails the whole patch with node_exists; to replace a node, delete it earlier in the same patch. An update cannot change id or type (identity_change) or object or children (immutable_field); restating the current value is fine. A parentId change must name an existing node that holds children (invalid_parent). An update cannot add schema issues to a node (invalid_update). After a delete or a roof update that regenerates a roof's default gutters, those gutters and their downspouts are addressable only in a later call (regenerated_default). Refusals come back as a tool error whose text is JSON {code, patchIndex, id, message}.",
-        inputSchema: applyPatchInput,
-        outputSchema: applyPatchOutput,
+        description: "Apply a batch of create/update/delete operations atomically. All patches are validated before any are applied; the entire batch forms a single undo step. Batch-first is the default: prefer one apply_patch call containing all create/update/delete ops for a build step, in stable order so later ops can reference ids created by earlier ops. A single call is atomic (all or nothing) and pays the snapshot and save cost once; do not loop one-op calls. A create whose id already exists fails the whole patch with node_exists; to replace a node, delete it earlier in the same patch. An update cannot change id or type (identity_change) or object or children (immutable_field); restating the current value is fine. A parentId change must name an existing node that holds children (invalid_parent). An update cannot add schema issues to a node (invalid_update). After a delete or a roof update that regenerates a roof's default gutters, those gutters and their downspouts are addressable only in a later call (regenerated_default). A roof created or moved onto the storey whose walls carry it goes to the level above them (the roof level over a top storey), said in notes; storey content (walls, zones, slabs, ceilings, items, stairs) on a roof level (roof_level), a walled level declared the roof level (roof_level_holds_storey) and floor indexes putting a roof level under a storey (roof_level_on_top) are refused. Refusals come back as a tool error whose text is JSON {code, patchIndex, id, message}.",
+        inputSchema: z.object(applyPatchInput),
+        outputSchema: z.object(applyPatchOutput),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async ({ patches }) => {
         const bridgePatches = patches.map((p) => {
@@ -45,7 +49,7 @@ export function registerApplyPatch(server, bridge) {
             };
         });
         try {
-            runPatchGuards(bridgePatches, bridge.getNodes());
+            const notes = runPatchGuards(bridgePatches, bridge.getNodes());
             const planDeletion = bridge
                 .planDeletion;
             assertPatchKeepsIdentity(bridgePatches, bridge.getNodes(), bridge.getRootNodeIds(), typeof planDeletion === 'function' ? planDeletion.bind(bridge) : undefined);
@@ -55,6 +59,7 @@ export function registerApplyPatch(server, bridge) {
                 appliedOps: result.appliedOps,
                 deletedIds: result.deletedIds,
                 createdIds: result.createdIds,
+                ...(notes.length ? { notes } : {}),
                 ...persistencePayload(persistence),
             };
             return {
@@ -64,7 +69,7 @@ export function registerApplyPatch(server, bridge) {
         }
         catch (err) {
             if (err instanceof PatchRefusedError) {
-                // A tool error, not an McpError: the SDK keeps only an McpError's
+                // A tool error, not an ProtocolError: the SDK keeps only an ProtocolError's
                 // message, and clients need the code, index and id to act on it.
                 const refusal = {
                     code: err.code,
@@ -80,10 +85,10 @@ export function registerApplyPatch(server, bridge) {
             // A refusal the store made (an accidental wipe) answers with its code, as the shared tools'.
             if (isAgentRefusal(err))
                 return refusalResult(err);
-            if (err instanceof McpError)
+            if (err instanceof ProtocolError)
                 throw err;
             const msg = err instanceof Error ? err.message : String(err);
-            throwMcpError(ErrorCode.InvalidParams, msg);
+            throwMcpError(ProtocolErrorCode.InvalidParams, msg);
         }
     });
 }

package/dist/tools/asset-catalog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/asset-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,EA6RzC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,SAAS,UAAU,EAAE,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc,EAAE,YAA4C,CAAA;AAEzE,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAO9D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEhG"}
+{"version":3,"file":"asset-catalog.d.ts","sourceRoot":"","sources":["../../src/tools/asset-catalog.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAEzD;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,UAAU,EAoTzC,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,CAAC,SAAS,UAAU,EAAE,CAAC,CAAA;AAE/D,eAAO,MAAM,cAAc,EAAE,YAA4C,CAAA;AAEzE,iGAAiG;AACjG,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,YAAY,CAO9D;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,SAAS,UAAU,EAAE,EAAE,EAAE,EAAE,MAAM,GAAG,UAAU,GAAG,SAAS,CAEhG"}

package/dist/tools/asset-catalog.js

@@ -10,6 +10,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'double-bed',
         category: 'furniture',
+        functionTags: ['double-beds'],
         tags: ['floor', 'bedroom'],
         name: 'Double Bed',
         thumbnail: '/items/double-bed/thumbnail.webp',
@@ -22,6 +23,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'single-bed',
         category: 'furniture',
+        functionTags: ['single-beds'],
         tags: ['floor', 'bedroom'],
         name: 'Single Bed',
         thumbnail: '/items/single-bed/thumbnail.webp',
@@ -34,6 +36,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'bedside-table',
         category: 'furniture',
+        functionTags: ['coffee-tables'],
         tags: ['floor', 'bedroom'],
         name: 'Bedside Table',
         thumbnail: '/items/bedside-table/thumbnail.webp',
@@ -47,6 +50,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'dresser',
         category: 'furniture',
+        functionTags: ['dressers'],
         tags: ['floor', 'storage', 'bedroom'],
         name: 'Dresser',
         thumbnail: '/items/dresser/thumbnail.webp',
@@ -60,6 +64,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'closet',
         category: 'furniture',
+        functionTags: ['wardrobes'],
         tags: ['floor', 'storage', 'bedroom'],
         name: 'Closet',
         thumbnail: '/items/closet/thumbnail.webp',
@@ -72,6 +77,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'sofa',
         category: 'furniture',
+        functionTags: ['sofas'],
         tags: ['floor', 'seating', 'living'],
         name: 'Sofa',
         thumbnail: '/items/sofa/thumbnail.webp',
@@ -84,6 +90,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'livingroom-chair',
         category: 'furniture',
+        functionTags: ['armchairs'],
         tags: ['floor', 'seating', 'living'],
         name: 'Livingroom Chair',
         thumbnail: '/items/livingroom-chair/thumbnail.webp',
@@ -96,6 +103,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'coffee-table',
         category: 'furniture',
+        functionTags: ['coffee-tables'],
         tags: ['floor', 'table', 'living'],
         name: 'Coffee Table',
         thumbnail: '/items/coffee-table/thumbnail.webp',
@@ -109,6 +117,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'tv-stand',
         category: 'furniture',
+        functionTags: ['cabinets'],
         tags: ['floor', 'storage', 'living'],
         name: 'TV Stand',
         thumbnail: '/items/tv-stand/thumbnail.webp',
@@ -122,6 +131,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'shelf',
         category: 'furniture',
+        functionTags: ['shelves'],
         tags: ['wall', 'storage'],
         name: 'Shelf',
         thumbnail: '/items/shelf/thumbnail.webp',
@@ -136,6 +146,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'dining-table',
         category: 'furniture',
+        functionTags: ['dining-tables'],
         tags: ['floor', 'table', 'dining'],
         name: 'Dining Table',
         thumbnail: '/items/dining-table/thumbnail.webp',
@@ -149,6 +160,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'dining-chair',
         category: 'furniture',
+        functionTags: ['dining-chairs'],
         tags: ['floor', 'seating', 'dining'],
         name: 'Dining Chair',
         thumbnail: '/items/dining-chair/thumbnail.webp',
@@ -161,6 +173,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'kitchen',
         category: 'kitchen',
+        functionTags: ['cabinets'],
         tags: ['floor', 'large', 'kitchen'],
         name: 'Kitchen',
         thumbnail: '/items/kitchen/thumbnail.webp',
@@ -173,6 +186,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'kitchen-counter',
         category: 'kitchen',
+        functionTags: ['counters'],
         tags: ['floor', 'large', 'storage', 'kitchen'],
         name: 'Kitchen Counter',
         thumbnail: '/items/kitchen-counter/thumbnail.webp',
@@ -186,6 +200,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'stove',
         category: 'kitchen',
+        functionTags: ['kitchen-appliances'],
         tags: ['floor', 'large', 'kitchen'],
         name: 'Stove',
         thumbnail: '/items/stove/thumbnail.webp',
@@ -198,6 +213,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'fridge',
         category: 'kitchen',
+        functionTags: ['kitchen-appliances'],
         tags: ['floor', 'large', 'kitchen'],
         name: 'Fridge',
         thumbnail: '/items/fridge/thumbnail.webp',
@@ -210,6 +226,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'toilet',
         category: 'bathroom',
+        functionTags: ['toilets'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Toilet',
         thumbnail: '/items/toilet/thumbnail.webp',
@@ -222,6 +239,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'bathroom-sink',
         category: 'bathroom',
+        functionTags: ['sinks'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Bathroom Sink',
         thumbnail: '/items/bathroom-sink/thumbnail.webp',
@@ -234,6 +252,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'shower-square',
         category: 'bathroom',
+        functionTags: ['showers'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Squared Shower',
         thumbnail: '/items/shower-square/thumbnail.webp',
@@ -246,6 +265,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'bathtub',
         category: 'bathroom',
+        functionTags: ['bathtubs'],
         tags: ['floor', 'large', 'bathroom'],
         name: 'Bathtub',
         thumbnail: '/items/bathtub/thumbnail.webp',
@@ -258,6 +278,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'washing-machine',
         category: 'bathroom',
+        functionTags: ['laundry-appliances'],
         tags: ['floor', 'large', 'electronics', 'laundry'],
         name: 'Washing Machine',
         thumbnail: '/items/washing-machine/thumbnail.webp',
@@ -270,6 +291,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'drying-rack',
         category: 'bathroom',
+        functionTags: ['laundry-appliances'],
         tags: ['floor', 'laundry'],
         name: 'Drying Rack',
         thumbnail: '/items/drying-rack/thumbnail.webp',
@@ -282,6 +304,7 @@ export const MCP_CATALOG_ITEMS = [
     {
         id: 'coat-rack',
         category: 'furniture',
+        functionTags: ['racks'],
         tags: ['floor', 'storage', 'entry'],
         name: 'Coat Rack',
         thumbnail: '/items/coat-rack/thumbnail.webp',

package/dist/tools/author-scene.d.ts

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import type { SceneOperations } from '../operations/index.js';
+import { type GeometryScriptHost } from './add-object.js';
+/**
+ * `author_scene` on the MCP: every item's module compiled and stored through the host, the
+ * module and the adapter kept as the scene's provenance, the operation applied, Pascal's checks
+ * run, and the gate report answered. Replay is the same payload through the same operation.
+ */
+export declare function registerAuthorScene(server: McpServer, bridge: SceneOperations, host: GeometryScriptHost | undefined): void;
+//# sourceMappingURL=author-scene.d.ts.map

package/dist/tools/author-scene.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"author-scene.d.ts","sourceRoot":"","sources":["../../src/tools/author-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAe7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AACpD,OAAO,EAAmB,KAAK,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAevE;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,MAAM,EAAE,eAAe,EACvB,IAAI,EAAE,kBAAkB,GAAG,SAAS,GACnC,IAAI,CA0HN"}

package/dist/tools/author-scene.js

@@ -0,0 +1,140 @@
+import { achievedChanges, verifyScene, } from '@pascal-app/core/agent-operations';
+import { authorSceneTool, isAgentRefusal, } from '@pascal-app/core/agent-tools';
+import { GEOMETRY_SCRIPT_MIME_TYPES } from '@pascal-app/core/schema';
+import { compileAuthorScene } from '@pascal-app/geometry-script/author-scene';
+import { z } from 'zod';
+import { compileAndStore } from './add-object.js';
+import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { refusalResult, toolError } from './errors.js';
+import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { toPatches } from './shared-tools.js';
+/**
+ * `author_scene` on the MCP: every item's module compiled and stored through the host, the
+ * module and the adapter kept as the scene's provenance, the operation applied, Pascal's checks
+ * run, and the gate report answered. Replay is the same payload through the same operation.
+ */
+export function registerAuthorScene(server, bridge, host) {
+    server.registerTool(authorSceneTool.name, {
+        title: authorSceneTool.title,
+        description: authorSceneTool.description,
+        inputSchema: z.object(authorSceneTool.input),
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    }, async (input) => {
+        if (!host) {
+            return toolError('This Pascal server cannot run geometry scripts.', {
+                code: 'scripts_unavailable',
+            });
+        }
+        const args = input;
+        const scene = bridge.getActiveScene();
+        if (!scene) {
+            return toolError('Open or save a scene first: a conversion is stored with a scene.', {
+                code: 'no_active_scene',
+            });
+        }
+        if (args.sceneId && args.sceneId !== scene.id) {
+            return toolError('Open the requested scene before converting it.', {
+                code: 'scene_mismatch',
+                mutationApplied: false,
+            });
+        }
+        const before = bridge.getNodes();
+        const beforeJson = JSON.stringify(before);
+        const context = {
+            activeLevelId: bridge.activeLevelId?.() ?? null,
+            ...(bridge.supportsMaterialUpserts && bridge.getMaterials
+                ? { materials: bridge.getMaterials() }
+                : {}),
+        };
+        let outcome;
+        try {
+            outcome = await compileAuthorScene(before, args, context, ({ code, kind, inputs, nodeId }) => compileAndStore(host, scene.id, { code, language: 'three', params: undefined, inputs }, kind, { nodeId }), host.signal);
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(error instanceof Error ? error.message : String(error), {
+                code: 'conversion_failed',
+            });
+        }
+        // Provenance: the design's module and the program that read it, kept as scripts of the scene.
+        const provenance = {};
+        for (const [kind, text] of [
+            ['module', args.module],
+            ['adapter', args.adapter],
+        ]) {
+            if (!text)
+                continue;
+            provenance[kind] = await host.storeArtifact({
+                sceneId: scene.id,
+                sha256: await sha256(text),
+                bytes: new TextEncoder().encode(text),
+                mimeType: GEOMETRY_SCRIPT_MIME_TYPES.three,
+                metadata: { kind: 'item' },
+            });
+        }
+        host.signal?.throwIfAborted();
+        await host.assertActive?.();
+        if (JSON.stringify(bridge.getNodes()) !== beforeJson) {
+            return toolError('The scene changed while its candidate was compiling. Read the current scene and retry the conversion.', { code: 'scene_changed', mutationApplied: false });
+        }
+        const buildingUpdate = outcome.changes.update.find((change) => change.id === outcome.buildingId);
+        buildingUpdate.data.metadata = {
+            ...buildingUpdate.data.metadata,
+            authorScene: {
+                ...provenance,
+                payload: withoutCode(args.payload),
+                report: outcome.result,
+                at: new Date().toISOString(),
+            },
+        };
+        const patches = toPatches(outcome.changes);
+        if (patches.length)
+            bridge.applyPatch(patches);
+        const checks = verifyScene(bridge.getNodes(), undefined, {
+            activeLevelId: null,
+        }).result;
+        const byType = new Map();
+        for (const issue of checks.issues)
+            byType.set(issue.type ?? 'unknown', (byType.get(issue.type ?? 'unknown') ?? 0) + 1);
+        const payload = {
+            ...outcome.result,
+            itemTriangles: outcome.itemTriangles,
+            itemsCompiled: outcome.itemsCompiled,
+            green: outcome.result.defects.length === 0,
+            verify: {
+                valid: checks.valid,
+                issues: checks.issues.length,
+                byType: Object.fromEntries(byType),
+                first: checks.issues.slice(0, 40).map((i) => i.message),
+            },
+            achieved: achievedChanges(before, outcome.changes ?? {}),
+            ...persistencePayload(await publishLiveSceneSnapshot(bridge, authorSceneTool.name)),
+        };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}
+/** The payload as kept with the scene: every module is already its own artifact. */
+function withoutCode(payload) {
+    return {
+        ...payload,
+        levels: payload.levels.map((level) => ({
+            ...level,
+            walls: (level.walls ?? []).map(({ faceLeft, faceRight, ...wall }) => ({
+                ...wall,
+                openings: (wall.openings ?? []).map(({ code: _, ...opening }) => opening),
+                ...(faceLeft ? { faceLeft: { toHeight: faceLeft.toHeight } } : {}),
+                ...(faceRight ? { faceRight: { toHeight: faceRight.toHeight } } : {}),
+            })),
+            items: (level.items ?? []).map(({ code: _, ...item }) => item),
+            rooms: level.rooms.map(({ floorCode: _, wallCode: _w, ...room }) => room),
+        })),
+    };
+}
+async function sha256(text) {
+    const digest = await crypto.subtle.digest('SHA-256', new TextEncoder().encode(text));
+    return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('');
+}

package/dist/tools/check-collisions.d.ts

@@ -1,17 +1,17 @@
-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 checkCollisionsInput: {
     levelId: z.ZodOptional<z.ZodString>;
-    minimumClearance: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    minimumClearance: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     floorOnly: z.ZodDefault<z.ZodBoolean>;
     candidate: z.ZodOptional<z.ZodObject<{
         id: z.ZodDefault<z.ZodString>;
         name: z.ZodDefault<z.ZodString>;
         levelId: z.ZodString;
-        position: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>, z.ZodTransform<[number, number, number], number[]>>;
-        dimensions: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>, z.ZodTransform<[number, number, number], number[]>>;
-        rotationY: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        position: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>> | z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>, z.ZodTransform<[number, number, number], number[]>>;
+        dimensions: z.ZodPipe<z.ZodArray<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>> | z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>, z.ZodTransform<[number, number, number], number[]>>;
+        rotationY: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
         source: z.ZodOptional<z.ZodObject<{
             assetId: z.ZodOptional<z.ZodString>;
             uri: z.ZodOptional<z.ZodString>;
@@ -21,8 +21,8 @@ export declare const checkCollisionsInput: {
 export declare const checkCollisionsOutput: {
     status: z.ZodEnum<{
         checked: "checked";
-        partial: "partial";
         insufficient_evidence: "insufficient_evidence";
+        partial: "partial";
     }>;
     units: z.ZodLiteral<"meters">;
     method: z.ZodLiteral<"rotation-aware-plan-aabb">;

package/dist/tools/check-collisions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAOxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA4BpD,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;CA+BhC,CAAA;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAoDjC,CAAA;AA6BD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAyKxF"}
+{"version":3,"file":"check-collisions.d.ts","sourceRoot":"","sources":["../../src/tools/check-collisions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAO7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AA4BpD,eAAO,MAAM,oBAAoB;IAC/B,OAAO;IACP,gBAAgB;IAIhB,SAAS;IAIT,SAAS;;;;;;;;;;;;CAqBV,CAAA;AAED,eAAO,MAAM,qBAAqB;IAChC,MAAM;;;;;IACN,KAAK;IACL,MAAM;IACN,mBAAmB;IACnB,sBAAsB;IACtB,SAAS;IACT,eAAe;IACf,YAAY;;;;;;;;;;;;;;;;;;;;IAsBZ,YAAY;;;;;IAOZ,iBAAiB;;;;IAMjB,UAAU;;;;;;;;;;CASX,CAAA;AA6BD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4KxF"}

package/dist/tools/check-collisions.js

@@ -2,7 +2,7 @@ import { findItemItemCollisions, inspectItemPlanFootprint, resolveNodeLevelId, }
 import { ItemNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
-import { ErrorCode, throwMcpError } from './errors.js';
+import { ProtocolErrorCode, throwMcpError } from './errors.js';
 import { measurement } from './measurement.js';
 import { computeGraphHash } from './scene-lifecycle/metadata.js';
 import { NodeIdSchema } from './schemas.js';
@@ -130,24 +130,24 @@ export function registerCheckCollisions(server, bridge) {
     server.registerTool('check_collisions', {
         title: 'Check collisions',
         description: 'Assess declared item footprints with a rotation-aware plan AABB test. Supports an explicit minimum clearance and reports units, source dimensions, skipped evidence, and unsupported checks. Optionally scope to one level or floor-standing items.',
-        inputSchema: checkCollisionsInput,
-        outputSchema: checkCollisionsOutput,
+        inputSchema: z.object(checkCollisionsInput),
+        outputSchema: z.object(checkCollisionsOutput),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async ({ levelId, minimumClearance, floorOnly, candidate }) => {
         const sceneNodes = Object.values(bridge.getNodes());
         if (candidate && levelId && candidate.levelId !== levelId) {
-            throwMcpError(ErrorCode.InvalidParams, 'candidate.levelId must match levelId when both are provided');
+            throwMcpError(ProtocolErrorCode.InvalidParams, 'candidate.levelId must match levelId when both are provided');
         }
         const scopeLevelId = candidate?.levelId ?? levelId;
         if (scopeLevelId) {
             const target = sceneNodes.find((node) => node.id === scopeLevelId);
             if (target?.type !== 'level') {
-                throwMcpError(ErrorCode.InvalidParams, `Level not found: ${scopeLevelId}`);
+                throwMcpError(ProtocolErrorCode.InvalidParams, `Level not found: ${scopeLevelId}`);
             }
         }
         if (candidate) {
             if (sceneNodes.some((node) => node.id === candidate.id)) {
-                throwMcpError(ErrorCode.InvalidParams, `Candidate id already exists: ${candidate.id}`);
+                throwMcpError(ProtocolErrorCode.InvalidParams, `Candidate id already exists: ${candidate.id}`);
             }
         }
         const candidateNode = candidate

package/dist/tools/clear-scene.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { SceneOperations } from '../operations/index.js';
 /**
  * `clear_scene`: the scene goes back to the host's default scaffold (a site, a building, a level),

package/dist/tools/clear-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clear-scene.d.ts","sourceRoot":"","sources":["../../src/tools/clear-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAGxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAmDvF"}
+{"version":3,"file":"clear-scene.d.ts","sourceRoot":"","sources":["../../src/tools/clear-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAG7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAKpD;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,eAAe,GAAG,IAAI,CAmDvF"}

package/dist/tools/clear-scene.js

@@ -12,13 +12,13 @@ export function registerClearScene(server, operations) {
     server.registerTool(clearSceneTool.name, {
         title: clearSceneTool.title,
         description: clearSceneTool.description,
-        inputSchema: clearSceneTool.input,
-        outputSchema: {
+        inputSchema: z.object(clearSceneTool.input),
+        outputSchema: z.object({
             cleared: z.object({ removed: z.number() }),
             version: z.number().nullable(),
             graphHash: z.string().nullable(),
             ...liveSyncOutput,
-        },
+        }),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async () => {
         try {

package/dist/tools/collections.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer } from '@modelcontextprotocol/server';
 import type { SceneOperations } from '../operations/index.js';
 export declare function registerCollectionTools(server: McpServer, bridge: SceneOperations): void;
 //# sourceMappingURL=collections.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/tools/collections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAWxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgBpD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA+CxF"}
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/tools/collections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAY7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgBpD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA+CxF"}

package/dist/tools/collections.js

@@ -1,5 +1,6 @@
 import { editCollection, listCollections, writeCollections, } from '@pascal-app/core/agent-operations';
 import { editCollectionTool, listCollectionsTool } from '@pascal-app/core/agent-tools';
+import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS } from './annotations.js';
 import { refusalResult } from './errors.js';
 import { persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
@@ -15,7 +16,7 @@ export function registerCollectionTools(server, bridge) {
     server.registerTool(listCollectionsTool.name, {
         title: listCollectionsTool.title,
         description: listCollectionsTool.description,
-        inputSchema: listCollectionsTool.input,
+        inputSchema: z.object(listCollectionsTool.input),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async (input) => {
         try {
@@ -28,7 +29,7 @@ export function registerCollectionTools(server, bridge) {
     server.registerTool(editCollectionTool.name, {
         title: editCollectionTool.title,
         description: editCollectionTool.description,
-        inputSchema: editCollectionTool.input,
+        inputSchema: z.object(editCollectionTool.input),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async (input) => {
         let outcome;

package/dist/tools/construction-tools.d.ts

@@ -1,15 +1,15 @@
-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 createStoryShellInput: {
     levelId: z.ZodString;
     footprint: z.ZodArray<z.ZodArray<z.ZodNumber>>;
-    wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    wallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     createSlab: z.ZodDefault<z.ZodBoolean>;
     createCeiling: z.ZodDefault<z.ZodBoolean>;
-    slabElevation: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    ceilingHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    slabElevation: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    ceilingHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
     namePrefix: z.ZodOptional<z.ZodString>;
     wallMaterialPreset: z.ZodOptional<z.ZodString>;
     slabMaterialPreset: z.ZodOptional<z.ZodString>;
@@ -20,8 +20,8 @@ export declare const createStoryShellOutput: {
     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>>;
@@ -35,48 +35,5 @@ export declare const createStoryShellOutput: {
     ceilingId: z.ZodNullable<z.ZodString>;
     createdIds: z.ZodArray<z.ZodString>;
 };
-export declare const createRoofInput: {
-    levelId: z.ZodString;
-    roofLevelId: z.ZodOptional<z.ZodString>;
-    useDedicatedRoofLevel: z.ZodDefault<z.ZodBoolean>;
-    roofLevelLabel: z.ZodDefault<z.ZodString>;
-    roofLevelElevation: z.ZodOptional<z.ZodNumber>;
-    roofLevelHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    center: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
-    width: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
-    depth: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>;
-    roofType: z.ZodDefault<z.ZodEnum<{
-        gable: "gable";
-        flat: "flat";
-        hip: "hip";
-        shed: "shed";
-        gambrel: "gambrel";
-        dutch: "dutch";
-        mansard: "mansard";
-        conical: "conical";
-    }>>;
-    pitch: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallHeight: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    wallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    overhang: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    materialPreset: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-};
-export declare const createRoofOutput: {
-    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";
-        }>;
-        warning: z.ZodString;
-    }, z.core.$strip>>;
-    referenceLevelId: z.ZodString;
-    roofLevelId: z.ZodString;
-    createdRoofLevelId: z.ZodNullable<z.ZodString>;
-    roofId: z.ZodString;
-    roofSegmentId: z.ZodString;
-};
 export declare function registerConstructionTools(server: McpServer, bridge: SceneOperations): void;
 //# sourceMappingURL=construction-tools.d.ts.map

package/dist/tools/construction-tools.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAKxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAgBpD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;CA8BjC,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;IAGjC,2DAA2D;;IAE3D,mFAAmF;;IAEnF,iFAAiF;;;CAIlF,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0B3B,CAAA;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;CAO5B,CAAA;AAgFD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA2O1F"}
+{"version":3,"file":"construction-tools.d.ts","sourceRoot":"","sources":["../../src/tools/construction-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAI7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAOpD,eAAO,MAAM,qBAAqB;IAChC,OAAO;IACP,SAAS;IACT,UAAU;IAIV,aAAa;IAIb,UAAU;IAIV,aAAa;IAIb,aAAa;IAGb,aAAa;IAIb,UAAU;IACV,kBAAkB;IAClB,kBAAkB;IAClB,qBAAqB;CACtB,CAAA;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;IAGjC,2DAA2D;;IAE3D,mFAAmF;;IAEnF,iFAAiF;;;CAIlF,CAAA;AAgDD,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA4H1F"}