@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-tools/contract.d.ts

@@ -0,0 +1,68 @@
+import type { z } from 'zod';
+/**
+ * MCP tool annotations. Hints for clients and for a host's display, never authorization: a host
+ * decides what a tool may do (write scope, retries, approvals) from its own review of the
+ * operation, not from what a contract declares about itself.
+ */
+export type AgentToolAnnotations = {
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+};
+/**
+ * One agent tool as every surface registers it: the name and description the agent reads, and its
+ * input schema. Zod only, so it can be imported where the hosted chat declares its tools.
+ */
+export type AgentToolContract<Input extends Record<string, z.ZodType> = Record<string, z.ZodType>> = {
+    name: string;
+    title: string;
+    description: string;
+    input: Input;
+    annotations?: AgentToolAnnotations;
+};
+/**
+ * Where a plugin's tool runs. `'operation'`: a pure `AgentOperation` over the scene's nodes,
+ * exported from the plugin's `./agent-operations`, so any surface can run it, a server included.
+ * `'editor'`: it needs the live editor (a renderer, the plugin's own stores, the browser), so it
+ * runs in an editor tab open on the project; a surface without one refuses it or hands it to one.
+ */
+export type PluginAgentToolPlacement = 'operation' | 'editor';
+export type PluginAgentTool = AgentToolContract & {
+    runsIn: PluginAgentToolPlacement;
+    /** The call produces a view (a drawing, a report) the host may open beside the scene. */
+    rendersView?: boolean;
+    /** How long a call may take, in milliseconds; the host clamps it to its own limits. */
+    timeoutMs?: number;
+    /**
+     * The plugin asks for this tool in a chat only (it needs the conversation, e.g. it asks the
+     * person something). A request the host reviews, not a way around surface parity.
+     */
+    chatOnly?: boolean;
+};
+/** Knowledge an agent loads on demand: the index shows `name` and `summary`, a load returns `body`. */
+export type PluginSkill = {
+    name: string;
+    summary: string;
+    body: string;
+};
+/**
+ * Everything a plugin contributes to an agent, exported from its `./agent-tools` entry, which,
+ * like this module, imports zod and its own dependency-free files only.
+ */
+export type PluginAgentTools = {
+    /** The `Plugin.id` these tools belong to; a host offers them only where the plugin is installed. */
+    pluginId: string;
+    /** The shape of this object. */
+    apiVersion: 1;
+    /**
+     * The revision of the plugin's contracts. Bump it whenever a tool's name, input or meaning
+     * changes, so a host can pin the exact contracts a run was offered and refuse a stale executor.
+     */
+    version: string;
+    tools: readonly PluginAgentTool[];
+    skills?: readonly PluginSkill[];
+    /** Guidance added to the agent's instructions while the plugin is installed; the host may cap it. */
+    instructions?: string;
+};
+//# sourceMappingURL=contract.d.ts.map

package/dist/agent-tools/contract.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contract.d.ts","sourceRoot":"","sources":["../../src/agent-tools/contract.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAE5B;;;;GAIG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,iBAAiB,CAAC,KAAK,SAAS,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC,OAAO,CAAC,IAC/F;IACE,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,WAAW,EAAE,MAAM,CAAA;IACnB,KAAK,EAAE,KAAK,CAAA;IACZ,WAAW,CAAC,EAAE,oBAAoB,CAAA;CACnC,CAAA;AAEH;;;;;GAKG;AACH,MAAM,MAAM,wBAAwB,GAAG,WAAW,GAAG,QAAQ,CAAA;AAE7D,MAAM,MAAM,eAAe,GAAG,iBAAiB,GAAG;IAChD,MAAM,EAAE,wBAAwB,CAAA;IAChC,yFAAyF;IACzF,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,uFAAuF;IACvF,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,uGAAuG;AACvG,MAAM,MAAM,WAAW,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAEzE;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,oGAAoG;IACpG,QAAQ,EAAE,MAAM,CAAA;IAChB,gCAAgC;IAChC,UAAU,EAAE,CAAC,CAAA;IACb;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAA;IACf,KAAK,EAAE,SAAS,eAAe,EAAE,CAAA;IACjC,MAAM,CAAC,EAAE,SAAS,WAAW,EAAE,CAAA;IAC/B,qGAAqG;IACrG,YAAY,CAAC,EAAE,MAAM,CAAA;CACtB,CAAA"}

