@pascal-app/core 1.0.3 → 1.0.5

package/dist/agent-tools/design-brief.d.ts

@@ -0,0 +1,408 @@
+import { z } from 'zod';
+/** Where a brief says the objects come from. */
+export declare const DESIGN_BRIEF_SOURCES: readonly ['open', 'catalog', 'brand', 'existing'];
+/** The tools that place a catalog piece, and the ones that make a piece: what a brief opens. */
+export declare const CATALOG_PLACEMENT_TOOLS: readonly ['place_items', 'furnish_room', 'place_in_room'];
+export declare const FURNISHING_CREATION_TOOLS: readonly ['add_object', 'place_design'];
+/** The layers of the dressing `beyond` states, with how each reads in a fact. */
+export declare const BEYOND_LAYERS: readonly [readonly ['textiles', 'textiles'], readonly ['light', 'light'], readonly ['windows', 'windows'], readonly ['walls', 'walls'], readonly ['floor', 'floor'], readonly ['plants', 'plants'], readonly ['objects', 'objects'], readonly ['smallFurniture', 'small furniture']];
+/** An open dressing owes at least this many of the layers pieces. */
+export declare const BEYOND_MIN_LAYERS = 6;
+export declare const beyondSchema: z.ZodObject<{
+    textiles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    light: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    windows: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    walls: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    floor: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    plants: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    objects: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+    smallFurniture: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+        none: z.ZodString;
+    }, z.core.$strip>]>;
+}, z.core.$strip>;
+export type Beyond = z.infer<typeof beyondSchema>;
+/** The pieces a layer names, or none. */
+export declare const layerPieces: (value: Beyond[keyof Beyond]) => string[];
+/**
+ * The axes of a request's creative latitude, besides the source (the `source` fields below).
+ * Each is bounded, quoting the person's own words that bound it with the reading in a short
+ * line, or open, with a design statement saying how it is designed. An axis the request does
+ * not touch at all is open.
+ */
+export declare const BRIEF_AXES: readonly ['action', 'size', 'pieces', 'openings', 'style', 'materials', 'dressing'];
+export type BriefAxis = (typeof BRIEF_AXES)[number];
+/** An open axis's design statement carries at least this many words. */
+export declare const AXIS_DESIGN_MIN_WORDS = 3;
+export declare const axesSchema: z.ZodObject<{
+    action: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    size: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    pieces: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    openings: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    style: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    materials: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+    dressing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        kind: z.ZodLiteral<"bounded">;
+        quote: z.ZodString;
+        reading: z.ZodString;
+        extent: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            minimum: "minimum";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        kind: z.ZodLiteral<"open">;
+        design: z.ZodString;
+    }, z.core.$strip>], "kind">>;
+}, z.core.$strip>;
+export type BriefAxes = z.infer<typeof axesSchema>;
+export type AxisReading = NonNullable<BriefAxes[BriefAxis]>;
+export declare const designBriefTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        axes: z.ZodOptional<z.ZodObject<{
+            action: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            size: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            pieces: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            openings: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            style: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            materials: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+            dressing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                kind: z.ZodLiteral<"bounded">;
+                quote: z.ZodString;
+                reading: z.ZodString;
+                extent: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    minimum: "minimum";
+                }>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"open">;
+                design: z.ZodString;
+            }, z.core.$strip>], "kind">>;
+        }, z.core.$strip>>;
+        source: z.ZodEnum<{
+            brand: "brand";
+            catalog: "catalog";
+            existing: "existing";
+            open: "open";
+        }>;
+        sourceQuote: z.ZodOptional<z.ZodString>;
+        brand: z.ZodOptional<z.ZodString>;
+        vision: z.ZodString;
+        beyond: z.ZodObject<{
+            textiles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            light: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            windows: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            walls: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            floor: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            plants: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            objects: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+            smallFurniture: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+                none: z.ZodString;
+            }, z.core.$strip>]>;
+        }, z.core.$strip>;
+        asIs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            assetId: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strip>>>;
+    };
+};
+/** What the tool's call carries: `beyond` is required there. */
+export type DesignBriefInput = z.infer<z.ZodObject<typeof designBriefTool.input>>;
+/**
+ * The brief as a session keeps it. Reading is tolerant, writing is strict: a record stored before
+ * `beyond` existed still reads (only the tool's input requires it), and a brief stored as
+ * `fixed`/`open` lists, before the axes, still reads with them, so an older brief never costs
+ * the session its checkpoints.
+ */
+export declare const DesignBriefRecord: z.ZodObject<{
+    axes: z.ZodOptional<z.ZodObject<{
+        action: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        size: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        pieces: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        openings: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        style: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        materials: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+        dressing: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"bounded">;
+            quote: z.ZodString;
+            reading: z.ZodString;
+            extent: z.ZodOptional<z.ZodEnum<{
+                exact: "exact";
+                minimum: "minimum";
+            }>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"open">;
+            design: z.ZodString;
+        }, z.core.$strip>], "kind">>;
+    }, z.core.$strip>>;
+    source: z.ZodEnum<{
+        brand: "brand";
+        catalog: "catalog";
+        existing: "existing";
+        open: "open";
+    }>;
+    sourceQuote: z.ZodOptional<z.ZodString>;
+    brand: z.ZodOptional<z.ZodString>;
+    vision: z.ZodString;
+    asIs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        assetId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strip>>>;
+    fixed: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    open: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    beyond: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        textiles: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        light: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        windows: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        walls: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        floor: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        plants: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        objects: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+        smallFurniture: z.ZodUnion<readonly [z.ZodArray<z.ZodString>, z.ZodObject<{
+            none: z.ZodString;
+        }, z.core.$strip>]>;
+    }, z.core.$strip>, z.ZodString]>>;
+}, z.core.$strip>;
+export type DesignBrief = z.infer<typeof DesignBriefRecord>;
+//# sourceMappingURL=design-brief.d.ts.map

