@pascal-app/mcp 1.0.3 → 1.0.5

package/dist/tools/patch-guards.js

@@ -0,0 +1,256 @@
+import { nodeRegistry, planNodeDeletion, previewDefaultGutterRefresh, validateNodeRelations, } from '@pascal-app/core';
+import { scriptedFieldRefusal, unknownMaterialPresetRefusal, } from '@pascal-app/core/agent-operations';
+import { AnyNode, nodeKindOf, parseNode } from '@pascal-app/core/schema';
+const guards = [];
+/** Runs a guard on every apply_patch from now on; registering a guard again replaces it. */
+export function registerPatchGuard(guard) {
+    const at = guards.findIndex((known) => known.name === guard.name);
+    if (at >= 0)
+        guards[at] = guard;
+    else
+        guards.push(guard);
+    guards.sort((a, b) => a.order - b.order);
+}
+/** Runs every guard in order; the notes are what the guards changed in the patch. */
+export function runPatchGuards(patches, nodes) {
+    return guards.flatMap((guard) => {
+        const notes = guard.run(patches, nodes);
+        return Array.isArray(notes) ? notes : [];
+    });
+}
+/**
+ * A patch op refused because it would break node identity, the hierarchy or
+ * the node's schema. apply_patch returns it as a tool error whose text is
+ * JSON `{ code, patchIndex, id, message }`.
+ */
+export class PatchRefusedError extends Error {
+    code;
+    patchIndex;
+    nodeId;
+    constructor(code, patchIndex, nodeId, detail) {
+        super(`${code}: patches[${patchIndex}] ${detail}`);
+        this.code = code;
+        this.patchIndex = patchIndex;
+        this.nodeId = nodeId;
+        this.name = 'PatchRefusedError';
+    }
+}
+/**
+ * Fields an update may restate but not change: `id` and `type` are the node's
+ * identity, `object` and `children` its place in the graph. `parentId` stays
+ * writable, checked below: the store reconciles both parents' `children`.
+ */
+const IMMUTABLE_FIELDS = [
+    ['id', 'identity_change'],
+    ['type', 'identity_change'],
+    ['object', 'immutable_field'],
+    ['children', 'immutable_field'],
+];
+const CORE_KINDS = new Set(AnyNode.options.map(nodeKindOf));
+const sameValue = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+/**
+ * Schema issues of a node, keyed `path: message`, from its kind's schema: the
+ * registered definition's, or the core per-kind schema. `null` only for a kind
+ * with neither (a plugin kind this runtime has not registered), which is then
+ * not validated.
+ */
+function schemaIssues(node) {
+    const type = node.type;
+    if (typeof type !== 'string')
+        return null;
+    const schema = nodeRegistry.get(type)?.schema;
+    if (!(schema || CORE_KINDS.has(type)))
+        return null;
+    const result = schema ? schema.safeParse(node) : parseNode(node);
+    const issues = result.success ? [] : (result.error?.issues ?? []);
+    return new Set(issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`));
+}
+function withChild(parent, childId) {
+    const children = parent.children;
+    if (!Array.isArray(children) || children.includes(childId))
+        return parent;
+    return { ...parent, children: [...children, childId] };
+}
+function withoutChild(parent, childId) {
+    const children = parent.children;
+    if (!Array.isArray(children))
+        return parent;
+    return { ...parent, children: children.filter((id) => id !== childId) };
+}
+/**
+ * Dry-runs a patch against the scene as each op leaves it and refuses:
+ * - a create whose id is already present (`node_exists`): a silent replace
+ *   orphans the old node's children;
+ * - an update that changes `id`, `type`, `object` or `children`
+ *   (`immutable_field`); restating the current value passes;
+ * - an update whose merged node has schema issues the node did not have
+ *   before (`invalid_update`); kinds without a schema in this runtime pass;
+ * - an update writing a material preset the catalog does not know
+ *   (`invalid_update`; a create is rejected like other invalid creates): it
+ *   would render as the default finish;
+ * - an update of what a node's script owns, its `source` or the size it
+ *   built (`scripted_field`): only a rebuild keeps them and the geometry in step;
+ * - any op on a node an earlier delete in the patch removed, or on a default
+ *   gutter or downspout that delete regenerates, and any update of the roof
+ *   segment holding them (`regenerated_default`).
+ *
+ * Deletes run through the bridge's own deletion preview (`planDeletion`; the
+ * local bridge uses core's store planner), one call per run of consecutive
+ * deletes as the bridge batches them, so cascades and wall merges are seen as
+ * that bridge applies them. A bridge without a preview gets a stricter rule:
+ * a create may not reuse any id present at the start of the patch.
+ * An update of a roof segment unsettles the default gutters its refresh may
+ * regenerate, as a delete does.
+ * Lives in the tool layer so every bridge behind `apply_patch` inherits it.
+ */
+export function assertPatchKeepsIdentity(patches, nodes, rootNodeIds, planDeletion) {
+    const initialIds = new Set(Object.keys(nodes));
+    let scene = {
+        nodes: { ...nodes },
+        rootNodeIds: [...rootNodeIds],
+        collections: {},
+    };
+    const at = (id) => scene.nodes[id];
+    const put = (node) => {
+        scene.nodes[node.id] = node;
+    };
+    // Default gutters and downspouts a delete run refreshes: the store may keep,
+    // move or replace them with freshly minted ids, so later ops in the same
+    // patch cannot address them reliably.
+    const regenerated = new Map();
+    // Roof segments whose `children` that refresh rewrites: an update restating
+    // their pre-delete children would bring back obsolete ids.
+    const regeneratedHosts = new Map();
+    const refuseRegenerated = (index, id) => {
+        const deleteIndex = regenerated.get(id);
+        if (deleteIndex === undefined)
+            return;
+        throw new PatchRefusedError('regenerated_default', index, id, `"${id}" is a default gutter or downspout that the edit at patches[${deleteIndex}] regenerates. Address it in a separate apply_patch call.`);
+    };
+    // Updating a roof or roof segment makes the store refresh that roof's
+    // default gutters, with the same effect on ids as a delete's refresh.
+    const unsettleRoofRefresh = (node, index) => {
+        const roofId = node.type === 'roof' ? node.id : node.type === 'roof-segment' ? node.parentId : null;
+        if (!roofId)
+            return;
+        const preview = previewDefaultGutterRefresh(scene.nodes, [roofId]);
+        for (const id of preview.unsettledIds)
+            regenerated.set(id, index);
+        for (const id of preview.regeneratedHostIds)
+            regeneratedHosts.set(id, index);
+    };
+    let pendingDeletes = [];
+    const flushDeletes = (index) => {
+        const plan = planDeletion
+            ? planDeletion(scene, pendingDeletes)
+            : planNodeDeletion(scene, pendingDeletes, { mintDefaults: false });
+        for (const id of plan.unsettledIds)
+            regenerated.set(id, index);
+        for (const id of plan.regeneratedHostIds)
+            regeneratedHosts.set(id, index);
+        scene = { nodes: plan.nodes, rootNodeIds: plan.rootNodeIds, collections: plan.collections };
+        pendingDeletes = [];
+    };
+    patches.forEach((patch, index) => {
+        if (patch.op === 'create') {
+            // Parse like the store does, so defaults such as an empty `children`
+            // list exist for later ops in the patch; the bridge reports schema errors.
+            const parsed = parseNode(patch.node);
+            const node = (parsed.success ? parsed.data : patch.node);
+            if (typeof node?.id !== 'string')
+                return;
+            const preset = unknownMaterialPresetRefusal(node);
+            if (preset)
+                throw new Error(`invalid patch: patches[${index}] create "${node.id}": ${preset}`);
+            refuseRegenerated(index, node.id);
+            const effectiveParentId = patch.parentId ?? node.parentId;
+            if (effectiveParentId)
+                refuseRegenerated(index, effectiveParentId);
+            if (at(node.id) || (!planDeletion && initialIds.has(node.id))) {
+                throw new PatchRefusedError('node_exists', index, node.id, planDeletion || at(node.id)
+                    ? `create id "${node.id}" already exists. Use op "update" to change it, or delete it earlier in the same patch to replace it.`
+                    : `create id "${node.id}" existed when the patch started, and this bridge cannot preview its deletes. Delete it in one apply_patch call and create it in the next.`);
+            }
+            const parentId = patch.parentId ?? node.parentId ?? null;
+            if (patch.parentId !== undefined && !at(patch.parentId)) {
+                throw new Error(`invalid patch: patches[${index}] create parentId "${patch.parentId}" not found`);
+            }
+            put({ ...node, parentId });
+            const parent = parentId ? at(parentId) : undefined;
+            if (parent)
+                put(withChild(parent, node.id));
+            return;
+        }
+        if (patch.op === 'update') {
+            refuseRegenerated(index, patch.id);
+            const hostDeleteIndex = regeneratedHosts.get(patch.id);
+            if (hostDeleteIndex !== undefined) {
+                throw new PatchRefusedError('regenerated_default', index, patch.id, `the edit at patches[${hostDeleteIndex}] regenerates the default gutters and downspouts under "${patch.id}", so its children are not known yet. Update it in a separate apply_patch call.`);
+            }
+            if (typeof patch.data?.parentId === 'string')
+                refuseRegenerated(index, patch.data.parentId);
+            const current = at(patch.id);
+            if (!current)
+                throw new Error(`invalid patch: patches[${index}] update id "${patch.id}" not found`);
+            if (!patch.data || typeof patch.data !== 'object')
+                return;
+            const data = patch.data;
+            for (const [field, code] of IMMUTABLE_FIELDS) {
+                const before = current[field];
+                if (field in data && !sameValue(data[field], before)) {
+                    throw new PatchRefusedError(code, index, patch.id, `update cannot change "${field}" of "${patch.id}" (${JSON.stringify(before)} → ${JSON.stringify(data[field])}). Create a new node, delete the old one, or reparent children through their own parentId.`);
+                }
+            }
+            const scripted = scriptedFieldRefusal(current, data);
+            if (scripted)
+                throw new PatchRefusedError('scripted_field', index, patch.id, scripted);
+            const preset = unknownMaterialPresetRefusal(data, current);
+            if (preset)
+                throw new PatchRefusedError('invalid_update', index, patch.id, preset);
+            const merged = { ...current, ...data };
+            const issuesAfter = schemaIssues(merged);
+            if (issuesAfter && issuesAfter.size > 0) {
+                const issuesBefore = schemaIssues(current) ?? new Set();
+                const added = [...issuesAfter].filter((issue) => !issuesBefore.has(issue));
+                if (added.length > 0) {
+                    throw new PatchRefusedError('invalid_update', index, patch.id, `update of ${current.type} "${patch.id}" fails its schema: ${added.slice(0, 5).join('; ')}`);
+                }
+            }
+            if ('parentId' in data && data.parentId !== current.parentId) {
+                const newParent = typeof data.parentId === 'string' ? at(data.parentId) : undefined;
+                if (!(newParent && Array.isArray(newParent.children))) {
+                    throw new PatchRefusedError('invalid_parent', index, patch.id, `update cannot move "${patch.id}" under ${JSON.stringify(data.parentId)}: ${newParent ? `a ${newParent.type} holds no children` : 'no such node'}.`);
+                }
+                const before = { ...scene.nodes };
+                const oldParent = current.parentId ? at(current.parentId) : undefined;
+                if (oldParent)
+                    put(withoutChild(oldParent, patch.id));
+                put(withChild(newParent, patch.id));
+                put(merged);
+                unsettleRoofRefresh(merged, index);
+                try {
+                    validateNodeRelations(before, scene.nodes, [patch.id]);
+                }
+                catch (err) {
+                    throw new PatchRefusedError('invalid_parent', index, patch.id, `${newParent.type} "${newParent.id}" does not accept "${patch.id}": ${err instanceof Error ? err.message : String(err)}`);
+                }
+                return;
+            }
+            put(merged);
+            unsettleRoofRefresh(merged, index);
+            return;
+        }
+        if (patch.op === 'delete') {
+            refuseRegenerated(index, patch.id);
+            if (!at(patch.id) || pendingDeletes.includes(patch.id)) {
+                throw new Error(`invalid patch: patches[${index}] delete id "${patch.id}" not found`);
+            }
+            pendingDeletes.push(patch.id);
+            // The bridge applies a run of consecutive deletes as one deleteNodes
+            // call, and wall merges and kind cascades depend on the whole id list,
+            // so plan the run together once it ends.
+            if (patches[index + 1]?.op !== 'delete')
+                flushDeletes(index);
+        }
+    });
+}

package/dist/tools/photo-to-scene/index.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';
 /**
  * Register the `photo_to_scene` orchestrator tool. Chains the vision

package/dist/tools/photo-to-scene/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAEzF;AAED,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,kBAAkB,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAGvD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAEzF;AAED,OAAO,EACL,iBAAiB,EACjB,kBAAkB,EAClB,oBAAoB,GACrB,MAAM,kBAAkB,CAAA"}

package/dist/tools/photo-to-scene/photo-to-scene.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';
 /**
@@ -10,8 +10,8 @@ export declare const photoToSceneInput: {
     scaleHint: z.ZodOptional<z.ZodString>;
     name: z.ZodDefault<z.ZodString>;
     save: z.ZodDefault<z.ZodBoolean>;
-    defaultWallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
-    defaultWallHeight: z.ZodDefault<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    defaultWallThickness: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+    defaultWallHeight: z.ZodDefault<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
 };
 export declare const photoToSceneOutput: {
     sceneId: z.ZodOptional<z.ZodString>;

package/dist/tools/photo-to-scene/photo-to-scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"photo-to-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/photo-to-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AAYxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKvD;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAa7B,CAAA;AAED,eAAO,MAAM,kBAAkB;;;;;;;;CAQ9B,CAAA;AAmTD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA8ErF"}
+{"version":3,"file":"photo-to-scene.d.ts","sourceRoot":"","sources":["../../../src/tools/photo-to-scene/photo-to-scene.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAM7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAKvD;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,KAAK;IACL,SAAS;IACT,IAAI;IACJ,IAAI;IACJ,oBAAoB;IAIpB,iBAAiB;CAIlB,CAAA;AAED,eAAO,MAAM,kBAAkB;IAC7B,OAAO;IACP,GAAG;IACH,KAAK;IACL,KAAK;IACL,UAAU;IACV,KAAK;IACL,KAAK;CACN,CAAA;AAmTD,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CA8ErF"}

package/dist/tools/photo-to-scene/photo-to-scene.js

@@ -1,5 +1,6 @@
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { AnyNode, BuildingNode, LevelNode, SiteNode, WallNode, ZoneNode, } from '@pascal-app/core/schema';
+import { ProtocolError, ProtocolErrorCode } from '@modelcontextprotocol/server';
+import { newZone } from '@pascal-app/core';
+import { AnyNode, BuildingNode, LevelNode, SiteNode, WallNode } from '@pascal-app/core/schema';
 import { z } from 'zod';
 import { DESTRUCTIVE_OPEN_WORLD_TOOL_ANNOTATIONS } from '../annotations.js';
 import { appendLiveSceneEvent } from '../live-sync.js';
@@ -121,7 +122,7 @@ function extractText(content) {
 async function callVisionSampling(server, image, scaleHint) {
     const caps = server.server.getClientCapabilities();
     if (!caps?.sampling) {
-        throw new McpError(ErrorCode.InvalidRequest, 'sampling_unavailable');
+        throw new ProtocolError(ProtocolErrorCode.InvalidRequest, 'sampling_unavailable');
     }
     const imageBlock = await resolveImageBlock(image);
     const instruction = scaleHint
@@ -140,7 +141,7 @@ async function callVisionSampling(server, image, scaleHint) {
     });
     const text = extractText(response.content);
     if (!text) {
-        throw new McpError(ErrorCode.InternalError, 'sampling_response_unparseable', {
+        throw new ProtocolError(ProtocolErrorCode.InternalError, 'sampling_response_unparseable', {
             reason: 'no text content returned by host',
         });
     }
@@ -149,14 +150,14 @@ async function callVisionSampling(server, image, scaleHint) {
         parsed = JSON.parse(text);
     }
     catch (err) {
-        throw new McpError(ErrorCode.InternalError, 'sampling_response_unparseable', {
+        throw new ProtocolError(ProtocolErrorCode.InternalError, 'sampling_response_unparseable', {
             raw: text,
             reason: err instanceof Error ? err.message : String(err),
         });
     }
     const validation = VisionResponseSchema.safeParse(parsed);
     if (!validation.success) {
-        throw new McpError(ErrorCode.InternalError, 'sampling_response_invalid', {
+        throw new ProtocolError(ProtocolErrorCode.InternalError, 'sampling_response_invalid', {
             raw: text,
             errors: validation.error.issues,
         });
@@ -236,7 +237,7 @@ function buildSceneGraphFromVision(vision, defaultWallThickness, defaultWallHeig
     for (let i = 0; i < vision.rooms.length; i++) {
         const r = vision.rooms[i];
         try {
-            const zone = ZoneNode.parse({
+            const zone = newZone({
                 name: r.name,
                 polygon: r.polygon,
             });
@@ -279,8 +280,8 @@ export function registerPhotoToScene(server, bridge) {
     server.registerTool('photo_to_scene', {
         title: 'Photo to Pascal scene',
         description: 'Orchestrator: analyse a floor-plan photo via MCP sampling, translate the structured vision result into a Pascal SceneGraph (site → building → level with walls and zones), optionally save it, and swap the bridge to the new scene. Requires host support for sampling.',
-        inputSchema: photoToSceneInput,
-        outputSchema: photoToSceneOutput,
+        inputSchema: z.object(photoToSceneInput),
+        outputSchema: z.object(photoToSceneOutput),
         annotations: DESTRUCTIVE_OPEN_WORLD_TOOL_ANNOTATIONS,
     }, async ({ image, scaleHint, name, save, defaultWallThickness, defaultWallHeight }) => {
         // 1. Vision.

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

@@ -0,0 +1,4 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import { type ProjectFileToolExecutor } from '@pascal-app/core/agent-operations';
+export declare function registerProjectFileTools(server: McpServer, execute: ProjectFileToolExecutor): void;
+//# sourceMappingURL=project-files.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"project-files.d.ts","sourceRoot":"","sources":["../../src/tools/project-files.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAEL,KAAK,uBAAuB,EAC7B,MAAM,mCAAmC,CAAA;AAQ1C,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,uBAAuB,QAmC3F"}

package/dist/tools/project-files.js

@@ -0,0 +1,30 @@
+import { executeProjectFileTool, } from '@pascal-app/core/agent-operations';
+import { isAgentRefusal, PROJECT_FILE_TOOL_CONTRACTS, refusalPayload, } from '@pascal-app/core/agent-tools';
+import { z } from 'zod';
+export function registerProjectFileTools(server, execute) {
+    for (const contract of PROJECT_FILE_TOOL_CONTRACTS) {
+        server.registerTool(contract.name, {
+            title: contract.title,
+            description: contract.description,
+            inputSchema: z.object(contract.input).strict(),
+            annotations: contract.annotations,
+        }, async (input, ctx) => {
+            try {
+                const result = await executeProjectFileTool(contract.name, input, execute, ctx.mcpReq.signal);
+                return { content: [{ type: 'text', text: JSON.stringify(result) }] };
+            }
+            catch (error) {
+                const result = isAgentRefusal(error)
+                    ? refusalPayload(error)
+                    : {
+                        code: 'file_error',
+                        error: 'Could not complete the file request. List project files before retrying an upload.',
+                    };
+                return {
+                    isError: true,
+                    content: [{ type: 'text', text: JSON.stringify(result) }],
+                };
+            }
+        });
+    }
+}

package/dist/tools/redo.d.ts

@@ -1,14 +1,16 @@
-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 redoInput: {
     steps: z.ZodOptional<z.ZodNumber>;
 };
 export declare const redoOutput: {
+    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/redo.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redo.d.ts","sourceRoot":"","sources":["../../src/tools/redo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAA;AACxE,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAIpD,eAAO,MAAM,SAAS;;CAErB,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;;;CAGtB,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsB7E"}
+{"version":3,"file":"redo.d.ts","sourceRoot":"","sources":["../../src/tools/redo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AACvB,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AASpD,eAAO,MAAM,SAAS;IACpB,KAAK;CACN,CAAA;AAED,eAAO,MAAM,UAAU;;;;;;;;;;;CAGtB,CAAA;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAsB7E"}

package/dist/tools/redo.js

@@ -1,6 +1,6 @@
 import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
-import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './live-sync.js';
+import { currentLiveSync, liveSyncOutput, persistencePayload, publishLiveSceneSnapshot, } from './live-sync.js';
 export const redoInput = {
     steps: z.number().int().positive().optional(),
 };
@@ -12,12 +12,12 @@ export function registerRedo(server, bridge) {
     server.registerTool('redo', {
         title: 'Redo',
         description: 'Redo the next N previously-undone steps (default 1). Returns the number of steps actually redone.',
-        inputSchema: redoInput,
-        outputSchema: redoOutput,
+        inputSchema: z.object(redoInput),
+        outputSchema: z.object(redoOutput),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async ({ steps }) => {
         const redone = bridge.redo(steps ?? 1);
-        const persistence = redone > 0 ? await publishLiveSceneSnapshot(bridge, 'redo') : 'published';
+        const persistence = redone > 0 ? await publishLiveSceneSnapshot(bridge, 'redo') : currentLiveSync(bridge);
         const payload = { redone, ...persistencePayload(persistence) };
         return {
             content: [{ type: 'text', text: JSON.stringify(payload) }],

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

@@ -0,0 +1,10 @@
+import type { McpServer } from '@modelcontextprotocol/server';
+import { type RetiredTool } from '@pascal-app/core/agent-tools';
+/**
+ * A retired tool (`RETIRED_MCP_TOOLS`, or a host's own map) is listed nowhere and still answered: a
+ * call to its name gets `tool_retired` with the tool that replaced it and how to use that one,
+ * where the SDK would answer an unknown name with a bare error. Install it once the tools are
+ * registered.
+ */
+export declare function answerRetiredTools(server: McpServer, retired?: Readonly<Record<string, RetiredTool>>): void;
+//# sourceMappingURL=retired-tools.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"retired-tools.d.ts","sourceRoot":"","sources":["../../src/tools/retired-tools.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAEL,KAAK,WAAW,EAEjB,MAAM,8BAA8B,CAAA;AAKrC;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,SAAS,EACjB,OAAO,GAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAqB,GACjE,IAAI,CAYN"}

package/dist/tools/retired-tools.js

@@ -0,0 +1,22 @@
+import { RETIRED_MCP_TOOLS, retiredToolRefusal, } from '@pascal-app/core/agent-tools';
+import { toolError } from './errors.js';
+/**
+ * A retired tool (`RETIRED_MCP_TOOLS`, or a host's own map) is listed nowhere and still answered: a
+ * call to its name gets `tool_retired` with the tool that replaced it and how to use that one,
+ * where the SDK would answer an unknown name with a bare error. Install it once the tools are
+ * registered.
+ */
+export function answerRetiredTools(server, retired = RETIRED_MCP_TOOLS) {
+    const registry = server.server;
+    const original = registry._requestHandlers.get('tools/call');
+    if (!original)
+        return;
+    server.server.removeRequestHandler('tools/call');
+    server.server.setRequestHandler('tools/call', async (request, ctx) => {
+        const { name } = request.params;
+        if (!Object.hasOwn(retired, name))
+            return (await original(request, ctx));
+        const { error, ...answer } = retiredToolRefusal(name, retired[name]);
+        return toolError(error, answer);
+    });
+}

package/dist/tools/roof-level-guard.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=roof-level-guard.d.ts.map

package/dist/tools/roof-level-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-level-guard.d.ts","sourceRoot":"","sources":["../../src/tools/roof-level-guard.ts"],"names":[],"mappings":""}

package/dist/tools/roof-level-guard.js

@@ -0,0 +1,22 @@
+import { seatWrittenRoofs } from '@pascal-app/core/agent-operations';
+import { isAgentRefusal } from '@pascal-app/core/agent-tools';
+import { PatchRefusedError, registerPatchGuard } from './patch-guards.js';
+/**
+ * The roof-level rule: a roof the patch puts on its walls' storey is seated on the level above by
+ * ops appended to the patch, said in notes, so every refusal's patchIndex stays on the model's own
+ * op; storey content on a roof level, a walled level declared the roof level and a roof level
+ * moved under a storey are refused. After the level heights, before the identity check, which
+ * checks the appended ops too.
+ */
+function roofLevels(patches, scene) {
+    try {
+        return seatWrittenRoofs(patches, scene);
+    }
+    catch (error) {
+        if (!isAgentRefusal(error))
+            throw error;
+        const { index, id } = error.details;
+        throw new PatchRefusedError(error.code, index, id, error.message);
+    }
+}
+registerPatchGuard({ name: 'roof-levels', order: 40, run: roofLevels });