@ggui-ai/protocol 0.8.0 → 0.10.0

package/dist/schemas/blueprint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blueprint.d.ts","sourceRoot":"","sources":["../../src/schemas/blueprint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,wBAAwB,EACxB,SAAS,EACT,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAGnC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAMvB,CAAC;AAE7C,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAExB,CAAC;AAE9C,oDAAoD;AACpD,eAAO,MAAM,4BAA4B,EAAE,CAAC,CAAC,OAAO,CAAC,sBAAsB,CAE3B,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAI7B,CAAC;AAEjC;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAqBtB,CAAC;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAwBd,CAAC;AAmBpC;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAAO,CAAC,wBAAwB,CAM7B,CAAC"}
+{"version":3,"file":"blueprint.d.ts","sourceRoot":"","sources":["../../src/schemas/blueprint.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,wBAAwB,EACxB,SAAS,EACT,iBAAiB,EAClB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,eAAe,EACf,sBAAsB,EACtB,kBAAkB,EAClB,mBAAmB,EACpB,MAAM,2BAA2B,CAAC;AAGnC;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,CAAC,CAAC,OAAO,CAAC,kBAAkB,CAMvB,CAAC;AAE7C,0EAA0E;AAC1E,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CAExB,CAAC;AAE9C,oDAAoD;AACpD,eAAO,MAAM,4BAA4B,EAAE,CAAC,CAAC,OAAO,CAAC,sBAAsB,CAE3B,CAAC;AAEjD;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,EAAE,CAAC,CAAC,OAAO,CAAC,eAAe,CAI7B,CAAC;AAEjC;;;;;;;;;GASG;AACH,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,4DAA6D,CAAC;AAElG,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAgCtB,CAAC;AAE5C;;;;;GAKG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAwBd,CAAC;AAmBpC;;;GAGG;AACH,eAAO,MAAM,8BAA8B,EAAE,CAAC,CAAC,OAAO,CAAC,wBAAwB,CAM7B,CAAC"}

package/dist/schemas/blueprint.js

@@ -48,6 +48,8 @@ export const blueprintSourceSchema = z.union([
  * metadata via `tools/list`, so they stay mechanism-only and
  * vendor-neutral.
  */
+/** The four — and only — variance keys; the strict object names them on rejection. */
+export const BLUEPRINT_VARIANCE_KEYS = ['persona', 'aesthetic', 'context', 'seedPrompt'];
 export const blueprintVarianceSchema = z
     .object({
     persona: z
@@ -66,6 +68,13 @@ export const blueprintVarianceSchema = z
         .string()
         .optional()
         .describe('Generation seed directive. Part of cache identity.'),
+}, {
+    // A rejection that teaches (ggui#523 item 2): the first live guest
+    // turn sent `mood` and got a bare "Unrecognized key" — name the
+    // legal set and where the misplaced intent belongs.
+    error: (issue) => issue.code === 'unrecognized_keys'
+        ? `variance: unknown key(s) ${issue.keys.map((k) => JSON.stringify(k)).join(', ')} — variance is EXACTLY {${BLUEPRINT_VARIANCE_KEYS.join(', ')}}; put tonal intent in \`aesthetic\`, and per-user runtime data in props / contextSpec, never in variance`
+        : undefined,
 })
     .strict();
 /**

package/dist/schemas/data-contract.d.ts

@@ -58,13 +58,6 @@ import type { DataContract, JsonValue, JsonSchema } from '../types/data-contract
  * values, examples, or arbitrary JSON payloads use this.
  */
 export declare const jsonValueSchema: z.ZodType<JsonValue>;
-/**
- * {@link JsonSchema} — JSON Schema draft-07 subset. Mirrors the
- * fields the TS interface enumerates. `additionalProperties` and
- * `items` are recursive — kept loose (`z.unknown()`) to avoid
- * deep `z.lazy` chains; the F4 schema-subset checker validates
- * full structural correctness at render time.
- */
 export declare const jsonSchemaSchema: z.ZodType<JsonSchema>;
 /**
  * {@link PropEntry} — per-prop metadata in a {@link PropsSpec}.
@@ -753,5 +746,66 @@ export declare const appPublicEnvSchema: z.ZodReadonly<z.ZodRecord<z.ZodString,
  * posture (`handshakeInputSchema`, `renderInputSchema`, etc. all
  * `passthrough` for the same reason).
  */
+/**
+ * The one-paragraph shape rule every teaching surface quotes (ggui#523
+ * item 1): the handshake's tool description, the loose `contract`
+ * field the handshake publishes on `tools/list`, and the format doc.
+ * One constant, so the wording cannot drift between them. Mechanism-
+ * only and vendor-neutral — it ships as JSON-Schema metadata to every
+ * agent that lists the tools.
+ */
+export declare const DATA_CONTRACT_SHAPE_RULE: string;
+/**
+ * A minimal, complete, valid example — published beside the rule so a
+ * first-time caller can copy a shape that parses (JSON-Schema
+ * `examples`). Deliberately tiny: one prop, one action with a payload,
+ * one context slot.
+ */
+export declare const DATA_CONTRACT_MINIMAL_EXAMPLE: {
+    readonly propsSpec: {
+        readonly properties: {
+            readonly items: {
+                readonly schema: {
+                    readonly type: "array";
+                    readonly items: {
+                        readonly type: "object";
+                        readonly properties: {
+                            readonly id: {
+                                readonly type: "string";
+                            };
+                            readonly title: {
+                                readonly type: "string";
+                            };
+                        };
+                        readonly required: readonly ["id", "title"];
+                    };
+                };
+                readonly required: true;
+            };
+        };
+    };
+    readonly actionSpec: {
+        readonly toggle: {
+            readonly label: "Toggle";
+            readonly schema: {
+                readonly type: "object";
+                readonly properties: {
+                    readonly id: {
+                        readonly type: "string";
+                    };
+                };
+                readonly required: readonly ["id"];
+            };
+        };
+    };
+    readonly contextSpec: {
+        readonly filter: {
+            readonly schema: {
+                readonly type: "string";
+            };
+            readonly default: "all";
+        };
+    };
+};
 export declare const dataContractSchema: z.ZodType<DataContract>;
 //# sourceMappingURL=data-contract.d.ts.map

package/dist/schemas/data-contract.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"data-contract.d.ts","sourceRoot":"","sources":["../../src/schemas/data-contract.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"data-contract.d.ts","sourceRoot":"","sources":["../../src/schemas/data-contract.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAIxB,OAAO,KAAK,EACV,YAAY,EACZ,SAAS,EACT,UAAU,EACX,MAAM,wBAAwB,CAAC;AAEhC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAYhD,CAAC;AAmBF,eAAO,MAAM,gBAAgB,EAAE,CAAC,CAAC,OAAO,CAAC,UAAU,CA2BlD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe;;;;;;;kBASjB,CAAC;AAEZ,sFAAsF;AACtF,eAAO,MAAM,eAAe;;;;;;;;;;kBAKjB,CAAC;AAEZ;;;;;;;;;;GAUG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;kBAUnB,CAAC;AAEZ,6DAA6D;AAC7D,eAAO,MAAM,gBAAgB;;;;;;;;mBAA0C,CAAC;AAExE,iFAAiF;AACjF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;kBAgB1B,CAAC;AAEZ,uEAAuE;AACvE,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;mBAAiD,CAAC;AAE/E,yEAAyE;AACzE,eAAO,MAAM,kBAAkB;;;;;;kBAQpB,CAAC;AAEZ,+DAA+D;AAC/D,eAAO,MAAM,iBAAiB;;;;;;mBAA2C,CAAC;AAE1E,sFAAsF;AACtF,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;kBAiBtB,CAAC;AAEZ,qEAAqE;AACrE,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;;;;iBAIxB,CAAC;AAEjB;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,QAAiC,CAAC;AAEpE;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,oBAAoB,wCAEpB,CAAC;AAEd;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,aAAa,QAA8B,CAAC;AAEzD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,mBAAmB,QACsB,CAAC;AAEvD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,QAAyC,CAAC;AAEpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,QAAyB,CAAC;AAErD;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,qBAAqB,CAAC;AAEtD;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,gBAAgB,QAAiD,CAAC;AAE/E;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;;;GAQG;AACH,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAC;AAwExE;;;;;;;;GAQG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;oBAa7B,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAanC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;kBAKxB,CAAC;AAEZ;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAK9B,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,gCAAgC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAU1C,CAAC;AAQJ;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;;;kBAKvB,CAAC;AAEZ;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,sBAAsB;;;mBAa/B,CAAC;AAEL;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,4BAA4B;;;;;kBAO9B,CAAC;AAEZ;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB,sDAElB,CAAC;AAEd;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,QAQa,CAAC;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAehC,CAAC;AAEX,eAAO,MAAM,kBAAkB,EAAE,CAAC,CAAC,OAAO,CAAC,YAAY,CAiCZ,CAAC"}

package/dist/schemas/data-contract.js

@@ -77,17 +77,26 @@ export const jsonValueSchema = z.lazy(() => z.union([
  * deep `z.lazy` chains; the F4 schema-subset checker validates
  * full structural correctness at render time.
  */
+const jsonSchemaTypeNameSchema = z.enum([
+    'string',
+    'number',
+    'integer',
+    'boolean',
+    'array',
+    'object',
+    'null',
+]);
 export const jsonSchemaSchema = z.lazy(() => z
     .object({
+    // Single type OR a draft-07 type array (`['string','null']` —
+    // the canonical nullability form the enforced-props-schema
+    // emission produces). Mirrors `JsonSchemaTypeName | JsonSchemaTypeName[]`
+    // on the TS type — the zod and TS sides are an SSoT pair; widen
+    // both or neither.
     type: z
-        .enum([
-        'string',
-        'number',
-        'integer',
-        'boolean',
-        'array',
-        'object',
-        'null',
+        .union([
+        jsonSchemaTypeNameSchema,
+        z.array(jsonSchemaTypeNameSchema),
     ])
         .optional(),
     description: z.string().optional(),
@@ -661,13 +670,63 @@ export const appPublicEnvSchema = z
  * posture (`handshakeInputSchema`, `renderInputSchema`, etc. all
  * `passthrough` for the same reason).
  */
+/**
+ * The one-paragraph shape rule every teaching surface quotes (ggui#523
+ * item 1): the handshake's tool description, the loose `contract`
+ * field the handshake publishes on `tools/list`, and the format doc.
+ * One constant, so the wording cannot drift between them. Mechanism-
+ * only and vendor-neutral — it ships as JSON-Schema metadata to every
+ * agent that lists the tools.
+ */
+export const DATA_CONTRACT_SHAPE_RULE = 'DataContract = up to six top-level specs: propsSpec (initial render data), ' +
+    'actionSpec (user gestures that drive the agent\'s next turn), contextSpec (observable client state), ' +
+    'streamSpec (live update channels), agentCapabilities (MCP tools the AGENT may call — the catalog ' +
+    'actionSpec[*].nextStep and streamSpec[*].source.tool must resolve into), clientCapabilities (browser ' +
+    'gadget hooks the COMPONENT imports). EVERY entry under propsSpec.properties / actionSpec / streamSpec / ' +
+    'contextSpec is a WRAPPER object whose JSON Schema sits in its `schema:` field — never a flat JSON Schema ' +
+    'at the entry level. Wrappers reject unrecognized keys. Placement test: needs next-turn reasoning ⇒ ' +
+    'actionSpec; observed state only ⇒ contextSpec.';
+/**
+ * A minimal, complete, valid example — published beside the rule so a
+ * first-time caller can copy a shape that parses (JSON-Schema
+ * `examples`). Deliberately tiny: one prop, one action with a payload,
+ * one context slot.
+ */
+export const DATA_CONTRACT_MINIMAL_EXAMPLE = {
+    propsSpec: {
+        properties: {
+            items: {
+                schema: { type: 'array', items: { type: 'object', properties: { id: { type: 'string' }, title: { type: 'string' } }, required: ['id', 'title'] } },
+                required: true,
+            },
+        },
+    },
+    actionSpec: {
+        toggle: { label: 'Toggle', schema: { type: 'object', properties: { id: { type: 'string' } }, required: ['id'] } },
+    },
+    contextSpec: {
+        filter: { schema: { type: 'string' }, default: 'all' },
+    },
+};
 export const dataContractSchema = z
     .object({
-    propsSpec: propsSpecSchema.optional(),
-    actionSpec: actionSpecSchema.optional(),
-    streamSpec: streamSpecSchema.optional(),
-    contextSpec: contextSpecSchema.optional(),
-    agentCapabilities: agentCapabilitiesSpecSchema.optional(),
-    clientCapabilities: clientCapabilitiesSpecSchema.optional(),
+    propsSpec: propsSpecSchema
+        .optional()
+        .describe('Initial render data: {description?, properties: {<name>: {schema: <JSON Schema>, required?: boolean, description?, default?, example?}}}. A prop is required at the wire gate ONLY when `required: true`; omitted ⇒ optional (declare `required: true` for props the render must always pass).'),
+    actionSpec: actionSpecSchema
+        .optional()
+        .describe("User gestures the agent reacts to on its next turn: {<action>: {label: string (REQUIRED — button copy / accessible name), schema?: <payload JSON Schema>, description?, example?, icon?, confirm?, nextStep?: '<agentCapabilities.tools key>'}}. Every action is agent-routed; `nextStep` is a hint, not a dispatch."),
+    streamSpec: streamSpecSchema
+        .optional()
+        .describe('Live update channels the agent emits into: {<channel>: {schema: <JSON Schema>, description?, example?, mode?: append|replace, replay?: latest|all|none, complete?, source?: {tool, args?}}}. `source.tool` must be declared in agentCapabilities.tools.'),
+    contextSpec: contextSpecSchema
+        .optional()
+        .describe('Observable client state the agent reads alongside each action: {<slot>: {schema: <JSON Schema>, description?, default?, debounceMs?, example?}}. State that needs no next-turn reasoning belongs here, not in actionSpec.'),
+    agentCapabilities: agentCapabilitiesSpecSchema
+        .optional()
+        .describe("MCP tools the AGENT may call: {tools: {<bareToolName>: {toolInfo: {inputSchema (REQUIRED), description?, outputSchema?}, serverInfo?: {name, version?}, usage?, example?: {input, output}}}}. Key by the BARE tool name (after any `mcp__<server>__` prefix); the component never calls these."),
+    clientCapabilities: clientCapabilitiesSpecSchema
+        .optional()
+        .describe('Browser-capability gadgets the COMPONENT imports: {gadgets: {<npm package>: {<exportName>: {description?, usage?}}}} — `use`-prefixed export keys are hooks, PascalCase keys are components; version and transport resolve from the app\'s registered catalog, never on the wire.'),
 })
     .passthrough();

package/dist/schemas/handshake-suggestion.d.ts

@@ -21,14 +21,11 @@ export declare const jsonPatchSchema: z.ZodType<JsonPatch>;
  * normal consumers should prefer {@link blueprintDraftSchema} (typed
  * `z.ZodType<BlueprintDraft>`).
  */
+/** The three — and only — draft keys; the strict object names them on rejection. */
+export declare const BLUEPRINT_DRAFT_KEYS: readonly ["contract", "variance", "generator"];
 export declare const blueprintDraftObjectSchema: z.ZodObject<{
     contract: z.ZodType<import("../index.js").DataContract, unknown, z.core.$ZodTypeInternals<import("../index.js").DataContract, unknown>>;
-    variance: z.ZodOptional<z.ZodObject<{
-        persona: z.ZodOptional<z.ZodString>;
-        aesthetic: z.ZodOptional<z.ZodString>;
-        context: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodType<import("../index.js").JsonValue, unknown, z.core.$ZodTypeInternals<import("../index.js").JsonValue, unknown>>>>;
-        seedPrompt: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
+    variance: z.ZodOptional<z.ZodType<import("../index.js").BlueprintVariance, unknown, z.core.$ZodTypeInternals<import("../index.js").BlueprintVariance, unknown>>>;
     generator: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 /** `BlueprintDraft` — input shape on the handshake. */

package/dist/schemas/handshake-suggestion.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"handshake-suggestion.d.ts","sourceRoot":"","sources":["../../src/schemas/handshake-suggestion.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,SAAS,EACT,WAAW,EACX,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,kCAAkC,CAAC;AAI1C,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAI7D,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAezB,CAAC;AAE7B,8DAA8D;AAC9D,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAsD,CAAC;AAExG;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B;;;;;;;;;kBAc5B,CAAC;AAEZ,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAA2D,CAAC;AAEvH,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CASlB,CAAC;AAExC,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAOtB,CAAC;AAE5C,qDAAqD;AACrD,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAKzB,CAAC;AAE/C,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CASxB,CAAC"}
+{"version":3,"file":"handshake-suggestion.d.ts","sourceRoot":"","sources":["../../src/schemas/handshake-suggestion.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EACV,cAAc,EACd,aAAa,EACb,mBAAmB,EACnB,SAAS,EACT,WAAW,EACX,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,kCAAkC,CAAC;AAI1C,qEAAqE;AACrE,eAAO,MAAM,sBAAsB,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAI7D,CAAC;AAEH,mEAAmE;AACnE,eAAO,MAAM,iBAAiB,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAezB,CAAC;AAE7B,8DAA8D;AAC9D,eAAO,MAAM,eAAe,EAAE,CAAC,CAAC,OAAO,CAAC,SAAS,CAAsD,CAAC;AAExG;;;;;GAKG;AACH,oFAAoF;AACpF,eAAO,MAAM,oBAAoB,gDAAiD,CAAC;AAEnF,eAAO,MAAM,0BAA0B;;;;kBAkB5B,CAAC;AAEZ,uDAAuD;AACvD,eAAO,MAAM,oBAAoB,EAAE,CAAC,CAAC,OAAO,CAAC,cAAc,CAA2D,CAAC;AAEvH,+DAA+D;AAC/D,eAAO,MAAM,mBAAmB,EAAE,CAAC,CAAC,OAAO,CAAC,aAAa,CASlB,CAAC;AAExC,0EAA0E;AAC1E,eAAO,MAAM,uBAAuB,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAOtB,CAAC;AAE5C,qDAAqD;AACrD,eAAO,MAAM,0BAA0B,EAAE,CAAC,CAAC,OAAO,CAAC,oBAAoB,CAKzB,CAAC;AAE/C,2EAA2E;AAC3E,eAAO,MAAM,yBAAyB,EAAE,CAAC,CAAC,OAAO,CAAC,mBAAmB,CASxB,CAAC"}

package/dist/schemas/handshake-suggestion.js

@@ -41,19 +41,21 @@ export const jsonPatchSchema = z.array(jsonPatchOpSchema);
  * normal consumers should prefer {@link blueprintDraftSchema} (typed
  * `z.ZodType<BlueprintDraft>`).
  */
+/** The three — and only — draft keys; the strict object names them on rejection. */
+export const BLUEPRINT_DRAFT_KEYS = ['contract', 'variance', 'generator'];
 export const blueprintDraftObjectSchema = z
     .object({
     contract: dataContractSchema,
-    variance: z
-        .object({
-        persona: z.string().optional(),
-        aesthetic: z.string().optional(),
-        context: z.record(z.string(), jsonValueSchema).optional(),
-        seedPrompt: z.string().optional(),
-    })
-        .strict()
-        .optional(),
+    // ONE declaration of the variance shape, protocol-wide: the same
+    // schema (with its `.describe()` teaching and its legal-set
+    // rejection message) that `blueprintMeta.variance` projects on the
+    // way back out (ggui#523 item 1 — the mirror-of-a-mirror is gone).
+    variance: blueprintVarianceSchema.optional(),
     generator: z.string().optional(),
+}, {
+    error: (issue) => issue.code === 'unrecognized_keys'
+        ? `blueprintDraft: unknown key(s) ${issue.keys.map((k) => JSON.stringify(k)).join(', ')} — a draft is EXACTLY {${BLUEPRINT_DRAFT_KEYS.join(', ')}}; \`intent\` is a top-level ggui_handshake field, not a draft field, and the four specs live INSIDE \`contract\``
+        : undefined,
 })
     .strict();
 /** `BlueprintDraft` — input shape on the handshake. */

package/dist/schemas/invoke.d.ts

@@ -8,7 +8,7 @@
  * client tools — no ggui-specific block type.
  *
  * TS types in types/invoke.ts are derived from these via z.infer. Consumers
- * (@ggui-ai/server, @ggui-ai/react) import schemas for runtime validation
+ * (@ggui-ai/server, @ggui-ai/mcp-apps-react) import schemas for runtime validation
  * and types for authoring.
  */
 import { z } from 'zod';

package/dist/schemas/invoke.js

@@ -8,7 +8,7 @@
  * client tools — no ggui-specific block type.
  *
  * TS types in types/invoke.ts are derived from these via z.infer. Consumers
- * (@ggui-ai/server, @ggui-ai/react) import schemas for runtime validation
+ * (@ggui-ai/server, @ggui-ai/mcp-apps-react) import schemas for runtime validation
  * and types for authoring.
  */
 import { z } from 'zod';

package/dist/schemas/mcp.d.ts

@@ -96,6 +96,19 @@ export declare const getSessionInputShape: {
 export declare const getSessionInputSchema: z.ZodObject<{
     sessionId: z.ZodString;
 }, z.core.$strip>;
+/**
+ * `ggui_get_render_source` input — read the generated source of the
+ * calling app's own render. Same shape as {@link getSessionInputShape}
+ * (both take only a sessionId); kept as its own named export rather
+ * than reused directly so each tool's wire contract is independently
+ * pinned, per this file's one-shape-per-tool convention.
+ */
+export declare const getRenderSourceInputShape: {
+    readonly sessionId: z.ZodString;
+};
+export declare const getRenderSourceInputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+}, z.core.$strip>;
 /**
  * `ggui_list_featured_blueprints` input — intentionally EMPTY. The
  * pre-launch No-Backcompat scrub deleted the level/category/tags/limit
@@ -316,7 +329,7 @@ export declare const renderCacheMarkerSchema: z.ZodObject<{
 /**
  * Canonical failure codes for the in-result `ggui_render` failure
  * envelope (SPEC §7.9 Plane 3). Closed enum — a failed render's
- * `error.code` is always one of these four; finer-grained diagnostics
+ * `error.code` is always one of these five; finer-grained diagnostics
  * ride on `error.message`.
  *
  *   - `PRODUCTION_FAILED` — generation ran but did not produce a
@@ -328,13 +341,29 @@ export declare const renderCacheMarkerSchema: z.ZodObject<{
  *     configuration has no key for the resolved route.
  *   - `NO_CREDENTIALS` — no generation credentials are configured on
  *     the server at all.
+ *   - `GENERATION_QUEUE_OVERLOADED` — the deployment's generation
+ *     admission gate rejected this request before any generation
+ *     attempt started (concurrent-request queue full, or wait for a
+ *     free slot exceeded the configured timeout). Distinct from
+ *     `PRODUCTION_FAILED` by design: generation never ran, so callers
+ *     MUST NOT bill or count it as a failed attempt. See
+ *     {@link GenerationError} in `types/ui-generator.ts` for the full
+ *     contract.
  */
 export declare const renderErrorCodeSchema: z.ZodEnum<{
     PRODUCTION_FAILED: "PRODUCTION_FAILED";
     VALIDATION_ERROR: "VALIDATION_ERROR";
     NO_PLATFORM_KEY: "NO_PLATFORM_KEY";
     NO_CREDENTIALS: "NO_CREDENTIALS";
+    GENERATION_QUEUE_OVERLOADED: "GENERATION_QUEUE_OVERLOADED";
 }>;
+/**
+ * Canonical inferred type for {@link renderErrorCodeSchema}. Lives
+ * beside the schema (rather than in `types/mcp.ts`, which re-exports
+ * it) so `types/render.ts` can reference it without a type-only
+ * import cycle through `types/mcp.ts`.
+ */
+export type RenderErrorCode = z.infer<typeof renderErrorCodeSchema>;
 /**
  * In-result failure marker for `ggui_render`. Present on the wire
  * output iff the tool result is `isError: true` — the structuredContent
@@ -347,6 +376,7 @@ export declare const renderErrorSchema: z.ZodObject<{
         VALIDATION_ERROR: "VALIDATION_ERROR";
         NO_PLATFORM_KEY: "NO_PLATFORM_KEY";
         NO_CREDENTIALS: "NO_CREDENTIALS";
+        GENERATION_QUEUE_OVERLOADED: "GENERATION_QUEUE_OVERLOADED";
     }>;
     message: z.ZodString;
 }, z.core.$strip>;
@@ -458,6 +488,7 @@ export declare const renderOutputSchema: z.ZodObject<{
             VALIDATION_ERROR: "VALIDATION_ERROR";
             NO_PLATFORM_KEY: "NO_PLATFORM_KEY";
             NO_CREDENTIALS: "NO_CREDENTIALS";
+            GENERATION_QUEUE_OVERLOADED: "GENERATION_QUEUE_OVERLOADED";
         }>;
         message: z.ZodString;
     }, z.core.$strip>>;
@@ -467,6 +498,7 @@ export declare const renderOutputSchema: z.ZodObject<{
         example: z.ZodString;
         args: z.ZodObject<{
             sessionId: z.ZodString;
+            timeout: z.ZodNumber;
         }, z.core.$strip>;
     }, z.core.$strip>>;
 }, z.core.$strip>;
@@ -510,21 +542,55 @@ export declare const updateInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     kind: z.ZodLiteral<"merge">;
     patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
 }, z.core.$strict>], "kind">;
+/**
+ * `ggui_amend` wire input (#483) — same replace/merge mutation
+ * grammar as `ggui_update`, different mount identity: amend targets
+ * the ALREADY-MOUNTED card. No new card, no history entry, the
+ * history number does not advance. Git reading: `ggui_update` =
+ * commit; `ggui_amend` = commit --amend.
+ */
+export declare const amendInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    sessionId: z.ZodString;
+    kind: z.ZodLiteral<"replace">;
+    props: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>, z.ZodObject<{
+    sessionId: z.ZodString;
+    kind: z.ZodLiteral<"merge">;
+    patch: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strict>], "kind">;
 /**
  * Wire-output shape — minimal acknowledgement. The handler carries
  * `decision`, `contract`, `contractHash` on its internal `UpdateOutput`
  * TS shape — zod strips them before structuredContent serialization.
  *
- * Post-update the iframe receives the new props via the live-channel
- * `props_update` WS frame; the cross-host fallback path receives them
- * via the `ai.ggui/render.propsJson` slice field (see
- * `update.resultMeta`). The wire response itself is just
- * acknowledgement.
+ * Every REAL update (`updated: true`) mints a new history record and
+ * its result carries the `ai.ggui/render` slice as a FULL bootable
+ * mount package (#483 — hosts mint a per-result view for the new
+ * card); a no-op (`updated: false`) carries NO result `_meta`.
+ * Already-mounted frames are not repainted by update — they freeze as
+ * history when its higher-epoch `props_update` frame lands; the
+ * in-place repaint over the live-channel ladder (WS / SSE / polling /
+ * bridge-pull) is `ggui_amend`'s job.
  */
 export declare const updateOutputSchema: z.ZodObject<{
     sessionId: z.ZodString;
     updated: z.ZodBoolean;
     resourceUri: z.ZodString;
+    epoch: z.ZodNumber;
+    warning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * `ggui_amend` wire output (#483) — acknowledgement only. `resourceUri`
+ * is the BARE live-head URI (amend targets the mounted card; it never
+ * mints a record, so there is no pinned URI to return and no epoch
+ * field — the history number is untouched by construction). The
+ * mounted card receives the new props over the live channels.
+ */
+export declare const amendOutputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    updated: z.ZodBoolean;
+    resourceUri: z.ZodString;
+    warning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 /**
  * `ggui_runtime_declare_tool_catalog` — the host runtime declares its
@@ -560,4 +626,170 @@ export declare const declareToolCatalogOutputSchema: z.ZodObject<{
     saved: z.ZodBoolean;
     appId: z.ZodString;
 }, z.core.$strict>;
+/**
+ * Server-side page cap for `ggui_runtime_pull`. A `limit` above this is
+ * CLAMPED (not rejected) — the tool mirrors the cursor-walk posture of
+ * the `/events` HTTP route, where a too-eager page size is a tuning
+ * knob, not a caller bug. Shared so the pulling client and the serving
+ * handler agree on the effective page ceiling from one constant.
+ */
+export declare const RUNTIME_PULL_MAX_LIMIT = 100;
+/**
+ * Server-side ceiling on `ggui_runtime_pull`'s `wait` hold, in seconds.
+ * Chosen under `ggui_consume`'s proven 25-second host tolerance for
+ * held tool calls — the hold must resolve before any host-side
+ * `tools/call` timeout fires, or the transport counts a failure the
+ * server intended as a quiet success.
+ */
+export declare const RUNTIME_PULL_MAX_WAIT_SECONDS = 20;
+/**
+ * One `GguiSessionEvent` ledger row on the `ggui_runtime_pull` wire —
+ * the zod mirror of the canonical `GguiSessionEvent` interface in
+ * `types/ggui-session-event.ts` (which stays the type-level source of
+ * truth; `mcp.test.ts` pins the two together in both directions).
+ */
+export declare const gguiSessionEventSchema: z.ZodObject<{
+    seq: z.ZodNumber;
+    type: z.ZodString;
+    timestamp: z.ZodString;
+    data: z.ZodUnknown;
+}, z.core.$strip>;
+/**
+ * `ggui_runtime_pull` input — the terminal bridge-pull rung of the
+ * live-channel failover ladder (WS → SSE → HTTP polling → bridge-pull).
+ *
+ * Two named parties:
+ *
+ *   - **Puller** — the `@ggui-ai/iframe-runtime` bridge rung. In a
+ *     CSP-jailed MCP Apps host the iframe can reach no network origin
+ *     at all, so it pulls the event ledger by issuing `tools/call`
+ *     postMessages that the host's MCP client relays (the tool
+ *     registers `_meta.ui.visibility: ['app']` per MCP Apps spec §401
+ *     — hosts MUST route view-issued calls to it and MUST reject
+ *     view-issued calls to tools without it).
+ *   - **Server** — the MCP server hosting the render. It serves the
+ *     SAME `GguiSessionEvent` ledger `GET
+ *     /api/sessions/:sessionId/events` serves, through the same
+ *     `listEventsSince` read, and MUST answer with the same shapes
+ *     (see {@link runtimePullOutputSchema}) so one client parse core
+ *     handles both carriers.
+ *
+ * Divergences from the HTTP route, both deliberate: `sinceSequence` is
+ * OPTIONAL here (the bridge rung owns its cursor and seeds from 0; the
+ * route requires it because a bare browser GET has no cursor owner),
+ * and `limit` is clamped to {@link RUNTIME_PULL_MAX_LIMIT} instead of
+ * rejecting above it. Tenancy violations and unknown sessionIds
+ * surface uniformly as the `session_not_found` error — existence of
+ * other tenants' renders is never leaked.
+ */
+export declare const runtimePullInputShape: {
+    readonly sessionId: z.ZodString;
+    readonly sinceSequence: z.ZodOptional<z.ZodNumber>;
+    readonly limit: z.ZodOptional<z.ZodNumber>;
+    readonly wait: z.ZodOptional<z.ZodNumber>;
+};
+export declare const runtimePullInputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    sinceSequence: z.ZodOptional<z.ZodNumber>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    wait: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+/**
+ * Normal-page arm — EXACT `EventsResponse` parity with
+ * `GET /api/sessions/:sessionId/events` (same keys, same semantics):
+ * `events` strictly ascending by seq, `lastSequence` = the render's
+ * current high-water mark (NOT the page's last seq — advances the
+ * cursor on empty pages), `hasMore` = the page was truncated by
+ * `limit`.
+ */
+export declare const runtimePullEventsPageSchema: z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        type: z.ZodString;
+        timestamp: z.ZodString;
+        data: z.ZodUnknown;
+    }, z.core.$strip>>;
+    lastSequence: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * Replay-horizon arm — parity with the route's 410 body, but on this
+ * carrier it is a NORMAL result arm, not an error: the bridge rung is
+ * terminal and treats it as a re-sync instruction. Returned when the
+ * cursor fell out of the replayable window on EITHER side
+ * (`sinceSequence` above the server's `lastSequence` — a cursor from a
+ * different deployment/reset render — or below the retention horizon).
+ * Client recovery: re-mount state from a fresh snapshot and reset the
+ * cursor to `currentSequence`.
+ */
+export declare const runtimePullHorizonSchema: z.ZodObject<{
+    reason: z.ZodLiteral<"REPLAY_HORIZON_PASSED">;
+    currentSequence: z.ZodNumber;
+}, z.core.$strip>;
+/**
+ * `ggui_runtime_pull` output — the canonical strict wire contract, a
+ * two-arm union: {@link runtimePullEventsPageSchema} (normal page) |
+ * {@link runtimePullHorizonSchema} (cursor out of window). The handler
+ * registers a flat raw shape (MCP tool registration takes a
+ * `ZodRawShape`, which cannot express a top-level union) and its
+ * alignment test pins that shape to this union — same posture as
+ * `updateInputSchema`.
+ */
+export declare const runtimePullOutputSchema: z.ZodUnion<readonly [z.ZodObject<{
+    events: z.ZodArray<z.ZodObject<{
+        seq: z.ZodNumber;
+        type: z.ZodString;
+        timestamp: z.ZodString;
+        data: z.ZodUnknown;
+    }, z.core.$strip>>;
+    lastSequence: z.ZodNumber;
+    hasMore: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    reason: z.ZodLiteral<"REPLAY_HORIZON_PASSED">;
+    currentSequence: z.ZodNumber;
+}, z.core.$strip>]>;
+/**
+ * Per-batch event cap on `ggui_runtime_telemetry` — a bounded
+ * fire-and-forget diagnostic channel, never a data plane.
+ */
+export declare const RUNTIME_TELEMETRY_MAX_EVENTS = 40;
+/**
+ * `ggui_runtime_telemetry` input — the iframe runtime's transport
+ * self-report (`_meta.ui.visibility: ['app']`, view-callable only).
+ *
+ * Contract (both parties named): the IFRAME RUNTIME batches short
+ * `{at, kind, detail?}` events describing its delivery-ladder journey
+ * (boot-path decision, per-rung status transitions and failures —
+ * `channel_failover_swap`, `channel_polling_budget_exhausted`, … —
+ * and outbound doorbell rings) and flushes them over the host's
+ * `tools/call` postMessage bridge; the SERVER logs one structured
+ * line per batch for operator forensics and stores NOTHING. Sandboxed
+ * hosts (claude.ai's `claudemcpcontent.com` frames) expose no
+ * readable console and no network — this tool is the ONLY way the
+ * ladder's behavior on such hosts reaches an operator. `sessionId` is
+ * client-claimed (log-tagged, never trusted for reads); events are
+ * bounded (≤ {@link RUNTIME_TELEMETRY_MAX_EVENTS} per batch, `kind` ≤
+ * 64 chars, `detail` ≤ 512) so a hostile view cannot use the channel
+ * for bulk exfiltration or log flooding.
+ */
+export declare const runtimeTelemetryInputShape: {
+    readonly sessionId: z.ZodString;
+    readonly events: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        kind: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+};
+export declare const runtimeTelemetryInputSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    events: z.ZodArray<z.ZodObject<{
+        at: z.ZodNumber;
+        kind: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/** `ggui_runtime_telemetry` output — bare acknowledgement. */
+export declare const runtimeTelemetryOutputSchema: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
 //# sourceMappingURL=mcp.d.ts.map

package/dist/schemas/mcp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/schemas/mcp.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAUxB,eAAO,MAAM,cAAc;;;iBAGzB,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAUnB,CAAC;AAYjB;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;CAgBpB,CAAC;AAEX,eAAO,MAAM,kBAAkB;;;iBAA8B,CAAC;AAE9D;;;GAGG;AACH,eAAO,MAAM,cAAc;;;;;CAKjB,CAAC;AAEX,eAAO,MAAM,eAAe;;;;;iBAA2B,CAAC;AAExD,eAAO,MAAM,oBAAoB;;CAKvB,CAAC;AAEX,eAAO,MAAM,qBAAqB;;iBAAiC,CAAC;AAEpE;;;;;GAKG;AACH,eAAO,MAAM,gCAAgC,IAAc,CAAC;AAE5D,eAAO,MAAM,iCAAiC,gCAE7C,CAAC;AAEF,eAAO,MAAM,0BAA0B;;;;;CAwB7B,CAAC;AAEX,eAAO,MAAM,2BAA2B;;;;;iBAAuC,CAAC;AAEhF,eAAO,MAAM,yBAAyB;;CAO5B,CAAC;AAEX,eAAO,MAAM,0BAA0B;;iBAAsC,CAAC;AAE9E,eAAO,MAAM,kBAAkB,IAAc,CAAC;AAE9C,eAAO,MAAM,mBAAmB,gCAA+B,CAAC;AAahE;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,oBAAoB;;;;kBA0BtB,CAAC;AAEZ;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;iBAgChC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,eAAO,MAAM,gBAAgB;;IAO3B;;;;;;;;OAQG;;IAEH;;;;;OAKG;;IAQH;;;;;;;;;;OAUG;;;;IAaH;;;;;;;;;;;OAWG;;;;;CAuBK,CAAC;AAEX,eAAO,MAAM,iBAAiB;;;;;;;;;;;iBAA6B,CAAC;AAE5D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;iBAyBlC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB;;;;;EAKhC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;iBAS5B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,eAAO,MAAM,2BAA2B;;;;;EAKtC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;iBAalC,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAwE7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;4BAa5B,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,kBAAkB;;;;iBAW7B,CAAC;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,6BAA6B;;;;;kBAW/B,CAAC;AAEZ,eAAO,MAAM,8BAA8B;;;kBAKhC,CAAC"}
+{"version":3,"file":"mcp.d.ts","sourceRoot":"","sources":["../../src/schemas/mcp.ts"],"names":[],"mappings":"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"}