@pascal-app/mcp 1.0.6 → 1.1.0

package/dist/tools/author-scene.js

@@ -1,5 +1,6 @@
-import { achievedChanges, verifyScene, } from '@pascal-app/core/agent-operations';
-import { authorSceneTool, isAgentRefusal, } from '@pascal-app/core/agent-tools';
+import { filterDerivedNodeWrites } from '@pascal-app/core';
+import { achievedChanges, authorSceneChecks, verifyScene, } from '@pascal-app/core/agent-operations';
+import { authorScenePayload, authorSceneTool, isAgentRefusal, refuse, surfaceDescription, } 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';
@@ -8,15 +9,21 @@ 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';
+/** The largest payload file read: a house with its modules inline runs to a few MiB. */
+const PAYLOAD_FILE_MAX_BYTES = 32 * 1024 * 1024;
+/** Payload keys holding a module's text; stored as `<key>Script`, the script's hash. */
+const CODE_KEYS = new Set(['code', 'floorCode', 'wallCode']);
 /**
- * `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.
+ * `author_scene` on the MCP: the payload given, or the one the adapter answers on the module (the
+ * stored module and adapter, changed by edits, when left out), or the stored conversion again;
+ * items naming a piece written with its module, those still being made left for the host to write
+ * when they land; every module compiled and stored through the host, the operation applied,
+ * Pascal's checks run, and the gate report answered.
  */
