@ggui-ai/mcp-server-handlers 0.12.0 → 0.14.0

package/dist/__tests__/define-handler.test-d.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=define-handler.test-d.d.ts.map

package/dist/__tests__/define-handler.test-d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-handler.test-d.d.ts","sourceRoot":"","sources":["../../src/__tests__/define-handler.test-d.ts"],"names":[],"mappings":""}

package/dist/__tests__/define-handler.test-d.js

@@ -0,0 +1,99 @@
+// Compile-time type tests for the handler contract (#817).
+// This file must compile with zero errors — that IS the test.
+// Run: pnpm typecheck (from this package — tsc compiles this file with the rest)
+//
+// Two obligations, both stated by the TYPE so a disagreement is a compile
+// error where there used to be silence (runtime `validateOutputPayload` on
+// the wire was the only failure mode):
+//   1. `defineHandler` binds the handler's output to what its `outputSchema`
+//      produces (inferred from the handler's return, checked against the
+//      shape) — so nobody hand-writes one; with an `outputEnvelopeSchema` the
+//      envelope must produce that same shape with exactly its keys.
+//   2. `SharedHandler` itself constrains `OutputData` to what its own
+//      `outputSchema` (or envelope) produces, so a raw literal that bypasses
+//      the helper still cannot omit a key.
+// No `@ts-expect-error` here — a negative case is asserted with vitest's
+// `expectTypeOf(...).not.toMatchTypeOf`, which fails to COMPILE when the
+// relationship holds the wrong way (precedent: protocol's
+// contract-inference.test-d.ts).
+import { expectTypeOf } from 'vitest';
+import { z } from 'zod';
+import { defineHandler, } from '../types.js';
+const inputSchema = { id: z.string() };
+const outputSchema = { id: z.string(), count: z.number(), note: z.string().optional() };
+// ── 1. defineHandler derives OutputData from outputSchema ──────────────────
+const derived = defineHandler({
+    name: 'x_derived',
+    description: 'd',
+    inputSchema,
+    outputSchema,
+    async handler() {
+        return { id: 'a', count: 1 };
+    },
+});
+// OutputData is INFERRED from what the handler returns and checked against the
+// shape's bound: this infallible handler is exactly its shape — no failure arm
+// it never produces, no narrowing for consumers.
+expectTypeOf(derived).toMatchTypeOf();
+// And every handler still assigns to the bound the list boundary uses.
+expectTypeOf(derived).toMatchTypeOf();
+expectTypeOf().toMatchTypeOf();
+expectTypeOf().not.toMatchTypeOf();
+// ── 1b. with an envelope: the envelope must produce the shape's output ────────
+const envelope = z.object({ id: z.string(), count: z.number(), note: z.string().optional() });
+const enveloped = defineHandler({
+    name: 'x_enveloped',
+    description: 'd',
+    inputSchema,
+    outputSchema,
+    outputEnvelopeSchema: envelope,
+    async handler() {
+        return { id: 'a', count: 1 };
+    },
+});
+// The enveloped definition is a SharedHandler like any other — same bound at the list boundary.
+expectTypeOf(enveloped).toMatchTypeOf();
+// Inferred, not stamped: this handler never fails, so its output is exactly the
+// envelope's shape — no failure arm it never produces.
+expectTypeOf().toEqualTypeOf();
+expectTypeOf().toMatchTypeOf();
+expectTypeOf().not.toMatchTypeOf();
+expectTypeOf().toMatchTypeOf();
+expectTypeOf().toEqualTypeOf();
+expectTypeOf().not.toMatchTypeOf();
+expectTypeOf().toEqualTypeOf();
+// … and so is a failure envelope carrying the shape.
+expectTypeOf().toEqualTypeOf();
+// ── 3. envelope keys must equal outputSchema keys (keyof identity) ─────────
+// A mismatched envelope (a key the raw shape does not declare) is rejected by
+// the helper's parameter type — asserted as non-assignability of the
+// definition object, never by @ts-expect-error.
+const mismatchedEnvelope = z.object({ id: z.string(), count: z.number(), rogue: z.boolean() });
+// It DOES produce the shape's output (extra key is fine for assignability) — the
+// rejection below is the keys rule, not the output rule.
+expectTypeOf(mismatchedEnvelope).toMatchTypeOf();
+// Same keys → admissible …
+expectTypeOf().toMatchTypeOf();
+// … a rogue key → the property type is unsatisfiable, the definition does not type.
+expectTypeOf().not.toMatchTypeOf();
+// Both mismatch directions, pinned on the operator itself. The EXTRA-key case
+// above is the one a strip-parsing transport hides at runtime (the key is
+// dropped, nothing fails) — the type is its only receipt. The MISSING-key case
+// is caught twice: the envelope no longer produces the shape's output (rule 1),
+// and its keys differ (rule 3). Exact keys are the identity.
+const missingKeyEnvelope = z.object({ id: z.string() });
+expectTypeOf(missingKeyEnvelope).not.toMatchTypeOf();
+expectTypeOf().toEqualTypeOf();
+expectTypeOf().toBeNever();
+expectTypeOf().toBeNever();
+const interfaceTyped = defineHandler({
+    name: 'x_interface',
+    description: 'd',
+    inputSchema,
+    outputSchema,
+    async handler() {
+        return { id: 'a', count: 1 };
+    },
+});
+expectTypeOf(interfaceTyped).toMatchTypeOf();
+expectTypeOf(enveloped).toMatchTypeOf();