package/dist/agent-tools/design-brief.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"design-brief.d.ts","sourceRoot":"","sources":["../../src/agent-tools/design-brief.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,gDAAgD;AAChD,eAAO,MAAM,oBAAoB,YAAI,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,UAAU,CAAU,CAAA;AAErF,gGAAgG;AAChG,eAAO,MAAM,uBAAuB,YAAI,aAAa,EAAE,cAAc,EAAE,eAAe,CAAU,CAAA;AAChG,eAAO,MAAM,yBAAyB,YAAI,YAAY,EAAE,cAAc,CAAU,CAAA;AAIhF,iFAAiF;AACjF,eAAO,MAAM,aAAa,sBACvB,UAAU,EAAE,UAAU,aACtB,OAAO,EAAE,OAAO,aAChB,SAAS,EAAE,SAAS,aACpB,OAAO,EAAE,OAAO,aAChB,OAAO,EAAE,OAAO,aAChB,QAAQ,EAAE,QAAQ,aAClB,SAAS,EAAE,SAAS,aACpB,gBAAgB,EAAE,iBAAiB,EAC5B,CAAA;AAEV,qEAAqE;AACrE,eAAO,MAAM,iBAAiB,IAAI,CAAA;AAYlC,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;iBAatB,CAAA;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAA;AAEjD,yCAAyC;AACzC,eAAO,MAAM,WAAW,UAAW,MAAM,CAAC,MAAM,MAAM,CAAC,KAAG,MAAM,EAC7B,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,UAAU,YACrB,QAAQ,EACR,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAO,EACP,WAAW,EACX,UAAU,CACF,CAAA;AAEV,MAAM,MAAM,SAAS,GAAG,CAAC,OAAO,UAAU,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnD,wEAAwE;AACxE,eAAO,MAAM,qBAAqB,IAAI,CAAA;AA6BtC,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoBpB,CAAA;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAA;AAClD,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC,CAAA;AAE3D,eAAO,MAAM,eAAe;IAC1B,IAAI;IACJ,KAAK;IACL,WAAW;IAOX,KAAK;QAGH,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QACJ,MAAM;;;;;;QAKN,WAAW;QAQX,KAAK;QAML,MAAM;QAON,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;QACN,IAAI;;;;;CAaP,CAAA;AAED,gEAAgE;AAChE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,SAAS,CAAC,OAAO,eAAe,CAAC,KAAK,CAAC,CAAC,CAAA;AAEjF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAM5B,CAAA;AAEF,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAA"}