-export function registerAuthorScene(server, bridge, host) {
+export function registerAuthorScene(server, bridge, host, makers, readFile) {
     server.registerTool(authorSceneTool.name, {
         title: authorSceneTool.title,
-        description: authorSceneTool.description,
+        description: surfaceDescription(authorSceneTool, 'mcp'),
         inputSchema: z.object(authorSceneTool.input),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async (input) => {
@@ -46,9 +53,39 @@ export function registerAuthorScene(server, bridge, host) {
                 ? { materials: bridge.getMaterials() }
                 : {}),
         };
+        const readText = async (sha256) => {
+            const bytes = await host.readArtifact({ sceneId: scene.id, sha256 });
+            if (!bytes)
+                throw new Error(`The stored script ${sha256} could not be read`);
+            return new TextDecoder().decode(bytes);
+        };
+        let source;
+        try {
+            const readPayloadFile = async (fileId) => {
+                if (!readFile)
+                    refuse('files_unavailable', 'This Pascal server keeps no project files: pass the payload itself.');
+                return new TextDecoder().decode(await readFile({
+                    projectId: scene.projectId ?? undefined,
+                    fileId,
+                    maxBytes: PAYLOAD_FILE_MAX_BYTES,
+                    signal: host.signal,
+                }));
+            };
+            source = await sourceOf(args, storedConversion(before, args.buildingId), host, readText, readPayloadFile);
+        }
+        catch (error) {
+            if (isAgentRefusal(error))
+                return refusalResult(error);
+            return toolError(error instanceof Error ? error.message : String(error), {
+                code: 'conversion_failed',
+            });
+        }
+        if ('failed' in source)
+            return source.failed;
+        const pieces = await withPieces(source.payload, scene.id, makers);
         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);
+            outcome = await compileAuthorScene(before, { payload: pieces.payload, replace: args.replace, buildingId: args.buildingId }, context, ({ code, kind, inputs, nodeId }) => compileAndStore(host, scene.id, { code, language: 'three', params: undefined, inputs }, kind, { nodeId }), host.signal);
         }
         catch (error) {
             if (isAgentRefusal(error))
@@ -59,54 +96,76 @@ export function registerAuthorScene(server, bridge, host) {
         }
         // 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' },
-            });
+        for (const kind of ['module', 'adapter']) {
+            const text = source.texts[kind];
+            const kept = source.changed[kind] && text !== undefined
+                ? await host.storeArtifact({
+                    sceneId: scene.id,
+                    sha256: await sha256(text),
+                    bytes: new TextEncoder().encode(text),
+                    mimeType: GEOMETRY_SCRIPT_MIME_TYPES.three,
+                    metadata: { kind: 'item' },
+                })
+                : source.stored[kind];
+            if (kept)
+                provenance[kind] = kept;
         }
         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 report = {
+            ...outcome.result,
+            defects: [...pieces.defects, ...outcome.result.defects],
+        };
+        const payloadText = storedPayloadText(await withScripts(source.payload));
+        const payloadScript = await host.storeArtifact({
+            sceneId: scene.id,
+            sha256: await sha256(payloadText),
+            bytes: new TextEncoder().encode(payloadText),
+            mimeType: GEOMETRY_SCRIPT_MIME_TYPES.three,
+            metadata: { kind: 'item' },
+        });
         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 stored = {
+            ...provenance,
+            payload: payloadScript,
+            pending: pieces.pending,
+            at: new Date().toISOString(),
         };
-        const patches = toPatches(outcome.changes);
+        buildingUpdate.data.metadata = JSON.parse(JSON.stringify({ ...buildingUpdate.data.metadata, authorScene: stored }));
+        // A revision's plates and ceilings follow its walls: what only the reconciler may change on
+        // one that stays (its outline, its room) is left to the bridge's reconciliation after the
+        // write, as in the editor; a new room's arrive with it.
+        const patches = toPatches(filterDerivedNodeWrites(bridge.getNodes(), outcome.changes));
         if (patches.length)
             bridge.applyPatch(patches);
-        const checks = verifyScene(bridge.getNodes(), undefined, {
+        const verified = verifyScene(bridge.getNodes(), undefined, {
             activeLevelId: null,
         }).result;
         const byType = new Map();
-        for (const issue of checks.issues)
+        for (const issue of verified.issues)
             byType.set(issue.type ?? 'unknown', (byType.get(issue.type ?? 'unknown') ?? 0) + 1);
+        const checks = authorSceneChecks({
+            payload: source.payload,
+            report,
+            pending: pieces.pending,
+            issues: verified.issues.filter((issue) => issue.severity !== 'info'),
+        });
         const payload = {
-            ...outcome.result,
+            ...report,
+            pending: pieces.pending,
+            checks,
+            complete: pieces.pending.length === 0 && checks.every((check) => check.passed),
             itemTriangles: outcome.itemTriangles,
             itemsCompiled: outcome.itemsCompiled,
-            green: outcome.result.defects.length === 0,
+            green: report.defects.length === 0,
             verify: {
-                valid: checks.valid,
-                issues: checks.issues.length,
+                valid: verified.valid,
+                issues: verified.issues.length,
                 byType: Object.fromEntries(byType),
-                first: checks.issues.slice(0, 40).map((i) => i.message),
+                first: verified.issues.slice(0, 40).map((i) => i.message),
             },
             achieved: achievedChanges(before, outcome.changes ?? {}),
             ...persistencePayload(await publishLiveSceneSnapshot(bridge, authorSceneTool.name)),
@@ -117,23 +176,215 @@ export function registerAuthorScene(server, bridge, host) {
         };
     });
 }
-/** The payload as kept with the scene: every module is already its own artifact. */
-function withoutCode(payload) {
+/** The building a conversion revises: the one named, else the one holding a conversion. */
+function storedConversion(nodes, buildingId) {
+    const holds = (node) => node?.type === 'building'
+        ? (node.metadata?.authorScene ?? null)
+        : null;
+    if (buildingId)
+        return holds(nodes[buildingId]) ?? undefined;
+    return Object.values(nodes).map(holds).find(Boolean) ?? undefined;
+}
+/**
+ * The payload to write, with the module and adapter it came from: given, or read from its project
+ * file; answered by the adapter on the module (each the one given or stored, changed by the edits);
+ * or the stored conversion again.
+ * An adapter that throws, or answers no valid payload, is answered with why, and nothing is written.
+ */
+async function sourceOf(args, stored, host, readText, readPayloadFile) {
+    const edits = args.edits ?? [];
+    const changed = {
+        module: args.module !== undefined || edits.some((edit) => edit.in === 'module'),
+        adapter: args.adapter !== undefined || edits.some((edit) => edit.in === 'adapter'),
+    };
+    const result = (payload, texts) => ({
+        payload,
+        texts,
+        changed,
+        stored: { module: stored?.module, adapter: stored?.adapter },
+    });
+    if (args.payload && args.payloadFile)
+        refuse('payload_twice', 'Pass the payload or its payloadFile, not both.');
+    if (args.payload || args.payloadFile) {
+        if (edits.length)
+            refuse('edits_with_payload', 'Edits change the module or the adapter Pascal runs: leave the payload out to have it run.');
+        const texts = { module: args.module, adapter: args.adapter };
+        if (args.payload)
+            return result(args.payload, texts);
+        let answered;
+        try {
+            answered = JSON.parse(await readPayloadFile(args.payloadFile));
+        }
+        catch (error) {
+            if (!(error instanceof SyntaxError))
+                throw error;
+            return {
+                failed: toolError(`The payload file is not JSON: ${error.message}`, {
+                    code: 'payload_invalid',
+                    mutationApplied: false,
+                }),
+            };
+        }
+        const parsed = parsedPayload(answered, 'The payload file');
+        return 'failed' in parsed ? parsed : result(parsed.payload, texts);
+    }
+    if (args.module !== undefined || args.adapter !== undefined || edits.length) {
+        const texts = {
+            module: args.module ?? (stored?.module ? await readText(stored.module) : undefined),
+            adapter: args.adapter ?? (stored?.adapter ? await readText(stored.adapter) : undefined),
+        };
+        edits.forEach((edit, index) => {
+            const text = texts[edit.in];
+            if (text === undefined)
+                refuse('edit_without_source', `Edit ${index}: there is no ${edit.in} to change. Pass it, or convert with one first.`, { edit: index });
+            const at = text.indexOf(edit.find);
+            if (at < 0)
+                refuse('edit_not_found', `Edit ${index}: its find text is not in the ${edit.in}.`, {
+                    edit: index,
+                });
+            if (text.indexOf(edit.find, at + 1) >= 0)
+                refuse('edit_ambiguous', `Edit ${index}: its find text occurs more than once in the ${edit.in}; give more of it.`, { edit: index });
+            texts[edit.in] = text.slice(0, at) + edit.replace + text.slice(at + edit.find.length);
+        });
+        if (texts.adapter === undefined)
+            refuse('adapter_required', 'This scene stores no adapter: pass the payload, or the module and its adapter together in one call.');
+        if (texts.module === undefined)
+            refuse('module_required', 'This scene stores no module: pass the module and its adapter together in one call.');
+        if (!host.runAdapter)
+            refuse('adapter_unavailable', 'This Pascal server cannot run an adapter: pass the payload.');
+        let answered;
+        try {
+            answered = (await host.runAdapter({ adapter: texts.adapter, design: texts.module })).payload;
+        }
+        catch (error) {
+            return {
+                failed: toolError(`Your adapter failed: ${error instanceof Error ? error.message : String(error)}`, { code: 'adapter_failed', mutationApplied: false }),
+            };
+        }
+        const parsed = parsedPayload(answered, "Your adapter's payload");
+        return 'failed' in parsed ? parsed : result(parsed.payload, texts);
+    }
+    if (typeof stored?.payload !== 'string')
+        refuse('nothing_to_write', 'Pass a payload, or a module and its adapter: this scene holds no stored conversion to write again.');
+    const rehydrated = (await withCode(readStoredPayload(await readText(stored.payload)), readText));
+    const parsed = authorScenePayload.safeParse(rehydrated);
+    if (!parsed.success)
+        refuse('stored_conversion_unreadable', 'The stored conversion could not be read back: pass the payload, or the module and its adapter.');
+    return result(parsed.data, {});
+}
+/** A payload read from an adapter or a file, or why it does not match author_scene's. */
+function parsedPayload(value, what) {
+    const parsed = authorScenePayload.safeParse(value);
+    if (parsed.success)
+        return { payload: parsed.data };
     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),
-        })),
+        failed: toolError(`${what} does not match author_scene's: ${parsed.error.issues
+            .slice(0, 12)
+            .map((issue) => `${issue.path.join('.')}: ${issue.message}`)
+            .join('; ')}`, {
+            code: 'payload_invalid',
+            mutationApplied: false,
+            issues: parsed.error.issues
+                .slice(0, 40)
+                .map((issue) => ({ path: issue.path.join('.'), message: issue.message })),
+        }),
     };
 }