package/dist/agent-tools/contract.js

@@ -0,0 +1 @@
+export {};

package/dist/agent-tools/corner-window.d.ts

@@ -0,0 +1,46 @@
+import { z } from 'zod';
+export declare const addCornerWindowTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        corner: z.ZodArray<z.ZodNumber>;
+        wallIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        widths: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>>;
+        height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        post: z.ZodOptional<z.ZodEnum<{
+            none: "none";
+            post: "post";
+        }>>;
+        windowType: z.ZodOptional<z.ZodEnum<{
+            awning: "awning";
+            bay: "bay";
+            bow: "bow";
+            casement: "casement";
+            "double-hung": "double-hung";
+            fixed: "fixed";
+            hopper: "hopper";
+            louvered: "louvered";
+            "single-hung": "single-hung";
+            sliding: "sliding";
+        }>>;
+        style: z.ZodOptional<z.ZodEnum<{
+            casement: "casement";
+            "double-hung": "double-hung";
+            grid: "grid";
+            "horizontal-bands": "horizontal-bands";
+            picture: "picture";
+            single: "single";
+            sliding: "sliding";
+            "tall-grid": "tall-grid";
+            transom: "transom";
+            "triple-hung": "triple-hung";
+            "wide-grid": "wide-grid";
+        }>>;
+    };
+};
+//# sourceMappingURL=corner-window.d.ts.map

package/dist/agent-tools/corner-window.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"corner-window.d.ts","sourceRoot":"","sources":["../../src/agent-tools/corner-window.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAMvB,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkD/B,CAAA"}

package/dist/agent-tools/corner-window.js

@@ -0,0 +1,47 @@
+import { z } from 'zod';
+import { WINDOW_STYLES } from '../building/opening-style-presets.js';
+import { WindowType } from '../schema/nodes/opening-types.js';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+export const addCornerWindowTool = {
+    name: 'add_corner_window',
+    title: 'Add corner window',
+    description: "A window that wraps the corner where two walls meet: one window on each wall, both running to the corner and joined, the glass fused at the corner (post none, a fixed window's default) or meeting at a thin post (post post). Any angle the walls make, a bay's 135° as well as a square or an acute corner. The corner is the point the two walls end at ([x, z], as get_walls gives their ends); width is how far the glass runs along each wall from the corner, the same on both unless widths names a wall. Each side is placed by add_window's rules (height, sillHeight, windowType, style the same on both sides; with no sillHeight, centred on the lower of the two walls). The walls are the level's (levelId, default the floor the person is viewing): stacked storeys share their corners' points. Refused with a code: no_corner where no two walls of the level end at the point, corner_ambiguous where more than two do (name two with wallIds), corner_angle for a corner nearly folded back or nearly straight, corner_not_fused for post none on a window type other than fixed, width_exceeds_wall. Returns windowIds and wallIds; the editor's window panel shows the pair under Corner.",
+    input: {
+        corner: z
+            .array(z.number())
+            .length(2)
+            .describe("The point where the two walls meet, [x, z] in the level's plan (m)."),
+        ...levelTarget,
+        wallIds: z
+            .array(z.string())
+            .length(2)
+            .optional()
+            .describe('The two walls, when more than two end at the corner.'),
+        width: measurement('length', 'm', {
+            positive: true,
+            description: 'How far the glass runs along each wall from the corner (default 1.2 m).',
+        }).optional(),
+        widths: z
+            .record(z.string(), measurement('length', 'm', { positive: true, description: 'The side on that wall.' }))
+            .optional()
+            .describe('A width for a wall by its id, over width (e.g. { "wall_a": 1.6 }).'),
+        height: measurement('length', 'm', {
+            positive: true,
+            description: 'Window height (default 1.5 m).',
+        }).optional(),
+        sillHeight: measurement('length', 'm', {
+            min: 0,
+            description: 'Height from the floor to the bottom of the window (default: centred vertically on the lower of the two walls, the same on both sides).',
+        }).optional(),
+        post: z
+            .enum(['none', 'post'])
+            .optional()
+            .describe("none: the glass fused at the corner (a fixed window's default); post: the glass meets at a thin post (the default, and the only choice, for the other window types, whose frames stay)."),
+        windowType: WindowType.optional().describe("How it opens (default fixed), the window panel's Type row; the fused corner is a fixed window's."),
+        style: z
+            .enum(WINDOW_STYLES)
+            .optional()
+            .describe("The panes' look on each side (rows and columns), the window panel's Style row."),
+    },
+};