package/dist/agent-tools/design-brief.js

@@ -0,0 +1,149 @@
+import { z } from 'zod';
+/** Where a brief says the objects come from. */
+export const DESIGN_BRIEF_SOURCES = ['open', 'catalog', 'brand', 'existing'];
+/** The tools that place a catalog piece, and the ones that make a piece: what a brief opens. */
+export const CATALOG_PLACEMENT_TOOLS = ['place_items', 'furnish_room', 'place_in_room'];
+export const FURNISHING_CREATION_TOOLS = ['add_object', 'place_design'];
+const fact = z.string().min(1).max(200);
+/** The layers of the dressing `beyond` states, with how each reads in a fact. */
+export const BEYOND_LAYERS = [
+    ['textiles', 'textiles'],
+    ['light', 'light'],
+    ['windows', 'windows'],
+    ['walls', 'walls'],
+    ['floor', 'floor'],
+    ['plants', 'plants'],
+    ['objects', 'objects'],
+    ['smallFurniture', 'small furniture'],
+];
+/** An open dressing owes at least this many of the layers pieces. */
+export const BEYOND_MIN_LAYERS = 6;
+const layer = (what) => z
+    .union([
+    z.array(z.string().min(1).max(120)).min(1).max(12),
+    z.object({ none: z.string().min(1).max(200) }),
+])
+    .describe(`${what}: a list of pieces, each a short phrase naming the piece (and, for a whole home, the room or rooms), or { "none": "<why>" }.`);
+export const beyondSchema = z
+    .object({
+    textiles: layer('Bedding, throws, cushions'),
+    light: layer('Lamps, pendants, sconces'),
+    windows: layer('Curtains, blinds'),
+    walls: layer('Art, mirrors, shelves of objects'),
+    floor: layer('Rugs'),
+    plants: layer('Plants'),
+    objects: layer('Books, vases, trays, tableware'),
+    smallFurniture: layer('A bench, a chair, a desk, a pouf'),
+})
+    .describe('The dressing of the rooms beyond the pieces the request names, layer by layer. An open dressing is a call to dress the rooms fully; beyond is where that design is stated.');
+/** The pieces a layer names, or none. */
+export const layerPieces = (value) => Array.isArray(value) ? value : [];
+/**
+ * The axes of a request's creative latitude, besides the source (the `source` fields below).
+ * Each is bounded, quoting the person's own words that bound it with the reading in a short
+ * line, or open, with a design statement saying how it is designed. An axis the request does
+ * not touch at all is open.
+ */
+export const BRIEF_AXES = [
+    'action',
+    'size',
+    'pieces',
+    'openings',
+    'style',
+    'materials',
+    'dressing',
+];
+/** An open axis's design statement carries at least this many words. */
+export const AXIS_DESIGN_MIN_WORDS = 3;
+const axis = (what) => z
+    .discriminatedUnion('kind', [
+    z.object({
+        kind: z.literal('bounded'),
+        quote: z
+            .string()
+            .max(300)
+            .describe("The person's own words that bound this axis, copied from the request."),
+        reading: fact.describe('One short line: how those words bound this axis.'),
+        extent: z
+            .enum(['minimum', 'exact'])
+            .optional()
+            .describe('Pieces only: minimum, the named pieces must be there and more may come (the default reading), or exact, the request limits the pieces to those ("only", "nothing else").'),
+    }),
+    z.object({
+        kind: z.literal('open'),
+        design: z
+            .string()
+            .max(600)
+            .describe(`How this axis is designed, at least ${AXIS_DESIGN_MIN_WORDS} words.`),
+    }),
+])
+    .describe(what);
+export const axesSchema = z
+    .object({
+    action: axis('What the request asks to be done: add a lamp, make a bedroom, build a house.').optional(),
+    size: axis('Dimensions and extents.').optional(),
+    pieces: axis('The pieces and counts the request names. Usually bounded as a minimum (extent); words such as "only", "nothing else", "just", "seulement", "rien d\'autre" make it exact.').optional(),
+    openings: axis('Counts of windows and doors, when the request gives them: exact counts of the architecture.').optional(),
+    style: axis('Style and form of what is made.').optional(),
+    materials: axis('Materials and finishes.').optional(),
+    dressing: axis('What makes the space lived-in. When open, beyond carries it layer by layer; when bounded, the quote is the words that bound it and beyond may say none everywhere. The pieces the request names, read as a minimum, do not bound it.').optional(),
+})
+    .describe("The request read axis by axis: action, size, pieces, openings, style, materials, dressing, each bounded (the person's words as quote, the reading in a short line) or open (a design statement saying how it is designed). The eighth axis, the source, is the source fields: open, or bounded by sourceQuote. Every axis is stated; an axis the request does not touch is open.");
+export const designBriefTool = {
+    name: 'design_brief',
+    title: 'Write the design brief',
+    description: `The design brief of the request, written once for the whole request (piece by piece when the request invites it): the request read axis by axis (action, size, pieces, openings, style, materials, source, dressing), each axis bounded by the person's own words or open with a design statement, a vision, and where the objects come from. It is recorded as the design record of the turn and answers with what it unlocks. It changes nothing in the scene.
+Furnishings are placed or made after a brief: ${CATALOG_PLACEMENT_TOOLS.join(', ')} (the catalog's) and ${FURNISHING_CREATION_TOOLS.join(', ')} (the agent's own), also inside run_batch. Before one, search_assets and view_assets read the catalog and every other tool works as usual; rooms, walls, openings and finishes are not furnishings.
+Bounded and open, in four readings. "a 4 by 5 m bedroom with a double bed, two nightstands, a wardrobe, one window, one door": action, size, pieces (as a minimum: those pieces must be there, more may come) and openings bounded; style, materials, source and dressing open. "add a lamp next to the sofa": action and dressing bounded by "add a lamp" (one object in a room that exists); style open, its design statement saying how this lamp is designed. "a bedroom with only a bed and a lamp": pieces exact and dressing bounded by "only a bed and a lamp"; style and materials open, the bed and the lamp designed, not defaulted. "Build a house": the action bounded only by "a house"; every other axis open, the dressing included.
+source open: the pieces are made (add_object, place_design), view_assets shows the catalog's pieces for reference, and furnish_room, which places a whole stock set, stays closed. asIs keeps technical equipment only (sanitaryware, kitchen and laundry appliances, heating and similar services): each piece is named with a reason and was shown by view_assets earlier in the same turn (chat) or session (MCP); furniture is made, not kept as it is. source catalog, brand or existing: place_items, furnish_room and place_in_room are open, and the creation tools stay open for what the catalog lacks.
+Naming a piece (a double bed) states its function; its form, size within reason and finish are open unless the request fixes them. The pieces a request names are what the room must contain, not all it may contain: where the dressing axis is open, beyond states that design layer by layer: textiles, light, windows, walls, floor, plants, objects, small furniture, each a list of pieces or { none: why }, at least ${BEYOND_MIN_LAYERS} of the 8 layers naming pieces; where the dressing is bounded (words that limit the pieces or the action, such as "only", "nothing else", "just"), none in every layer is accepted. The pieces the request names, read as a minimum, do not bound the dressing. The answer hands the pieces back as dressing.
+A source other than open is set by the request, not chosen: sourceQuote holds the person's own words that name it, at least two words naming a brand (the brief's brand), the catalog or what is already there ("IKEA furniture only", "que du catalogue", "use my existing furniture"); a request that names no source is open. The chat checks the quote against the person's message of the turn, as it checks every bounded axis's quote; over MCP, where there is no message, a source quote must still name the source and is not compared with a request, and an axis quote is not compared either.
+In the chat a brief lasts for the turn; over MCP it lasts for the session. The next design_brief replaces it. Refused: axis_missing (an axis is absent), axis_quote_not_in_request (a bounded axis's quote is not in the person's message), axis_open_without_design (an open axis without a design statement of at least ${AXIS_DESIGN_MIN_WORDS} words), dressing_bounded_by_minimum (the dressing bounded by words inside a pieces quote read as a minimum), brand_required (source brand without a brand name), source_quote_required (a source other than open without sourceQuote), source_not_named (the quote names no brand, catalog or existing source), source_not_in_request (the quote is not in the person's message), beyond_too_thin (dressing open, fewer than ${BEYOND_MIN_LAYERS} layers naming pieces).`,
+    input: {
+        // Optional in the schema so an absent axis is refused by the operation, with the list,
+        // on every surface, rather than by each surface's own validation error.
+        axes: axesSchema.optional(),
+        source: z
+            .enum(DESIGN_BRIEF_SOURCES)
+            .describe('The source axis: where the objects come from. open: the request names no source. catalog: it asks for the catalog. brand: it names a range (give brand). existing: it names pieces that already exist.'),
+        sourceQuote: z
+            .string()
+            .min(1)
+            .max(300)
+            .optional()
+            .describe('Required with source catalog, brand or existing: the person\'s own words that name it (a brand, the catalog, what is already there), copied from the request ("IKEA furniture only").'),
+        brand: z
+            .string()
+            .min(1)
+            .max(80)
+            .optional()
+            .describe('The range the request names, when source is brand ("IKEA").'),
+        vision: z
+            .string()
+            .min(1)
+            .max(1200)
+            .describe('A few lines: the design intent for what is open (character, forms, materials, how the room is meant to feel).'),
+        beyond: beyondSchema,
+        asIs: z
+            .array(z.object({
+            assetId: z.string().min(1).describe('The catalog id of the piece, from search_assets.'),
+            reason: fact.describe('One line: why this piece stands as it is.'),
+        }))
+            .max(24)
+            .optional()
+            .describe('With source open: technical equipment placed unchanged (place_items, place_in_room), each piece shown by view_assets first, each with its reason. Sanitaryware, kitchen and laundry appliances, heating and similar services; furniture is made.'),
+    },
+};
+/**
+ * The brief as a session keeps it. Reading is tolerant, writing is strict: a record stored before
+ * `beyond` existed still reads (only the tool's input requires it), and a brief stored as
+ * `fixed`/`open` lists, before the axes, still reads with them, so an older brief never costs
+ * the session its checkpoints.
+ */
+export const DesignBriefRecord = z.object({
+    ...designBriefTool.input,
+    fixed: z.array(fact).min(1).max(24).optional(),
+    open: z.array(fact).max(24).optional(),
+    // A brief stored before the dressing had layers holds a string: it still reads.
+    beyond: z.union([designBriefTool.input.beyond, z.string()]).optional(),
+});

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