+/**
+ * Items naming a piece, with its module once made; those still being made left out and listed as
+ * pending (the host writes them when they land); one that failed, is unknown or has no module, a
+ * defect by its id.
+ */
+async function withPieces(payload, sceneId, makers) {
+    const items = [
+        ...payload.levels.flatMap((level) => level.items ?? []),
+        ...(payload.roof?.items ?? []),
+    ];
+    const ids = [...new Set(items.flatMap((item) => (item.piece ? [item.piece] : [])))];
+    const states = ids.length && makers ? await makers.pieces({ sceneId, ids }) : {};
+    const pending = [];
+    const defects = [];
+    const resolve = (list) => list?.flatMap(({ piece, ...item }) => {
+        if (!piece) {
+            if (item.code)
+                return [item];
+            defects.push({ id: item.id, code: 'no_module', message: 'It has neither code nor piece.' });
+            return [];
+        }
+        const state = states[piece];
+        if (state?.status === 'made')
+            return [{ ...item, code: state.code }];
+        if (state?.status === 'making')
+            pending.push({ id: item.id, piece });
+        else
+            defects.push(!makers
+                ? {
+                    id: item.id,
+                    code: 'pieces_unavailable',
+                    message: 'This Pascal server makes no pieces: give the item its code.',
+                }
+                : state
+                    ? { id: item.id, code: 'piece_failed', message: state.error }
+                    : {
+                        id: item.id,
+                        code: 'piece_unknown',
+                        message: `No piece "${piece}": make it with add_object's piece first.`,
+                    });
+        return [];
+    });
+    return {
+        payload: {
+            ...payload,
+            levels: payload.levels.map((level) => ({ ...level, items: resolve(level.items) })),
+            ...(payload.roof ? { roof: { ...payload.roof, items: resolve(payload.roof.items) } } : {}),
+        },
+        pending,
+        defects,
+    };
+}
+const STORED_PAYLOAD_PREFIX = 'export default ';
+/** The payload as a module of the scene, the one script type its files take. */
+const storedPayloadText = (payload) => `${STORED_PAYLOAD_PREFIX}${JSON.stringify(payload)}\n`;
+function readStoredPayload(text) {
+    if (!text.startsWith(STORED_PAYLOAD_PREFIX))
+        return undefined;
+    try {
+        return JSON.parse(text.slice(STORED_PAYLOAD_PREFIX.length));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** The payload as kept with the scene: every module as its stored script's hash, pieces by id. */
+async function withScripts(value) {
+    if (Array.isArray(value))
+        return Promise.all(value.map(withScripts));
+    if (!value || typeof value !== 'object')
+        return value;
+    const out = {};
+    for (const [key, entry] of Object.entries(value))
+        if (CODE_KEYS.has(key) && typeof entry === 'string')
+            out[`${key}Script`] = await sha256(entry);
+        else
+            out[key] = await withScripts(entry);
+    return out;
+}
+/** The stored payload with its modules read back; one whose script is gone is left without it. */
+async function withCode(value, readText) {
+    if (Array.isArray(value))
+        return Promise.all(value.map((entry) => withCode(entry, readText)));
+    if (!value || typeof value !== 'object')
+        return value;
+    const out = {};
+    for (const [key, entry] of Object.entries(value)) {
+        const base = key.endsWith('Script') ? key.slice(0, -'Script'.length) : null;
+        if (base && CODE_KEYS.has(base) && typeof entry === 'string')
+            out[base] = await readText(entry).catch(() => undefined);
+        else
+            out[key] = await withCode(entry, readText);
+    }
+    return out;
+}
 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/clear-scene.js

@@ -1,4 +1,4 @@
-import { clearSceneTool } from '@pascal-app/core/agent-tools';
+import { clearSceneTool, surfaceDescription } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
 import { DESTRUCTIVE_TOOL_ANNOTATIONS } from './annotations.js';
 import { refusalResult } from './errors.js';
@@ -11,7 +11,7 @@ import { liveSyncOutput, persistencePayload, publishLiveSceneSnapshot } from './
 export function registerClearScene(server, operations) {
     server.registerTool(clearSceneTool.name, {
         title: clearSceneTool.title,
-        description: clearSceneTool.description,
+        description: surfaceDescription(clearSceneTool, 'mcp'),
         inputSchema: z.object(clearSceneTool.input),
         outputSchema: z.object({
             cleared: z.object({ removed: z.number() }),

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,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"}
+{"version":3,"file":"collections.d.ts","sourceRoot":"","sources":["../../src/tools/collections.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAiB7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAiBpD,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,eAAe,GAAG,IAAI,CAgDxF"}

package/dist/tools/collections.js

@@ -1,9 +1,11 @@
 import { editCollection, listCollections, writeCollections, } from '@pascal-app/core/agent-operations';
-import { editCollectionTool, listCollectionsTool } from '@pascal-app/core/agent-tools';
+import { editCollectionTool, listCollectionsTool, surfaceDescription, } from '@pascal-app/core/agent-tools';
+import { untracked } from '@pascal-app/core/runtime';
 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';
+import { inScene } from './scene-scope.js';
 // The collection tools share contracts and operations with the chat; they read the scene's
 // collections beside its nodes, which the node-only shared operations never see.
 function sceneOf(bridge) {
@@ -15,7 +17,7 @@ function reply(payload) {
 export function registerCollectionTools(server, bridge) {
     server.registerTool(listCollectionsTool.name, {
         title: listCollectionsTool.title,
-        description: listCollectionsTool.description,
+        description: surfaceDescription(listCollectionsTool, 'mcp'),
         inputSchema: z.object(listCollectionsTool.input),
         annotations: READ_ONLY_TOOL_ANNOTATIONS,
     }, async (input) => {
@@ -28,13 +30,13 @@ export function registerCollectionTools(server, bridge) {
     });
     server.registerTool(editCollectionTool.name, {
         title: editCollectionTool.title,
-        description: editCollectionTool.description,
+        description: surfaceDescription(editCollectionTool, 'mcp'),
         inputSchema: z.object(editCollectionTool.input),
         annotations: DESTRUCTIVE_TOOL_ANNOTATIONS,
     }, async (input) => {
         let outcome;
         try {
-            outcome = editCollection(sceneOf(bridge), input);
+            outcome = inScene(bridge, () => editCollection(sceneOf(bridge), input));
         }
         catch (error) {
             return refusalResult(error);
@@ -43,7 +45,8 @@ export function registerCollectionTools(server, bridge) {
         bridge.runAsSingleHistoryStep(() => {
             if (update?.length)
                 bridge.applyPatch(update.map(({ id, data }) => ({ op: 'update', id: id, data })));
-            bridge.setCollections(writeCollections(bridge.getCollections(), collections));
+            // Writing the other collections back is a copy, not a read of them.
+            bridge.setCollections(writeCollections(untracked(bridge.getCollections()), collections));
         });
         return reply({
             ...outcome.result,

package/dist/tools/honest-patch-guard.js

@@ -7,14 +7,15 @@ import { PatchRefusedError, registerPatchGuard } from './patch-guards.js';
  * one hides is refused, naming it; `null` clears. The cleaned data is what is written.
  */
 function honestUpdates(patches, scene) {
-    const nodes = { ...scene };
+    // The batch over the scene, read id by id.
+    const written = new Map();
     for (const [index, patch] of patches.entries()) {
         if (patch.op === 'create')
-            nodes[patch.node.id] = patch.node;
+            written.set(patch.node.id, patch.node);
         else if (patch.op === 'delete')
-            delete nodes[patch.id];
+            written.set(patch.id, undefined);
         else if (patch.op === 'update') {
-            const current = nodes[patch.id];
+            const current = written.has(patch.id) ? written.get(patch.id) : scene[patch.id];
             if (!current)
                 continue;
             try {
@@ -25,7 +26,7 @@ function honestUpdates(patches, scene) {
                     throw error;
                 throw new PatchRefusedError(error.code, index, patch.id, error.message);
             }
-            nodes[patch.id] = { ...current, ...patch.data };
+            written.set(patch.id, { ...current, ...patch.data });
         }
     }
 }

package/dist/tools/hosted-services.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"hosted-services.d.ts","sourceRoot":"","sources":["../../src/tools/hosted-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAA;AAQ1C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,qBAAqB,GAC7B,IAAI,CA8CN"}
+{"version":3,"file":"hosted-services.d.ts","sourceRoot":"","sources":["../../src/tools/hosted-services.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,mCAAmC,CAAA;AAS1C,wBAAgB,0BAA0B,CACxC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,qBAAqB,GAC7B,IAAI,CA8CN"}

package/dist/tools/hosted-services.js

@@ -1,11 +1,11 @@
 import { executeHostedServiceTool, } from '@pascal-app/core/agent-operations';
-import { HOSTED_SERVICE_TOOL_CONTRACTS, isAgentRefusal, refusalPayload, } from '@pascal-app/core/agent-tools';
+import { HOSTED_SERVICE_TOOL_CONTRACTS, isAgentRefusal, refusalPayload, surfaceDescription, } from '@pascal-app/core/agent-tools';
 import { z } from 'zod';
 export function registerHostedServiceTools(server, execute) {
     for (const contract of HOSTED_SERVICE_TOOL_CONTRACTS) {
         server.registerTool(contract.name, {
             title: contract.title,
-            description: contract.description,
+            description: surfaceDescription(contract, 'mcp'),
             inputSchema: z.object(contract.input).strict(),
             annotations: contract.annotations,
         }, async (input, ctx) => {

package/dist/tools/index.d.ts

@@ -1,6 +1,7 @@
 import type { McpServer } from '@modelcontextprotocol/server';
+import type { ProjectFileReader } from '@pascal-app/core/agent-operations';
 import type { SceneOperations } from '../operations/index.js';
-import { type GeometryScriptHost } from './add-object.js';
+import { type GeometryScriptHost, type ObjectMakerHost } from './add-object.js';
 import type { AssetCatalog } from './asset-catalog.js';
 import { type PlanReadingHosts } from './shared-tools.js';
 import { type SceneViewHost } from './view-scene.js';
@@ -16,7 +17,11 @@ import { type SceneViewHost } from './view-scene.js';
 export type ToolHosts = PlanReadingHosts & {
     catalog?: AssetCatalog;
     geometryScripts?: GeometryScriptHost;
+    /** Makes add_object's pieces from words; without it a piece is refused `pieces_unavailable`. */
+    objectMakers?: ObjectMakerHost;
+    /** Reads author_scene's payloadFile; without it the tool refuses one `files_unavailable`. */
+    readFile?: ProjectFileReader;
     sceneViews?: SceneViewHost;
 };
-export declare function registerTools(server: McpServer, operations: SceneOperations, { catalog, geometryScripts, sceneViews, assetViews }?: ToolHosts): void;
+export declare function registerTools(server: McpServer, operations: SceneOperations, { catalog, geometryScripts, objectMakers, readFile, sceneViews, assetViews }?: ToolHosts): void;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAiBnD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,gBAAgB,CAAA;AAI3E,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAEpE;;;;;;;GAOG;AACH,gFAAgF;AAChF,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG;IACzC,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,eAAe,CAAC,EAAE,kBAAkB,CAAA;IACpC,UAAU,CAAC,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,eAAe,EAC3B,EAAE,OAAO,EAAE,eAAe,EAAE,UAAU,EAAE,UAAU,EAAE,GAAE,SAAc,GACnE,IAAI,CA+BN"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/tools/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,8BAA8B,CAAA;AAC7D,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,mCAAmC,CAAA;AAC1E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAA;AAEpD,OAAO,EAEL,KAAK,kBAAkB,EACvB,KAAK,eAAe,EAGrB,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,iBAAiB,CAAA;AAcnD,OAAO,EAAE,KAAK,gBAAgB,EAAuB,MAAM,gBAAgB,CAAA;AAI3E,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,cAAc,CAAA;AAEpE;;;;;;;GAOG;AACH,gFAAgF;AAChF,MAAM,MAAM,SAAS,GAAG,gBAAgB,GAAG;IACzC,OAAO,CAAC,EAAE,YAAY,CAAA;IACtB,eAAe,CAAC,EAAE,kBAAkB,CAAA;IACpC,gGAAgG;IAChG,YAAY,CAAC,EAAE,eAAe,CAAA;IAC9B,6FAA6F;IAC7F,QAAQ,CAAC,EAAE,iBAAiB,CAAA;IAC5B,UAAU,CAAC,EAAE,aAAa,CAAA;CAC3B,CAAA;AAED,wBAAgB,aAAa,CAC3B,MAAM,EAAE,SAAS,EACjB,UAAU,EAAE,eAAe,EAC3B,EAAE,OAAO,EAAE,eAAe,EAAE,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,GAAE,SAAc,GAC3F,IAAI,CA4BN"}

package/dist/tools/index.js

@@ -5,32 +5,29 @@ import { registerAuthorScene } from './author-scene.js';
 import { registerCheckCollisions } from './check-collisions.js';
 import { registerClearScene } from './clear-scene.js';
 import { registerConstructionTools } from './construction-tools.js';
-import { registerCreateUnit } from './create-unit.js';
 import { registerExportGlb } from './export-glb.js';
 import { registerExportJson } from './export-json.js';
 import { registerGetScene } from './get-scene.js';
-import { registerListUnits } from './list-units.js';
 import { registerMeasure } from './measure.js';
 import { registerPhotoToSceneTool } from './photo-to-scene/index.js';
 import { registerRedo } from './redo.js';
 import { registerRoomTools } from './room-tools.js';
 import { registerSceneLifecycleTools } from './scene-lifecycle/index.js';
-import { registerSetUnitMembers } from './set-unit-members.js';
 import { registerSetZone } from './set-zone.js';
 import { registerSharedTools } from './shared-tools.js';
 import { registerTemplateTools } from './templates/index.js';
 import { registerUndo } from './undo.js';
 import { registerVariantTools } from './variants/index.js';
 import { registerViewScene } from './view-scene.js';
-export function registerTools(server, operations, { catalog, geometryScripts, sceneViews, assetViews } = {}) {
+export function registerTools(server, operations, { catalog, geometryScripts, objectMakers, readFile, sceneViews, assetViews } = {}) {
     registerGetScene(server, operations);
     registerSharedTools(server, operations, catalog, {
         assetViews,
         buildObject: (input) => compileObjectOnHost(geometryScripts, operations, input),
     });
     registerAddColumn(server, operations, geometryScripts);
-    registerAddObject(server, operations, geometryScripts);
-    registerAuthorScene(server, operations, geometryScripts);
+    registerAddObject(server, operations, geometryScripts, objectMakers);
+    registerAuthorScene(server, operations, geometryScripts, objectMakers, readFile);
     registerGetSource(server, operations, geometryScripts);
     registerMeasure(server, operations);
     registerViewScene(server, operations, sceneViews);
@@ -38,9 +35,6 @@ export function registerTools(server, operations, { catalog, geometryScripts, sc
     registerRoomTools(server, operations, geometryScripts);
     registerApplyPatch(server, operations);
     registerClearScene(server, operations);
-    registerCreateUnit(server, operations);
-    registerSetUnitMembers(server, operations);
-    registerListUnits(server, operations);
     registerSetZone(server, operations);
     registerUndo(server, operations);
     registerRedo(server, operations);

package/dist/tools/local-geometry-scripts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"local-geometry-scripts.d.ts","sourceRoot":"","sources":["../../src/tools/local-geometry-scripts.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,CA4D5E"}
+{"version":3,"file":"local-geometry-scripts.d.ts","sourceRoot":"","sources":["../../src/tools/local-geometry-scripts.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtD;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,MAAM,GAAG,kBAAkB,CAkE5E"}

package/dist/tools/local-geometry-scripts.js

@@ -1,5 +1,6 @@
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
+import { sdfChecksOn } from '@pascal-app/core/usage-field';
 import { compileBlenderBuild } from '@pascal-app/geometry-script/blender';
 import { runBlenderLocally } from '@pascal-app/geometry-script/blender-local';
 import { DiskArtifactStore } from '../storage/disk-artifact-store.js';
@@ -17,7 +18,11 @@ export function localGeometryScripts(projectPath) {
                 if (!blender)
                     throw new Error('bpy scripts need PASCAL_BLENDER, the path to a Blender binary');
                 const run = await runBlenderLocally({ blender, code: input.code, params: input.params });
-                const { glb, ...compiled } = await compileBlenderBuild({ ...input, run });
+                const { glb, ...compiled } = await compileBlenderBuild({
+                    ...input,
+                    run,
+                    ...(sdfChecksOn() ? { usageShape: true } : {}),
+                });
                 return { ...compiled, glb: new Uint8Array(glb) };
             }
             if (process.env.PASCAL_SERVER_SCRIPT_COMPILE !== '1') {
@@ -55,7 +60,7 @@ export function localGeometryScripts(projectPath) {
                         reject(new Error(`Geometry script compilation failed: ${stderr}`));
                     }
                 });
-                child.stdin.end(JSON.stringify(input));
+                child.stdin.end(JSON.stringify({ ...input, ...(sdfChecksOn() ? { usageShape: true } : {}) }));
             });
         },
         storeArtifact: async ({ sha256, bytes }) => {