package/dist/agent-tools/create-room.d.ts

@@ -0,0 +1,64 @@
+import { z } from 'zod';
+export declare const createRoomTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        levelId: z.ZodOptional<z.ZodString>;
+        level: z.ZodOptional<z.ZodString>;
+        name: z.ZodString;
+        polygon: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+        color: z.ZodOptional<z.ZodString>;
+        wallHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        wallThickness: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        rename: z.ZodOptional<z.ZodBoolean>;
+        outdoor: z.ZodOptional<z.ZodBoolean>;
+        doors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            wallIndex: z.ZodNumber;
+            t: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            hingesSide: z.ZodOptional<z.ZodEnum<{
+                left: "left";
+                right: "right";
+            }>>;
+            swingDirection: z.ZodOptional<z.ZodEnum<{
+                inward: "inward";
+                outward: "outward";
+            }>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                barn: "barn";
+                craftsman: "craftsman";
+                french: "french";
+                glass: "glass";
+                "half-louvered": "half-louvered";
+                modern: "modern";
+                panel: "panel";
+                "paneled-glass": "paneled-glass";
+                shaker: "shaker";
+                "six-panel": "six-panel";
+            }>>;
+        }, z.core.$strip>>>;
+        windows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            wallIndex: z.ZodNumber;
+            t: z.ZodOptional<z.ZodNumber>;
+            width: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            height: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            sillHeight: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+            style: z.ZodOptional<z.ZodEnum<{
+                casement: "casement";
+                "double-hung": "double-hung";
+                grid: "grid";
+                "horizontal-bands": "horizontal-bands";
+                picture: "picture";
+                single: "single";
+                sliding: "sliding";
+                "tall-grid": "tall-grid";
+                transom: "transom";
+                "triple-hung": "triple-hung";
+                "wide-grid": "wide-grid";
+            }>>;
+        }, z.core.$strip>>>;
+    };
+};
+//# sourceMappingURL=create-room.d.ts.map

package/dist/agent-tools/create-room.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-room.d.ts","sourceRoot":"","sources":["../../src/agent-tools/create-room.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAuBvB,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8F1B,CAAA"}

package/dist/agent-tools/create-room.js