@@ -0,0 +1,34 @@
+import { z } from 'zod';
+export declare const validateDesignTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    };
+    annotations: {
+        readOnlyHint: boolean;
+    };
+};
+export declare const placeDesignTool: {
+    name: string;
+    title: string;
+    description: string;
+    input: {
+        design: z.ZodUnion<readonly [z.ZodString, z.ZodRecord<z.ZodString, z.ZodUnknown>]>;
+        hostId: z.ZodString;
+        position: z.ZodArray<z.ZodNumber>;
+        rotation: z.ZodOptional<z.ZodPipe<z.ZodUnion<[z.ZodNumber, z.ZodString]>, z.ZodTransform<number, string | number>>>;
+        side: z.ZodOptional<z.ZodEnum<{
+            back: "back";
+            front: "front";
+        }>>;
+        surfaceId: z.ZodOptional<z.ZodString>;
+        parameters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+        slots: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        name: z.ZodOptional<z.ZodString>;
+        id: z.ZodOptional<z.ZodString>;
+    };
+};
+//# sourceMappingURL=designs.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"designs.d.ts","sourceRoot":"","sources":["../../src/agent-tools/designs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAkBvB,eAAO,MAAM,kBAAkB;;;;;;;;;QAMd,YAAY;;CAC5B,CAAA;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;CAyC3B,CAAA"}