package/dist/app-discovery/list-gadgets.d.ts

@@ -42,12 +42,8 @@
  * defeats per-app curation.
  */
 import { z } from 'zod';
-import { type GadgetDescriptor } from '@ggui-ai/protocol';
 import type { AppMetadataStore } from '@ggui-ai/mcp-server-core';
-import type { SharedHandler } from '../types.js';
-declare const inputSchema: {
-    readonly appId: z.ZodOptional<z.ZodString>;
-};
+import { type ShapeOutput } from '../types.js';
 declare const outputSchema: {
     readonly gadgets: z.ZodArray<z.ZodObject<{
         exports: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
@@ -86,9 +82,66 @@ export interface GguiListGadgetsHandlerDeps {
      */
     readonly appMetadataStore: AppMetadataStore;
 }
-export interface GguiListGadgetsOutput {
-    readonly gadgets: readonly GadgetDescriptor[];
-}
-export declare function createGguiListGadgetsHandler(deps: GguiListGadgetsHandlerDeps): SharedHandler<typeof inputSchema, typeof outputSchema, GguiListGadgetsOutput>;
+/** The wire shape — derived from `outputSchema`, the one source of truth (#817). */
+export type GguiListGadgetsOutput = ShapeOutput<typeof outputSchema>;
+export declare function createGguiListGadgetsHandler(deps: GguiListGadgetsHandlerDeps): import("../types.js").SharedHandler<{
+    readonly appId: z.ZodOptional<z.ZodString>;
+}, {
+    readonly gadgets: z.ZodArray<z.ZodObject<{
+        exports: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            usage: z.ZodOptional<z.ZodString>;
+            example: z.ZodOptional<z.ZodType<import("@ggui-ai/protocol").JsonValue, unknown, z.core.$ZodTypeInternals<import("@ggui-ai/protocol").JsonValue, unknown>>>;
+            permission: z.ZodOptional<z.ZodString>;
+            gotchas: z.ZodOptional<z.ZodString>;
+            hook: z.ZodString;
+        }, z.core.$strict>, z.ZodObject<{
+            description: z.ZodOptional<z.ZodString>;
+            usage: z.ZodOptional<z.ZodString>;
+            example: z.ZodOptional<z.ZodType<import("@ggui-ai/protocol").JsonValue, unknown, z.core.$ZodTypeInternals<import("@ggui-ai/protocol").JsonValue, unknown>>>;
+            permission: z.ZodOptional<z.ZodString>;
+            gotchas: z.ZodOptional<z.ZodString>;
+            component: z.ZodString;
+        }, z.core.$strict>]>>;
+        version: z.ZodString;
+        package: z.ZodString;
+        bundleUrl: z.ZodOptional<z.ZodURL>;
+        bundleHost: z.ZodOptional<z.ZodString>;
+        bundleSri: z.ZodOptional<z.ZodString>;
+        styleUrl: z.ZodOptional<z.ZodURL>;
+        connect: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodURL>>>;
+        requires: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        typesUrl: z.ZodOptional<z.ZodURL>;
+        typesSri: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, {
+    gadgets: {
+        exports: ({
+            hook: string;
+            description?: string | undefined;
+            usage?: string | undefined;
+            example?: import("@ggui-ai/protocol").JsonValue | undefined;
+            permission?: string | undefined;
+            gotchas?: string | undefined;
+        } | {
+            component: string;
+            description?: string | undefined;
+            usage?: string | undefined;
+            example?: import("@ggui-ai/protocol").JsonValue | undefined;
+            permission?: string | undefined;
+            gotchas?: string | undefined;
+        })[];
+        version: string;
+        package: string;
+        bundleUrl?: string | undefined;
+        bundleHost?: string | undefined;
+        bundleSri?: string | undefined;
+        styleUrl?: string | undefined;
+        connect?: readonly string[] | undefined;
+        requires?: readonly string[] | undefined;
+        typesUrl?: string | undefined;
+        typesSri?: string | undefined;
+    }[];
+}>;
 export {};
 //# sourceMappingURL=list-gadgets.d.ts.map

package/dist/app-discovery/list-gadgets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-gadgets.d.ts","sourceRoot":"","sources":["../../src/app-discovery/list-gadgets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,EAGL,KAAK,gBAAgB,EACtB,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjE,QAAA,MAAM,WAAW;;CAQP,CAAC;AAkBX,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAER,CAAC;AAEX,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;CAC7C;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,OAAO,EAAE,SAAS,gBAAgB,EAAE,CAAC;CAC/C;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,0BAA0B,GAC/B,aAAa,CACd,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,qBAAqB,CACtB,CA6BA"}
+{"version":3,"file":"list-gadgets.d.ts","sourceRoot":"","sources":["../../src/app-discovery/list-gadgets.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAKxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAsC,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AA6BnF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAER,CAAC;AAEX,MAAM,WAAW,0BAA0B;IACzC;;;;;OAKG;IACH,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;CAC7C;AAED,oFAAoF;AACpF,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,YAAY,CAAC,CAAC;AAErE,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+B5E"}

package/dist/app-discovery/list-gadgets.js

@@ -43,6 +43,7 @@
  */
 import { z } from 'zod';
 import { resolveAppGadgets, gadgetDescriptorSchema, } from '@ggui-ai/protocol';
+import { defineHandler } from '../types.js';
 import { AppAccessDeniedError } from './errors.js';
 const inputSchema = {
     appId: z
@@ -70,7 +71,7 @@ const outputSchema = {
     gadgets: z.array(gadgetEntryWireSchema),
 };
 export function createGguiListGadgetsHandler(deps) {
-    return {
+    return defineHandler({
         name: 'ggui_list_gadgets',
         title: 'List gadgets',
         audience: ['agent'],
@@ -90,7 +91,9 @@ export function createGguiListGadgetsHandler(deps) {
             // get a meaningful catalog. This mirrors the cloud DDB adapter's
             // default-on-read pattern at the row-projection site.
             const gadgets = resolveAppGadgets(app?.gadgets);
-            return { gadgets };
+            // A fresh copy: the resolver may hand back the stdlib singleton, which is
+            // a resolver-internal guard, never a wire fact — the wire is mutable JSON.
+            return { gadgets: [...gadgets] };
         },
-    };
+    });
 }

package/dist/app-discovery/list-themes.d.ts

@@ -25,10 +25,7 @@
  */
 import { z } from 'zod';
 import type { AppMetadataStore } from '@ggui-ai/mcp-server-core';
-import type { SharedHandler } from '../types.js';
-declare const inputSchema: {
-    readonly appId: z.ZodOptional<z.ZodString>;
-};
+import { type ShapeOutput } from '../types.js';
 declare const outputSchema: {
     readonly themes: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -38,7 +35,7 @@ declare const outputSchema: {
             light: "light";
             dark: "dark";
         }>>;
-    }, z.core.$loose>>;
+    }, z.core.$strip>>;
 };
 export interface ThemeCatalogEntry {
     readonly id: string;
@@ -62,9 +59,27 @@ export interface GguiListThemesHandlerDeps {
      */
     readonly themes: () => readonly ThemeCatalogEntry[];
 }
-export interface GguiListThemesOutput {
-    readonly themes: readonly ThemeCatalogEntry[];
-}
-export declare function createGguiListThemesHandler(deps: GguiListThemesHandlerDeps): SharedHandler<typeof inputSchema, typeof outputSchema, GguiListThemesOutput>;
+/** The wire shape — derived from `outputSchema`, the one source of truth (#817). */
+export type GguiListThemesOutput = ShapeOutput<typeof outputSchema>;
+export declare function createGguiListThemesHandler(deps: GguiListThemesHandlerDeps): import("../types.js").SharedHandler<{
+    readonly appId: z.ZodOptional<z.ZodString>;
+}, {
+    readonly themes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodString;
+        modes: z.ZodArray<z.ZodEnum<{
+            light: "light";
+            dark: "dark";
+        }>>;
+    }, z.core.$strip>>;
+}, {
+    themes: {
+        id: string;
+        name: string;
+        description: string;
+        modes: ("light" | "dark")[];
+    }[];
+}>;
 export {};
 //# sourceMappingURL=list-themes.d.ts.map

package/dist/app-discovery/list-themes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"list-themes.d.ts","sourceRoot":"","sources":["../../src/app-discovery/list-themes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjE,QAAA,MAAM,WAAW;;CAQP,CAAC;AAkBX,QAAA,MAAM,YAAY;;;;;;;;;;CAER,CAAC;AAEX,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,iBAAiB,EAAE,CAAC;CACrD;AAED,MAAM,WAAW,oBAAoB;IACnC,QAAQ,CAAC,MAAM,EAAE,SAAS,iBAAiB,EAAE,CAAC;CAC/C;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,yBAAyB,GAC9B,aAAa,CACd,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,oBAAoB,CACrB,CAgCA"}
+{"version":3,"file":"list-themes.d.ts","sourceRoot":"","sources":["../../src/app-discovery/list-themes.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AACjE,OAAO,EAAsC,KAAK,WAAW,EAAE,MAAM,aAAa,CAAC;AA8BnF,QAAA,MAAM,YAAY;;;;;;;;;;CAER,CAAC;AAEX,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,OAAO,GAAG,MAAM,CAAC,EAAE,CAAC;CAC/C;AAED,MAAM,WAAW,yBAAyB;IACxC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,gBAAgB,CAAC;IAC5C;;;;;;OAMG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,SAAS,iBAAiB,EAAE,CAAC;CACrD;AAED,oFAAoF;AACpF,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,YAAY,CAAC,CAAC;AAEpE,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,yBAAyB;;;;;;;;;;;;;;;;;;;GAyC1E"}

package/dist/app-discovery/list-themes.js

@@ -24,6 +24,7 @@
  * apply a chosen theme.
  */
 import { z } from 'zod';
+import { defineHandler } from '../types.js';
 import { AppAccessDeniedError } from './errors.js';
 const inputSchema = {
     appId: z
@@ -39,19 +40,20 @@ const inputSchema = {
  * `themes` resolver and is responsible for whatever upstream shape
  * produces it.
  */
-const themeEntryWireSchema = z
-    .object({
+// Closed: the wire carries exactly the four documented keys. A catalog
+// entry's undeclared extras (a resolver's `metadata`, say) stay seam-side —
+// declare a key here if agents should see it.
+const themeEntryWireSchema = z.object({
     id: z.string().min(1),
     name: z.string(),
     description: z.string(),
     modes: z.array(z.enum(['light', 'dark'])),
-})
-    .passthrough();
+});
 const outputSchema = {
     themes: z.array(themeEntryWireSchema),
 };
 export function createGguiListThemesHandler(deps) {
-    return {
+    return defineHandler({
         name: 'ggui_list_themes',
         title: 'List themes',
         audience: ['agent'],
@@ -70,11 +72,19 @@ export function createGguiListThemesHandler(deps) {
             // (so the picker UI stays stable) and silently drops ids that
             // appear in the allowlist but aren't registered (defensive
             // against operator typos — agent still sees a working list).
-            if (app?.availableThemeIds && app.availableThemeIds.length > 0) {
-                const allowed = new Set(app.availableThemeIds);
-                return { themes: catalog.filter((t) => allowed.has(t.id)) };
-            }
-            return { themes: catalog };
+            const visible = app?.availableThemeIds && app.availableThemeIds.length > 0
+                ? catalog.filter((t) => new Set(app.availableThemeIds).has(t.id))
+                : catalog;
+            // Project the seam entries onto the wire shape — exactly the four keys
+            // `outputSchema` declares, as fresh mutable values.
+            return {
+                themes: visible.map((t) => ({
+                    id: t.id,
+                    name: t.name,
+                    description: t.description,
+                    modes: [...t.modes],
+                })),
+            };
         },
-    };
+    });
 }

package/dist/blueprints/describe-blueprint-format.d.ts

@@ -8,18 +8,37 @@
  * composing from stale training-data assumptions about the shape.
  */
 import { z } from 'zod';
-import type { SharedHandler } from '../types.js';
-declare const inputSchema: {};
-declare const outputSchema: {
+export declare function createDescribeBlueprintFormatHandler(): import("../types.js").SharedHandler<{}, {
     format: z.ZodLiteral<"AgentBlueprint">;
     documentation: z.ZodString;
     example: z.ZodRecord<z.ZodString, z.ZodUnknown>;
-};
-interface DescribeBlueprintFormatOutput {
-    readonly format: 'AgentBlueprint';
-    readonly documentation: string;
-    readonly example: Record<string, unknown>;
-}
-export declare function createDescribeBlueprintFormatHandler(): SharedHandler<typeof inputSchema, typeof outputSchema, DescribeBlueprintFormatOutput>;
-export {};
+}, {
+    format: "AgentBlueprint";
+    documentation: string;
+    example: {
+        source: string;
+        contract: {
+            propsSpec: {
+                properties: {
+                    greeting: {
+                        schema: {
+                            type: string;
+                        };
+                        required: boolean;
+                        description: string;
+                    };
+                };
+            };
+            actionSpec: {
+                dismiss: {
+                    label: string;
+                    description: string;
+                };
+            };
+        };
+        fixtureProps: {
+            greeting: string;
+        };
+    };
+}>;
 //# sourceMappingURL=describe-blueprint-format.d.ts.map

package/dist/blueprints/describe-blueprint-format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe-blueprint-format.d.ts","sourceRoot":"","sources":["../../src/blueprints/describe-blueprint-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,QAAA,MAAM,WAAW,IAAK,CAAC;AAEvB,QAAA,MAAM,YAAY;;;;CAIjB,CAAC;AAEF,UAAU,6BAA6B;IACrC,QAAQ,CAAC,MAAM,EAAE,gBAAgB,CAAC;IAClC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC3C;AA6GD,wBAAgB,oCAAoC,IAAI,aAAa,CACnE,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,6BAA6B,CAC9B,CAiBA"}
+{"version":3,"file":"describe-blueprint-format.d.ts","sourceRoot":"","sources":["../../src/blueprints/describe-blueprint-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAsHxB,wBAAgB,oCAAoC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiBnD"}

package/dist/blueprints/describe-blueprint-format.js

@@ -8,6 +8,7 @@
  * composing from stale training-data assumptions about the shape.
  */
 import { z } from 'zod';
+import { defineHandler } from '../types.js';
 const inputSchema = {};
 const outputSchema = {
     format: z.literal('AgentBlueprint'),
@@ -120,7 +121,7 @@ export default function Hello(props: Props) {
     },
 };
 export function createDescribeBlueprintFormatHandler() {
-    return {
+    return defineHandler({
         name: 'ggui_protocol_describe_blueprint_format',
         title: 'Describe blueprint format',
         audience: ['protocol'],
@@ -134,5 +135,5 @@ export function createDescribeBlueprintFormatHandler() {
                 example: EXAMPLE,
             };
         },
-    };
+    });
 }

package/dist/blueprints/describe-data-contract-format.d.ts

@@ -8,24 +8,19 @@
  * what Claude composes and what `ggui_protocol_validate_blueprint` expects.
  */
 import { z } from 'zod';
-import type { SharedHandler } from '../types.js';
-declare const inputSchema: {};
-declare const outputSchema: {
+export declare function createDescribeDataContractFormatHandler(): import("../types.js").SharedHandler<{}, {
     format: z.ZodLiteral<"DataContract">;
     documentation: z.ZodString;
     examples: z.ZodArray<z.ZodObject<{
         title: z.ZodString;
         contract: z.ZodRecord<z.ZodString, z.ZodUnknown>;
     }, z.core.$strip>>;
-};
-interface DescribeDataContractFormatOutput {
-    readonly format: 'DataContract';
-    readonly documentation: string;
-    readonly examples: ReadonlyArray<{
-        readonly title: string;
-        readonly contract: Record<string, unknown>;
-    }>;
-}
-export declare function createDescribeDataContractFormatHandler(): SharedHandler<typeof inputSchema, typeof outputSchema, DescribeDataContractFormatOutput>;
-export {};
+}, {
+    format: "DataContract";
+    documentation: string;
+    examples: {
+        title: string;
+        contract: Record<string, unknown>;
+    }[];
+}>;
 //# sourceMappingURL=describe-data-contract-format.d.ts.map

package/dist/blueprints/describe-data-contract-format.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"describe-data-contract-format.d.ts","sourceRoot":"","sources":["../../src/blueprints/describe-data-contract-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,QAAA,MAAM,WAAW,IAAK,CAAC;AAEvB,QAAA,MAAM,YAAY;;;;;;;CASjB,CAAC;AAEF,UAAU,gCAAgC;IACxC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;IAChC,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC;QAC/B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;QACvB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KAC5C,CAAC,CAAC;CACJ;AAyUD,wBAAgB,uCAAuC,IAAI,aAAa,CACtE,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,gCAAgC,CACjC,CAiBA"}
+{"version":3,"file":"describe-data-contract-format.d.ts","sourceRoot":"","sources":["../../src/blueprints/describe-data-contract-format.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AA2VxB,wBAAgB,uCAAuC;;;;;;;;;;;;;;GAkBtD"}

package/dist/blueprints/describe-data-contract-format.js

@@ -9,6 +9,7 @@
  */
 import { z } from 'zod';
 import { RETIRED_CONTRACT_FIELDS } from '@ggui-ai/protocol';
+import { defineHandler } from '../types.js';
 const inputSchema = {};
 const outputSchema = {
     format: z.literal('DataContract'),
@@ -343,7 +344,7 @@ const EXAMPLES = [
     },
 ];
 export function createDescribeDataContractFormatHandler() {
-    return {
+    return defineHandler({
         name: 'ggui_protocol_describe_data_contract_format',
         title: 'Describe data contract format',
         audience: ['protocol'],
@@ -354,8 +355,9 @@ export function createDescribeDataContractFormatHandler() {
             return {
                 format: 'DataContract',
                 documentation: DOCUMENTATION,
-                examples: EXAMPLES,
+                // A fresh copy: the wire is mutable JSON, the module constant is not ours to hand out.
+                examples: [...EXAMPLES],
             };
         },
-    };
+    });
 }

package/dist/blueprints/get-blueprint-boilerplate.d.ts

@@ -18,8 +18,7 @@
  * is the load-bearing input: a richer contract → a more complete scaffold.
  */
 import { z } from 'zod';
-import type { SharedHandler } from '../types.js';
-declare const inputSchema: {
+export declare function createGetBlueprintBoilerplateHandler(): import("../types.js").SharedHandler<{
     contract: z.ZodUnknown;
     intent: z.ZodOptional<z.ZodString>;
     shell: z.ZodDefault<z.ZodEnum<{
@@ -33,13 +32,9 @@ declare const inputSchema: {
         desktop: "desktop";
         universal: "universal";
     }>>;
-};
-declare const outputSchema: {
+}, {
     source: z.ZodString;
-};
-interface GetBlueprintBoilerplateOutput {
-    readonly source: string;
-}
-export declare function createGetBlueprintBoilerplateHandler(): SharedHandler<typeof inputSchema, typeof outputSchema, GetBlueprintBoilerplateOutput>;
-export {};
+}, {
+    source: string;
+}>;
 //# sourceMappingURL=get-blueprint-boilerplate.d.ts.map

package/dist/blueprints/get-blueprint-boilerplate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-blueprint-boilerplate.d.ts","sourceRoot":"","sources":["../../src/blueprints/get-blueprint-boilerplate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;CAwBhB,CAAC;AAEF,QAAA,MAAM,YAAY;;CAEjB,CAAC;AAEF,UAAU,6BAA6B;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAED,wBAAgB,oCAAoC,IAAI,aAAa,CACnE,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,6BAA6B,CAC9B,CAqBA"}
+{"version":3,"file":"get-blueprint-boilerplate.d.ts","sourceRoot":"","sources":["../../src/blueprints/get-blueprint-boilerplate.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuCxB,wBAAgB,oCAAoC;;;;;;;;;;;;;;;;;;GAqBnD"}

package/dist/blueprints/get-blueprint-boilerplate.js

@@ -19,6 +19,7 @@
  */
 import { z } from 'zod';
 import { generateBoilerplate, } from '@ggui-ai/ui-gen/boilerplate';
+import { defineHandler } from '../types.js';
 const inputSchema = {
     contract: z
         .unknown()
@@ -40,7 +41,7 @@ const outputSchema = {
     source: z.string().describe('TSX source ready to compile + render.'),
 };
 export function createGetBlueprintBoilerplateHandler() {
-    return {
+    return defineHandler({
         name: 'ggui_protocol_get_blueprint_boilerplate',
         title: 'Get blueprint boilerplate',
         audience: ['protocol'],
@@ -53,5 +54,5 @@ export function createGetBlueprintBoilerplateHandler() {
             const source = generateBoilerplate(parsed.intent ?? '', contract, parsed.shell, parsed.screen);
             return { source };
         },
-    };
+    });
 }

package/dist/blueprints/get-example-blueprints.d.ts

@@ -24,16 +24,14 @@
  * generative path; this is the curated reference path.
  */
 import { z } from 'zod';
-import type { SharedHandler } from '../types.js';
-declare const inputSchema: {
+export declare function createGetExampleBlueprintsHandler(): import("../types.js").SharedHandler<{
     kind: z.ZodDefault<z.ZodEnum<{
         display: "display";
         collect: "collect";
         converse: "converse";
         all: "all";
     }>>;
-};
-declare const outputSchema: {
+}, {
     examples: z.ZodArray<z.ZodObject<{
         title: z.ZodString;
         kind: z.ZodEnum<{
@@ -48,20 +46,16 @@ declare const outputSchema: {
             fixtureProps: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
         }, z.core.$strip>;
     }, z.core.$strip>>;
-};
-interface ExampleBlueprintEntry {
-    readonly title: string;
-    readonly kind: 'display' | 'collect' | 'converse';
-    readonly summary: string;
-    readonly blueprint: {
-        readonly source: string;
-        readonly contract: Record<string, unknown>;
-        readonly fixtureProps?: Record<string, unknown>;
-    };
-}
-interface GetExampleBlueprintsOutput {
-    readonly examples: ReadonlyArray<ExampleBlueprintEntry>;
-}
-export declare function createGetExampleBlueprintsHandler(): SharedHandler<typeof inputSchema, typeof outputSchema, GetExampleBlueprintsOutput>;
-export {};
+}, {
+    examples: {
+        title: string;
+        kind: "display" | "collect" | "converse";
+        summary: string;
+        blueprint: {
+            source: string;
+            contract: Record<string, unknown>;
+            fixtureProps?: Record<string, unknown> | undefined;
+        };
+    }[];
+}>;
 //# sourceMappingURL=get-example-blueprints.d.ts.map

package/dist/blueprints/get-example-blueprints.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-example-blueprints.d.ts","sourceRoot":"","sources":["../../src/blueprints/get-example-blueprints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAEjD,QAAA,MAAM,WAAW;;;;;;;CAOhB,CAAC;AAEF,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;CAajB,CAAC;AAEF,UAAU,qBAAqB;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,SAAS,GAAG,SAAS,GAAG,UAAU,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE;QAClB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC3C,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;KACjD,CAAC;CACH;AAED,UAAU,0BAA0B;IAClC,QAAQ,CAAC,QAAQ,EAAE,aAAa,CAAC,qBAAqB,CAAC,CAAC;CACzD;AAuQD,wBAAgB,iCAAiC,IAAI,aAAa,CAChE,OAAO,WAAW,EAClB,OAAO,YAAY,EACnB,0BAA0B,CAC3B,CAkBA"}
+{"version":3,"file":"get-example-blueprints.d.ts","sourceRoot":"","sources":["../../src/blueprints/get-example-blueprints.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAqSxB,wBAAgB,iCAAiC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkBhD"}

package/dist/blueprints/get-example-blueprints.js

@@ -24,6 +24,7 @@
  * generative path; this is the curated reference path.
  */
 import { z } from 'zod';
+import { defineHandler } from '../types.js';
 const inputSchema = {
     kind: z
         .enum(['display', 'collect', 'converse', 'all'])
@@ -297,7 +298,7 @@ const ALL_EXAMPLES = [
     CHAT_PANEL,
 ];
 export function createGetExampleBlueprintsHandler() {
-    return {
+    return defineHandler({
         name: 'ggui_protocol_get_example_blueprints',
         title: 'Get example blueprints',
         audience: ['protocol'],
@@ -311,5 +312,5 @@ export function createGetExampleBlueprintsHandler() {
                 : ALL_EXAMPLES.filter((ex) => ex.kind === parsed.kind);
             return { examples: [...filtered] };
         },
-    };
+    });
 }