@@ -0,0 +1,97 @@
+import { z } from 'zod';
+import { DOOR_STYLES, WINDOW_STYLES } from '../building/opening-style-presets.js';
+import { FOUNDATION_BY_REGION_NOTE } from '../lib/foundation-construction.js';
+import { levelTarget } from './levels.js';
+import { measurement } from './measurement.js';
+// A list of two, not a tuple: a tuple's list-form schema is refused by some clients.
+const point = z.array(z.number()).length(2);
+const onEdge = {
+    wallIndex: z
+        .number()
+        .int()
+        .min(0)
+        .describe('The polygon edge it sits on: edge i runs from corner i to corner i + 1.'),
+    t: z
+        .number()
+        .min(0)
+        .max(1)
+        .optional()
+        .describe('Position along that edge: 0 = its start, 1 = its end (default 0.5).'),
+};
+export const createRoomTool = {
+    name: 'create_room',
+    title: 'Create room',
+    description: "Create a room on a level from its polygon: a wall per edge, an edge a wall already runs along reusing that wall (rooms share their boundary with their neighbour), and the room zone that names it. The floor plate and the ceiling are derived from the room — never author a slab or a ceiling for it. Declare the room's doors and windows in the same call by polygon edge (wallIndex) and t along it, no wall ids needed; each is placed with add_door's and add_window's rules, and one that cannot be is skipped and listed in skippedOpenings with its code. Returns zoneId, slabId, ceilingId, wallIds in edge order (null where no wall), doorIds, windowIds. outdoor: true draws a terrace instead: separators where no wall runs, no walls of its own and no ceiling. Where the walls already enclose a room the reconciler numbered, the call names that room instead of adding a second one; where they enclose a room with a name of its own (not a number the editor gave it), it is refused (room_named_by_person) unless rename is true, which you pass only when the person asked for the rename, so a name is never changed silently.",
+    input: {
+        ...levelTarget,
+        name: z.string().min(1).describe('Room name, e.g. "Bedroom", "Kitchen".'),
+        polygon: z.array(point).min(3).describe('The corners in order, as [x, z] in metres.'),
+        color: z
+            .string()
+            .optional()
+            .describe('Hex colour of the room zone, e.g. "#22c55e"; omit it and the room gets a palette colour picked from its id.'),
+        wallHeight: measurement('length', 'm', {
+            positive: true,
+            description: "Omit to follow the storey and covering-slab underside. Equal to the stored storey height also follows that plane; other values are body heights above the wall's support, including deliberately taller walls.",
+        }).optional(),
+        wallThickness: measurement('length', 'm', {
+            positive: true,
+            description: 'Thickness of the walls it builds. Omitted, a wall against the ground on a level below grade is a foundation wall ' +
+                FOUNDATION_BY_REGION_NOTE +
+                ', a partition inside the outline is an ordinary wall; a thickness keeps the schema wall.',
+        }).optional(),
+        rename: z
+            .boolean()
+            .optional()
+            .describe('Only where the walls already enclose a room with a name of its own (not a number the editor gave it): true names that room with `name` instead of the refusal room_named_by_person. Pass it only when the person asked for the rename; otherwise ask them first.'),
+        outdoor: z
+            .boolean()
+            .optional()
+            .describe("true for an outdoor room (a terrace): closed with separators (the editor's Separator: a room boundary with no wall) where no wall runs, no walls of its own and no ceiling."),
+        doors: z
+            .array(z.object({
+            ...onEdge,
+            width: measurement('length', 'm', {
+                positive: true,
+                description: 'Door width (default 0.9 m).',
+            }).optional(),
+            height: measurement('length', 'm', {
+                positive: true,
+                description: 'Door height (default 2.1 m).',
+            }).optional(),
+            hingesSide: z.enum(['left', 'right']).optional().describe('Hinge side (default left).'),
+            swingDirection: z
+                .enum(['inward', 'outward'])
+                .optional()
+                .describe('Which way the door opens (default inward).'),
+            style: z
+                .enum(DOOR_STYLES)
+                .optional()
+                .describe("Visual preset: 'panel' (default raised-panel), 'glass' (mostly glass), 'modern' (flush slab), 'paneled-glass' (glass top, panel bottom — an entry door), 'french' (two narrow glass leaves), 'shaker' (one flat panel), 'six-panel' (3 × 2 traditional grid), 'craftsman' (4 stacked vertical panels), 'half-louvered' (slats on top, panel below — closet, laundry), 'barn' (wide recessed panel). One style per room type across the home; the entry door may differ."),
+        }))
+            .optional()
+            .describe('The entry door and the doors to the rooms next to it.'),
+        windows: z
+            .array(z.object({
+            ...onEdge,
+            width: measurement('length', 'm', {
+                positive: true,
+                description: 'Window width (default 1.5 m).',
+            }).optional(),
+            height: measurement('length', 'm', {
+                positive: true,
+                description: 'Window height (default 1.5 m).',
+            }).optional(),
+            sillHeight: measurement('length', 'm', {
+                min: 0,
+                description: 'Height from the floor to the bottom of the window (default: centred vertically on the wall).',
+            }).optional(),
+            style: z
+                .enum(WINDOW_STYLES)
+                .optional()
+                .describe("Visual preset: 'single' (default single pane), 'double-hung', 'triple-hung' (stacked sashes), 'casement' (two panes side by side), 'sliding' (three side by side — wide), 'grid' (2 × 2), 'tall-grid' (2 × 3), 'wide-grid' (3 × 2), 'horizontal-bands' (4 stacked bands), 'transom' (a small row over a larger pane), 'picture' (an alias of 'single'). One style for all the windows of a room, and per room type across the home."),
+        }))
+            .optional()
+            .describe('Windows, on exterior edges only: not on an edge shared with another room.'),
+    },
+};