package/dist/agent-tools/designs.js

@@ -0,0 +1,50 @@
+import { z } from 'zod';
+import { measurement } from './measurement.js';
+import { NodeId } from './node-id.js';
+const design = z
+    .union([z.string(), z.record(z.string(), z.unknown())])
+    .describe('The design (procedural recipe, version 1 or 2) as an object, or as a JSON string for clients that cannot send recursive objects. Schema: pascal://schema/design.');
+const parameters = z
+    .record(z.string(), z.number())
+    .optional()
+    .describe('Parameter values to measure at, by parameter id. Defaults otherwise.');
+// A list of three, not a tuple: a tuple's list-form schema is refused by some clients.
+const point3 = z.array(z.number()).length(3);
+export const validateDesignTool = {
+    name: 'validate_design',
+    title: 'Validate design',
+    description: 'Check a design (procedural item recipe) without changing the scene. Returns `valid`, coded `diagnostics` with paths (errors block placement, warnings flag floating or unbalanced parts), the parameter `sweep`, and `measurements` at the given parameters: bounds, per-part bounds and instances, true triangle counts, draw groups per slot, datum contact and connected components. It is the authority: some rules are not expressible in pascal://schema/design. Repair and re-validate until `valid` is true. Version 2 designs validate fully but carry a design_version_not_enabled warning: placement accepts version 1 only until the next release.',
+    input: { design, parameters },
+    annotations: { readOnlyHint: true },
+};
+export const placeDesignTool = {
+    name: 'place_design',
+    title: 'Place design',
+    description: 'Create one instance of a design (procedural item recipe, object or JSON string) in the scene. The design must pass validate_design. Its mounting picks the host: floor designs go on a level (or a slab or zone of it) or on a named surface of a placed design; wall-side designs on a straight wall face; ceiling designs under a ceiling. Only creates: refusals carry a code (invalid_design with diagnostics, design_version_not_enabled for version 2 designs until the next release, design_too_large above 24 KiB, invalid_placement, node_exists, host_not_found, wrong_host, unknown_surface, does_not_fit) and change nothing.',
+    input: {
+        design,
+        hostId: NodeId.describe('Floor designs: a level, or a slab or zone on it, or a placed design with surfaceId. Wall-side designs: a straight wall. Ceiling designs: a ceiling.'),
+        position: point3.describe('Metres. Floor: level-local [x, y, z], y above the floor. Wall-side: [along, height, offset] of the mounting reference from the wall start. Ceiling: plan [x, 0, z] of the reference. Surface: [x, 0, z] in the surface frame.'),
+        rotation: measurement('angle', 'rad', {
+            description: 'Yaw. Not for wall-side designs; use side to face the other way.',
+        }).optional(),
+        side: z
+            .enum(['front', 'back'])
+            .optional()
+            .describe("Wall face for wall-side designs: front is the +normal side, normal (−Δz, Δx) of start→end. The wall's frontSide and backSide say which face is exterior (a facade light goes on that one)."),
+        surfaceId: z
+            .string()
+            .optional()
+            .describe('Named surface of the host design to rest on (see validate_design measurements.surfaces).'),
+        parameters,
+        slots: z
+            .record(z.string(), z.string())
+            .optional()
+            .describe('Slot id to "#rrggbb" or a scene:/library: material reference.'),
+        name: z.string().optional(),
+        id: z
+            .string()
+            .optional()
+            .describe('Optional new id ("procedural-item_…"). Refused if it exists: this tool only creates.'),
+    },
+};