@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/shared-tools.js

@@ -0,0 +1,574 @@
+import { AGENT_OPERATIONS, achievedChanges, applyAgentOutcome, assetViewNeeds, assetViewsReadCatalog, briefReadsCatalog, buildBatchObjects, createAssetViewLoader, createFetchAssetViewIO, furnishingRefusal, startOfSession, writeCollections, } from '@pascal-app/core/agent-operations';
+import { addCornerWindowTool, addFenceTool, addLevelTool, addObjectTool, addWallTool, createRoofTool, createRoomTool, createStairTool, deleteNodeTool, designBriefTool, duplicateLevelTool, findByTypeTool, fitStairTool, furnishRoomTool, getLevelSummaryTool, getNodeTool, getSiteTool, getWallsTool, getZonesTool, listLevelsTool, measureStairTool, mergeWindowsTool, moveRoofsToRoofLevelTool, paintTool, placeBuildingTool, placeDesignTool, placeInRoomTool, placeItemsTool, ROOM_TOOL_CONTRACTS, refuse, runBatchTool, searchAssetsTool, searchMaterialsTool, setCheckpointTool, setGroundLevelTool, validateDesignTool, verifySceneTool, viewAssetsTool, } from '@pascal-app/core/agent-tools';
+import { DesignValidationSchema } from '@pascal-app/core/procedural-items';
+import { MaterialSchema, SceneMaterial, } from '@pascal-app/core/schema';
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS, READ_ONLY_TOOL_ANNOTATIONS, } from './annotations.js';
+import { builtInCatalog } from './asset-catalog.js';
+import { registerCollectionTools } from './collections.js';
+import { refusalResult } from './errors.js';
+import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { ROOM_TOOL_ANNOTATIONS, structureOutput } from './structure-tools.js';
+const defaultAssetViews = createAssetViewLoader(createFetchAssetViewIO());
+const jsonObject = z.record(z.string(), z.unknown());
+function refuseScripts() {
+    refuse('scripts_unavailable', 'This Pascal server cannot run geometry scripts.');
+}
+/** What the scene holds after a mutating call (core achievedChanges). */
+const achievedOutput = {
+    achieved: z
+        .object({
+        created: z.record(z.string(), z.number()),
+        updated: z.number(),
+        deleted: z.record(z.string(), z.number()),
+        unchanged: z.literal(true).optional(),
+    })
+        .optional(),
+};
+const levelRoleOutput = {
+    levelId: z.string(),
+    levelName: z.string().optional(),
+    floorIndex: z.number(),
+    role: z.string(),
+    metadataRole: z.string().nullable(),
+    isOccupiedStory: z.boolean(),
+    isSupportLevel: z.boolean(),
+    referenceLevelId: z.string().nullable(),
+};
+const SHARED_TOOLS = [
+    {
+        contract: validateDesignTool,
+        operation: AGENT_OPERATIONS.validate_design,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: DesignValidationSchema.shape,
+    },
+    {
+        contract: placeDesignTool,
+        operation: AGENT_OPERATIONS.place_design,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            designId: z.string(),
+            parentId: z.string(),
+            surfaceId: z.string().nullable(),
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: measureStairTool,
+        operation: AGENT_OPERATIONS.measure_stair,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { measurements: z.json(), layouts: z.json() },
+    },
+    {
+        contract: fitStairTool,
+        operation: AGENT_OPERATIONS.fit_stair,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: { stairId: z.string().min(1), measurements: z.json(), ...liveSyncOutput },
+    },
+    {
+        contract: findByTypeTool,
+        operation: AGENT_OPERATIONS.find_by_type,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: listLevelsTool,
+        operation: AGENT_OPERATIONS.list_levels,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            activeSceneId: z.string().nullable(),
+            activeLevelId: z.string().nullable(),
+            levelCount: z.number(),
+            occupiedStoryCount: z.number(),
+            supportLevelCount: z.number(),
+            roofLevelIds: z.array(z.string()),
+            levels: z.array(jsonObject),
+        },
+        envelope: (bridge) => ({ activeSceneId: bridge.getActiveScene()?.id ?? null }),
+    },
+    {
+        contract: getNodeTool,
+        operation: AGENT_OPERATIONS.get_node,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            node: jsonObject,
+            ancestorIds: z.array(z.string()),
+            missingChildIds: z.array(z.string()).optional(),
+            materials: z.record(z.string(), SceneMaterial).optional(),
+        },
+    },
+    {
+        contract: getLevelSummaryTool,
+        operation: AGENT_OPERATIONS.get_level_summary,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ...levelRoleOutput,
+            counts: jsonObject,
+            walls: z.array(jsonObject),
+            zones: z.array(jsonObject),
+            slabs: z.array(jsonObject),
+            ceilings: z.array(jsonObject),
+            items: z.array(jsonObject),
+            openings: z.array(jsonObject),
+            stairs: z.array(jsonObject),
+            roofs: z.array(jsonObject),
+            other: z.array(jsonObject),
+        },
+    },
+    {
+        contract: getWallsTool,
+        operation: AGENT_OPERATIONS.get_walls,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { levelId: z.string(), walls: z.array(jsonObject) },
+    },
+    {
+        contract: getZonesTool,
+        operation: AGENT_OPERATIONS.get_zones,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: { levelId: z.string(), zones: z.array(jsonObject) },
+    },
+    {
+        contract: duplicateLevelTool,
+        operation: AGENT_OPERATIONS.duplicate_level,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            newLevelId: z.string(),
+            name: z.string().optional(),
+            floorIndex: z.number(),
+            shiftedLevelIds: z.array(z.string()),
+            copied: z.record(z.string(), z.number()),
+            skipped: z.record(z.string(), z.number()),
+            newNodeIds: z.array(z.string()),
+            // A floor copy is hundreds of ids: the result lists 40 and counts the rest.
+            newNodeIdsOmitted: z.number().optional(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: setGroundLevelTool,
+        operation: AGENT_OPERATIONS.set_ground_level,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.boolean(),
+            levelId: z.string(),
+            buildingId: z.string(),
+            floorElevation: z.number(),
+            gradeElevation: z.number().optional(),
+            movedBuildingBy: z.number().optional(),
+            renumbered: z.boolean().optional(),
+            unchanged: z.boolean().optional(),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: verifySceneTool,
+        operation: AGENT_OPERATIONS.verify_scene,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.boolean(),
+            valid: z.boolean(),
+            levelCount: z.number(),
+            occupiedStoryCount: z.number(),
+            supportLevelCount: z.number(),
+            roofLevelIds: z.array(z.string()),
+            activeSceneId: z.string().nullable(),
+            activeLevelId: z.string().nullable(),
+            levels: z.array(jsonObject),
+            emptyLevelIds: z.array(z.string()),
+            // Typed by `type`; a check registered with verify_scene may add fields of its own.
+            issues: z.array(z.looseObject({
+                type: z.string(),
+                message: z.string(),
+                severity: z.literal('info').optional(),
+                nodeId: z.string().optional(),
+                path: z.string().optional(),
+                zoneId: z.string().optional(),
+                wallIds: z.array(z.string()).optional(),
+                area: z.number().optional(),
+                at: z.tuple([z.number(), z.number()]).optional(),
+                wallId: z.string().optional(),
+                slabId: z.string().optional(),
+                levelId: z.string().optional(),
+                wallTop: z.number().optional(),
+                slabUnderside: z.number().optional(),
+                slabTop: z.number().optional(),
+                penetration: z.number().optional(),
+                coplanar: z.boolean().optional(),
+                end: z.enum(['start', 'end']).optional(),
+                reason: z.enum(['gap', 'crosses', 'parallel', 'rejected']).optional(),
+                gap: z.number().optional(),
+                nearestWallId: z.string().optional(),
+            })),
+            hasIssues: z.boolean(),
+            checkpoints: z.array(z.string()).optional(),
+            since: jsonObject.optional(),
+            authoredObjects: z
+                .array(z.object({
+                id: z.string(),
+                name: z.string(),
+                category: z.string(),
+                reason: z.string().nullable(),
+            }))
+                .optional(),
+        },
+        envelope: (bridge) => ({ activeSceneId: bridge.getActiveScene()?.id ?? null }),
+    },
+    {
+        contract: setCheckpointTool,
+        operation: AGENT_OPERATIONS.set_checkpoint,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: designBriefTool,
+        operation: AGENT_OPERATIONS.design_brief,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: addWallTool,
+        operation: AGENT_OPERATIONS.add_wall,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: addFenceTool,
+        operation: AGENT_OPERATIONS.add_fence,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: addCornerWindowTool,
+        operation: AGENT_OPERATIONS.add_corner_window,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: mergeWindowsTool,
+        operation: AGENT_OPERATIONS.merge_windows,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: addLevelTool,
+        operation: AGENT_OPERATIONS.add_level,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: createStairTool,
+        operation: AGENT_OPERATIONS.create_stair,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: createRoofTool,
+        operation: AGENT_OPERATIONS.create_roof,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: moveRoofsToRoofLevelTool,
+        operation: AGENT_OPERATIONS.move_roofs_to_roof_level,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: placeItemsTool,
+        operation: AGENT_OPERATIONS.place_items,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        catalog: true,
+    },
+    {
+        contract: deleteNodeTool,
+        operation: AGENT_OPERATIONS.delete_node,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: { deletedIds: z.array(z.string()), ...achievedOutput, ...liveSyncOutput },
+    },
+    {
+        contract: createRoomTool,
+        operation: AGENT_OPERATIONS.create_room,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.literal(true),
+            zoneId: z.string(),
+            // The floor plate and the ceiling the host derived; null where it derives none (a terrace).
+            slabId: z.string().nullable(),
+            ceilingId: z.string().nullable(),
+            // One per polygon edge; null where no wall runs along it.
+            wallIds: z.array(z.string().nullable()),
+            reusedWalls: z.number(),
+            areaSqMeters: z.number(),
+            doorIds: z.array(z.string()),
+            windowIds: z.array(z.string()),
+            skippedOpenings: z
+                .array(z.object({
+                kind: z.enum(['door', 'window']),
+                index: z.number(),
+                code: z.string(),
+                message: z.string(),
+            }))
+                .optional(),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: furnishRoomTool,
+        operation: AGENT_OPERATIONS.furnish_room,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        catalog: true,
+        outputSchema: {
+            ok: z.literal(true),
+            placed: z.number(),
+            itemIds: z.array(z.string()),
+            skipped: z.array(z.string()),
+            doorWallIndex: z.number(),
+            doorsDetected: z.number(),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: paintTool,
+        operation: AGENT_OPERATIONS.paint,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            ok: z.literal(true),
+            painted: z.array(z.object({ id: z.string(), roles: z.array(z.string()) })),
+            finish: z.string(),
+            materialId: z.string().optional(),
+            material: MaterialSchema.optional(),
+            createdMaterial: SceneMaterial.optional(),
+            note: z.string().optional(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: placeInRoomTool,
+        operation: AGENT_OPERATIONS.place_in_room,
+        annotations: ADDITIVE_TOOL_ANNOTATIONS,
+        catalog: true,
+        outputSchema: {
+            ok: z.literal(true),
+            itemId: z.string(),
+            kind: z.string(),
+            placed: z.object({ position: z.array(z.number()), rotationDeg: z.number() }),
+            against: z.object({ edge: z.number(), wall: z.string() }).optional(),
+            around: z.string().optional(),
+            facing: z.string().optional(),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: getSiteTool,
+        operation: AGENT_OPERATIONS.get_site,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    },
+    {
+        contract: placeBuildingTool,
+        operation: AGENT_OPERATIONS.place_building,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+        outputSchema: {
+            buildingId: z.string(),
+            moved: z.boolean(),
+            fit: z.enum(['buildable', 'lot', 'outside']),
+            message: z.string(),
+            ...achievedOutput,
+            ...liveSyncOutput,
+        },
+    },
+    {
+        contract: searchAssetsTool,
+        operation: AGENT_OPERATIONS.search_assets,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        catalog: true,
+    },
+    {
+        contract: viewAssetsTool,
+        operation: AGENT_OPERATIONS.view_assets,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+        catalog: true,
+    },
+    {
+        contract: searchMaterialsTool,
+        operation: AGENT_OPERATIONS.search_materials,
+        annotations: READ_ONLY_TOOL_ANNOTATIONS,
+    },
+    ...ROOM_TOOL_CONTRACTS.map((contract) => {
+        const name = contract.name;
+        return {
+            contract,
+            operation: AGENT_OPERATIONS[name],
+            annotations: ROOM_TOOL_ANNOTATIONS[name],
+            outputSchema: { ...structureOutput, ...achievedOutput },
+        };
+    }),
+    {
+        contract: runBatchTool,
+        operation: AGENT_OPERATIONS.run_batch,
+        annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    },
+];
+export function toPatches(changes) {
+    return [
+        ...(changes.materials ?? []).map((material) => ({ op: 'upsert_material', material })),
+        ...(changes.create ?? []).map(({ node, parentId }) => ({
+            op: 'create',
+            node,
+            parentId: parentId,
+        })),
+        ...(changes.update ?? []).map(({ id, data }) => ({
+            op: 'update',
+            id: id,
+            data,
+        })),
+        ...(changes.delete ?? []).map((id) => ({
+            op: 'delete',
+            id: id,
+            cascade: true,
+        })),
+    ];
+}
+/** How an outcome reaches this bridge: its patches, its derived construction, its session record. */
+export function agentRuntime(bridge) {
+    return {
+        getNodes: () => bridge.getNodes(),
+        applyChanges: (changes) => {
+            if (changes.materials?.length &&
+                (bridge.supportsMaterialUpserts !== true || bridge.getMaterials?.() === undefined))
+                refuse('materials_unavailable', 'This host cannot atomically persist native materials; nothing was painted.');
+            const next = toPatches(changes);
+            if (next.length)
+                bridge.applyPatch(next);
+            if (changes.collections && Object.keys(changes.collections).length)
+                bridge.setCollections(writeCollections(bridge.getCollections(), changes.collections));
+        },
+        reconcile: () => {
+            bridge.deriveStructure();
+        },
+        keep: (keep) => bridge.agentSession?.keep(keep),
+    };
+}
+export function briefInForce(bridge) {
+    if (bridge.designBriefRequired === false)
+        return undefined;
+    const session = bridge.agentSession;
+    return session ? (session.read().designBrief ?? null) : undefined;
+}
+function writesScene(changes) {
+    return Boolean(changes &&
+        (toPatches(changes).length ||
+            (changes.collections && Object.keys(changes.collections).length)));
+}
+export function registerSharedTools(server, bridge, catalog = builtInCatalog, hosts = {}) {
+    for (const tool of SHARED_TOOLS)
+        registerOperationTool(server, bridge, tool, catalog, hosts);
+    registerCollectionTools(server, bridge);
+}
+/**
+ * Registers one operation tool, as the shared tools are: a host adds a plugin's `'operation'`
+ * tools with it, from the plugin's `./agent-tools` contract and `./agent-operations` operation.
+ */
+export function registerOperationTool(server, bridge, tool, catalog = builtInCatalog, hosts = {}) {
+    server.registerTool(tool.contract.name, {
+        title: tool.contract.title,
+        description: tool.contract.description,
+        inputSchema: z.object(tool.contract.input),
+        // Loose: a client that listed the tools rejects any field the schema leaves out, and the
+        // operations in core grow fields (verify_scene's guesses) that this list would miss.
+        ...(tool.outputSchema ? { outputSchema: z.looseObject(tool.outputSchema) } : {}),
+        annotations: tool.annotations,
+    }, async (input) => {
+        let outcome;
+        // A copy of the map: a host may write its own in place (the hosted bridge does), and a
+        // "before" that grows with the call reads every creation as unchanged.
+        const before = { ...bridge.getNodes() };
+        // The agent's session begins with its first call, before anything is written.
+        const first = bridge.agentSession && startOfSession(bridge.agentSession.read(), before);
+        if (first)
+            bridge.agentSession?.keep(first);
+        // Gate before catalog I/O or module compilation.
+        const designBrief = briefInForce(bridge);
+        if (designBrief !== undefined) {
+            const refusal = furnishingRefusal(tool.contract.name, input, designBrief);
+            if (refusal)
+                return refusalResult(refusal);
+        }
+        const batchPlacesInRoom = tool.contract.name === runBatchTool.name &&
+            Array.isArray(input.calls) &&
+            input.calls.some((call) => typeof call === 'object' &&
+                call !== null &&
+                'tool' in call &&
+                call.tool === placeInRoomTool.name);
+        const batchesObjects = tool.contract.name === runBatchTool.name &&
+            Array.isArray(input.calls) &&
+            input.calls.some((call) => typeof call === 'object' &&
+                call !== null &&
+                'tool' in call &&
+                call.tool === addObjectTool.name);
+        const context = {
+            activeLevelId: bridge.activeLevelId?.() ?? null,
+            ...(bridge.supportsMaterialUpserts && bridge.getMaterials
+                ? { materials: bridge.getMaterials() }
+                : {}),
+            ...(bridge.nodeSchema && { nodeSchema: (kind) => bridge.nodeSchema(kind) }),
+            session: bridge.agentSession?.read(),
+            ...(designBrief !== undefined && { designBrief }),
+            ...((tool.catalog ||
+                batchPlacesInRoom ||
+                assetViewsReadCatalog(tool.contract.name, input) ||
+                briefReadsCatalog(tool.contract.name, input)) && { catalog: await catalog() }),
+            ...(batchesObjects && {
+                batchObjects: await buildBatchObjects(input.calls, hosts.buildObject ?? refuseScripts),
+            }),
+        };
+        const needs = assetViewNeeds(before, tool.contract.name, input, context);
+        if (needs.subjects.length)
+            context.assetViews = await (hosts.assetViews ?? defaultAssetViews)(needs.subjects, {
+                pictures: needs.pictures,
+            });
+        try {
+            outcome = tool.operation(before, input, context);
+        }
+        catch (error) {
+            return refusalResult(error);
+        }
+        let result = outcome.result;
+        let persistence = {};
+        // An outcome edits the scene through its node changes, its collection writes, or the
+        // follow-up it plans once the host has reconciled; any of them is one history step.
+        if (writesScene(outcome.changes) || outcome.afterReconcile) {
+            result = bridge.runAsSingleHistoryStep(() => applyAgentOutcome(outcome, agentRuntime(bridge)));
+            persistence = persistencePayload(await publishLiveSceneSnapshot(bridge, tool.contract.name));
+        }
+        else if (outcome.keep) {
+            // A checkpoint: kept with the session, nothing in the scene to save.
+            result = applyAgentOutcome(outcome, agentRuntime(bridge));
+        }
+        // What the scene holds after the call, not only what the call says it built.
+        const achieved = outcome.changes ? achievedChanges(before, outcome.changes) : null;
+        const payload = {
+            ...result,
+            ...(achieved ? { achieved } : {}),
+            ...(tool.envelope?.(bridge) ?? {}),
+            ...persistence,
+        };
+        const { previews, ...shown } = payload;
+        const pictures = (Array.isArray(previews) ? previews : []).flatMap(({ label, image }) => {
+            const [, mimeType, data] = /^data:(image\/[\w.+-]+);base64,(.+)$/.exec(image) ?? [];
+            return mimeType && data
+                ? [
+                    { type: 'text', text: label },
+                    { type: 'image', data, mimeType },
+                ]
+                : [];
+        });
+        if (pictures.length)
+            return {
+                content: [{ type: 'text', text: JSON.stringify(shown) }, ...pictures],
+                structuredContent: shown,
+            };
+        return {
+            content: [{ type: 'text', text: JSON.stringify(payload) }],
+            structuredContent: payload,
+        };
+    });
+}

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

@@ -0,0 +1,57 @@
+import type { ROOM_OPERATIONS } from '@pascal-app/core/agent-operations';
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+export type RoomToolName = keyof typeof ROOM_OPERATIONS;
+export declare const ROOM_TOOL_ANNOTATIONS: Record<RoomToolName, typeof ADDITIVE_TOOL_ANNOTATIONS | typeof DESTRUCTIVE_TOOL_ANNOTATIONS>;
+export declare const structureOutput: {
+    project: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    unsaved: z.ZodOptional<z.ZodString>;
+    persistence: z.ZodOptional<z.ZodObject<{
+        status: z.ZodEnum<{
+            events_unsupported: "events_unsupported";
+            unbound: "unbound";
+        }>;
+        warning: z.ZodString;
+    }, z.core.$strip>>;
+    zoneId: z.ZodOptional<z.ZodString>;
+    openingId: z.ZodOptional<z.ZodString>;
+    openingIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hints: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodLiteral<"manual-ceiling">;
+        openingId: z.ZodString;
+        surfaceIds: z.ZodArray<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+    idMap: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodArray<z.ZodString>>>;
+    changes: z.ZodNumber;
+    separatorId: z.ZodOptional<z.ZodString>;
+    separatorIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    zoneIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    payload: z.ZodOptional<z.ZodObject<{
+        zoneId: z.ZodString;
+        name: z.ZodString;
+        mode: z.ZodEnum<{
+            blocked: "blocked";
+            delete: "delete";
+            merge: "merge";
+        }>;
+        mergedIntoZoneId: z.ZodOptional<z.ZodString>;
+        contents: z.ZodEnum<{
+            delete: "delete";
+            keep: "keep";
+        }>;
+        wallIds: z.ZodArray<z.ZodString>;
+        keptSharedWallIds: z.ZodArray<z.ZodString>;
+        separatorIds: z.ZodArray<z.ZodString>;
+        keptSharedSeparatorIds: z.ZodArray<z.ZodString>;
+        openingIds: z.ZodArray<z.ZodString>;
+        itemIds: z.ZodArray<z.ZodString>;
+        opensZoneIds: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    conflicts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        nodeIds: z.ZodArray<z.ZodString>;
+        message: z.ZodString;
+    }, z.core.$strip>>>;
+};
+//# sourceMappingURL=structure-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"structure-tools.d.ts","sourceRoot":"","sources":["../../src/tools/structure-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,EAAE,yBAAyB,EAAE,4BAA4B,EAAE,MAAM,eAAe,CAAA;AAMvF,MAAM,MAAM,YAAY,GAAG,MAAM,OAAO,eAAe,CAAA;AAEvD,eAAO,MAAM,qBAAqB,EAAE,MAAM,CACxC,YAAY,EACZ,OAAO,yBAAyB,GAAG,OAAO,4BAA4B,CAgBvE,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuC3B,CAAA"}

package/dist/tools/structure-tools.js

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+import { ADDITIVE_TOOL_ANNOTATIONS, DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
+import { liveSyncOutput } from './live-sync.js';
+export const ROOM_TOOL_ANNOTATIONS = {
+    cut_floor_opening: ADDITIVE_TOOL_ANNOTATIONS,
+    remove_floor_opening: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    set_floor_foundation: ADDITIVE_TOOL_ANNOTATIONS,
+    set_room_floor_construction: ADDITIVE_TOOL_ANNOTATIONS,
+    rebase_floor_reference: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    create_mezzanine: ADDITIVE_TOOL_ANNOTATIONS,
+    move_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    duplicate_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    rotate_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    lock_outside_faces: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    set_zone_intent: ADDITIVE_TOOL_ANNOTATIONS,
+    divide_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    merge_zones: DESTRUCTIVE_TOOL_ANNOTATIONS,
+    delete_zone: DESTRUCTIVE_TOOL_ANNOTATIONS,
+};
+export const structureOutput = {
+    zoneId: z.string().optional(),
+    openingId: z.string().optional(),
+    openingIds: z.array(z.string()).optional(),
+    hints: z
+        .array(z.object({
+        code: z.literal('manual-ceiling'),
+        openingId: z.string(),
+        surfaceIds: z.array(z.string()),
+        message: z.string(),
+    }))
+        .optional(),
+    idMap: z.record(z.string(), z.array(z.string())).optional(),
+    changes: z.number(),
+    separatorId: z.string().optional(),
+    separatorIds: z.array(z.string()).optional(),
+    zoneIds: z.array(z.string()).optional(),
+    payload: z
+        .object({
+        zoneId: z.string(),
+        name: z.string(),
+        mode: z.enum(['delete', 'merge', 'blocked']),
+        mergedIntoZoneId: z.string().optional(),
+        contents: z.enum(['delete', 'keep']),
+        wallIds: z.array(z.string()),
+        keptSharedWallIds: z.array(z.string()),
+        separatorIds: z.array(z.string()),
+        keptSharedSeparatorIds: z.array(z.string()),
+        openingIds: z.array(z.string()),
+        itemIds: z.array(z.string()),
+        opensZoneIds: z.array(z.string()),
+    })
+        .optional(),
+    conflicts: z
+        .array(z.object({ code: z.string(), nodeIds: z.array(z.string()), message: z.string() }))
+        .optional(),
+    ...liveSyncOutput,
+};