@ggui-ai/iframe-runtime 0.5.0-rc.1 → 0.6.0

package/dist/index.d.ts

@@ -37,7 +37,7 @@ export { parseMetaFromGlobal, parseMetaFromToolResult, validateMeta, } from './m
 export type { RendererBootFailureReason, RendererBootFailedMessage, } from './runtime.js';
 export type { ProtocolError, ProtocolErrorEmitter, BootstrapFailureReason, } from './protocol-error.js';
 export { defaultProtocolErrorEmitter, fromBootstrapFailure, fromClientContractViolation, fromTransportFailure, fromAuthFailure, fromUpgradeRequired, fromUnknown, } from './protocol-error.js';
-export type { ObservabilityEvent, ObservabilityEmitter, ObservabilityMessage, SchemaVersionMismatchEvent, SubscribeFailedEvent, AuthRequiredEvent, ChannelTransportPickedEvent, ChannelTransportFallbackEvent, ChannelTransportResubscribedEvent, UnknownObservabilityEvent, } from './observability.js';
+export type { ObservabilityEvent, ObservabilityEmitter, ObservabilityMessage, SchemaVersionMismatchEvent, SubscribeFailedEvent, AuthRequiredEvent, ChannelTransportPickedEvent, ChannelTransportFallbackEvent, ChannelTransportResubscribedEvent, UiFeedbackEvent, UnknownObservabilityEvent, } from './observability.js';
 export { postObservabilityToParent } from './observability.js';
 export type { LifecycleEmitter } from './lifecycle.js';
 export { postLifecycleToParent, makeLifecycleEvent } from './lifecycle.js';

package/dist/observability.d.ts

@@ -33,7 +33,7 @@ import { MCP_APP_OBSERVE_TYPE } from '@ggui-ai/protocol/integrations/mcp-apps';
  *
  * @public
  */
-export type ObservabilityEvent = SchemaVersionMismatchEvent | SubscribeFailedEvent | AuthRequiredEvent | ChannelTransportPickedEvent | ChannelTransportFallbackEvent | ChannelTransportResubscribedEvent | UnknownObservabilityEvent;
+export type ObservabilityEvent = SchemaVersionMismatchEvent | SubscribeFailedEvent | AuthRequiredEvent | ChannelTransportPickedEvent | ChannelTransportFallbackEvent | ChannelTransportResubscribedEvent | UiFeedbackEvent | UnknownObservabilityEvent;
 /**
  * Fired when the protocol-version handshake rejects the connection.
  * Parallel to `UpgradeRequiredError` — the host can choose to render
@@ -152,6 +152,44 @@ export interface ChannelTransportResubscribedEvent {
     readonly sessionId: string;
     readonly channelName: string;
 }
+/**
+ * Fired when the end user submits the runtime's in-iframe UI-feedback
+ * affordance ("did this generated UI work for you?"). Field semantics
+ * mirror `UiFeedbackPayload` in `@ggui-ai/react` / `@ggui-ai/react-native`
+ * (the host-chrome twin of this affordance):
+ *
+ *   - `verdict` — `'love'` / `'dislike'`, or `'other'` for the
+ *     free-text flow.
+ *   - `comment` — present only for `verdict: 'other'` with a non-empty
+ *     trimmed comment.
+ *   - `sessionId` / `toolName` — present exactly when the runtime knew
+ *     them at mount time.
+ *
+ * Observability-only — feedback is host-app chrome with ZERO wire
+ * surface: the agent cannot observe it (it is neither an action nor
+ * context), so it rides this renderer ↔ host seam instead of the
+ * agent ↔ UI contract.
+ *
+ * The affordance mounts only when the runtime document has a parent
+ * window (`window.parent !== window`) — a top-level tab has no
+ * `ggui:observe` egress, and a dead affordance must never render.
+ * Hosts that also own DOM chrome around the iframe MUST wire exactly
+ * ONE feedback surface: either their own chrome (the `onUiFeedback`
+ * host-callback component) or this event arm — never both, or the
+ * user sees two affordances for one render.
+ *
+ * @public
+ */
+export interface UiFeedbackEvent {
+    readonly kind: 'ui-feedback';
+    readonly verdict: 'love' | 'dislike' | 'other';
+    /** Trimmed free-text comment; only on `verdict: 'other'`, never empty. */
+    readonly comment?: string;
+    /** GguiSession id of the render the feedback is about. */
+    readonly sessionId?: string;
+    /** Tool that produced the render (e.g. `ggui_render`). */
+    readonly toolName?: string;
+}
 /**
  * Catch-all branch for event kinds the host's typings don't recognize.
  * Lets the union stay extensible without forcing protocol-version

package/dist/provisional-renderer.js

@@ -48,6 +48,12 @@ const PREVIEW_CHANNEL = '_ggui:preview';
 import { parseServerMessage, } from '@ggui-ai/preview-a2ui';
 import { Button, Card, Checkbox, Divider, Heading, Icon, Image, Input, Row, Select, Spinner, Stack, Text, } from '@ggui-ai/design/primitives';
 import { PreviewFragmentEnter, PreviewSurface, StreamingText, } from '@ggui-ai/design/preview';
+// A2UI Text carries INLINE markdown (the block level comes from
+// `variant`) — rendered through the shared @silverprotocol/richtext
+// subset via the design system's inline renderer. Streaming-safe:
+// prefixes parse to stable ASTs, so re-emitting a longer `text`
+// only extends the trailing construct.
+import { MarkdownInline } from '@ggui-ai/design';
 const A2UI_ROOT_ID = 'root';
 const EMPTY_STATE = {
     surfaceId: null,
@@ -152,7 +158,7 @@ function renderComponent(component, all) {
             const headingMatch = /^h([1-6])$/.exec(variant);
             if (headingMatch) {
                 const level = Number(headingMatch[1]);
-                return wrap(createElement(Heading, { level }, createElement(StreamingText, null, component.text)));
+                return wrap(createElement(Heading, { level }, createElement(StreamingText, null, createElement(MarkdownInline, { text: component.text }))));
             }
             // A2UI 'caption' / 'label' map onto Text's size/weight/tone
             // axes; anything else degrades to default body text.
@@ -161,7 +167,7 @@ function renderComponent(component, all) {
                 : variant === 'label'
                     ? { size: 'sm', weight: 'medium' }
                     : {};
-            return wrap(createElement(Text, textProps, createElement(StreamingText, null, component.text)));
+            return wrap(createElement(Text, textProps, createElement(StreamingText, null, createElement(MarkdownInline, { text: component.text }))));
         }
         case 'Image':
             return wrap(createElement(Image, { src: component.src, alt: component.alt ?? '' }));

package/dist/runtime.js

@@ -15,6 +15,7 @@ import { loadCompiledValidatorsFromUrl } from './compiled-validators.js';
 import { mountRender, } from './render-item.js';
 import { fromBootstrapFailure, } from './protocol-error.js';
 import { postObservabilityToParent, } from './observability.js';
+import { mountUiFeedbackChrome } from './ui-feedback-chrome.js';
 import { makeLifecycleEvent, postLifecycleToParent, } from './lifecycle.js';
 import { contextSlotLastValues, createContextStateHost, installContextRegistry, reemitLastContextValues, } from './context-observer.js';
 const RENDERER_VERSION = typeof __GGUI_RUNTIME_VERSION__ === 'string' ? __GGUI_RUNTIME_VERSION__ : 'dev';
@@ -367,6 +368,19 @@ export async function bootSequence(opts) {
             ...(onObserve !== undefined ? { onObserve } : {}),
         })
         : null;
+    // In-iframe UI-feedback affordance (ggui#244) — mounted adjacent to
+    // the session root, gated inside the helper on `window.parent !==
+    // window` (top-level `/r/<shortCode>` tabs have no `ggui:observe`
+    // egress, so they get NO affordance). Interaction emits a
+    // `ui-feedback` ObservabilityEvent through the boot path's emitter;
+    // when no emitter was injected the postMessage-to-parent default
+    // still gives the mounted affordance a live sink (the gate already
+    // proved a parent exists). Fire-and-forget: chrome never blocks or
+    // fails the boot.
+    void mountUiFeedbackChrome(doc, {
+        emit: onObserve ?? postObservabilityToParent,
+        sessionId: meta.sessionId,
+    });
     setStatus(refs, `Connecting to ${meta.sessionId}…`, 'connecting');
     // Boot-without-renderer path: we still need a ChannelRegistry to
     // receive frames, because the registry is the only dispatch

package/dist/system-cards/UiFeedbackCard.d.ts

@@ -0,0 +1,46 @@
+/**
+ * UiFeedbackCard — the runtime's in-iframe UI-feedback affordance
+ * ("did this generated UI work for you?").
+ *
+ * The in-iframe twin of the host-chrome `UiFeedback` component in
+ * `@ggui-ai/react`: same three verdicts — Love / Dislike / Other
+ * (free-text comment) — same acknowledgement after submit, same
+ * dismiss control, same payload semantics (trimmed comment only on
+ * `verdict: 'other'`, context stamps present exactly when known).
+ * Where the host-chrome twin hands a payload to an `onUiFeedback`
+ * callback, this card builds a {@link UiFeedbackEvent} and hands it to
+ * the injected {@link ObservabilityEmitter} — production binds the
+ * `ggui:observe` postMessage-to-parent default, tests record.
+ *
+ * This is CHROME the runtime mounts adjacent to the session root
+ * (see `ui-feedback-chrome.ts`), NOT a system card: it has no
+ * `SystemGguiSession.kind`, no registry entry, and no server-side
+ * producer. It lives in this directory because it follows the
+ * system-card authoring idiom — inline styles with `--ggui-*`
+ * CSS-variable hooks and {@link useColorScheme} adaptation — and
+ * because the dynamic-import posture keeps it out of the runtime's
+ * base module graph.
+ *
+ * No ThemeProvider on purpose: the adjacent user render owns the
+ * document's `--ggui-*` variable layer (its own theme injection wrote
+ * `:root`), and wrapping this card in a ThemeProvider would overwrite
+ * those variables last-writer-wins. Inline `var(--ggui-*, fallback)`
+ * styles pick up the render's theme when present; the
+ * scheme-conditional fallbacks keep the card readable when no theme
+ * variables were injected at all.
+ */
+import * as React from 'react';
+import type { ObservabilityEmitter } from '../observability.js';
+export interface UiFeedbackCardProps {
+    /**
+     * Sink for the built {@link UiFeedbackEvent}. Required — the mount
+     * gate (`ui-feedback-chrome.ts`) guarantees a reachable parent
+     * before this card ever renders, so there is no unsunk state.
+     */
+    readonly emit: ObservabilityEmitter;
+    /** GguiSession id stamped onto every emitted event, when known. */
+    readonly sessionId?: string;
+    /** Producing tool name stamped onto every emitted event, when known. */
+    readonly toolName?: string;
+}
+export declare function UiFeedbackCard({ emit, sessionId, toolName, }: UiFeedbackCardProps): React.JSX.Element | null;

package/dist/system-cards/UiFeedbackCard.js

@@ -0,0 +1,133 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+/**
+ * UiFeedbackCard — the runtime's in-iframe UI-feedback affordance
+ * ("did this generated UI work for you?").
+ *
+ * The in-iframe twin of the host-chrome `UiFeedback` component in
+ * `@ggui-ai/react`: same three verdicts — Love / Dislike / Other
+ * (free-text comment) — same acknowledgement after submit, same
+ * dismiss control, same payload semantics (trimmed comment only on
+ * `verdict: 'other'`, context stamps present exactly when known).
+ * Where the host-chrome twin hands a payload to an `onUiFeedback`
+ * callback, this card builds a {@link UiFeedbackEvent} and hands it to
+ * the injected {@link ObservabilityEmitter} — production binds the
+ * `ggui:observe` postMessage-to-parent default, tests record.
+ *
+ * This is CHROME the runtime mounts adjacent to the session root
+ * (see `ui-feedback-chrome.ts`), NOT a system card: it has no
+ * `SystemGguiSession.kind`, no registry entry, and no server-side
+ * producer. It lives in this directory because it follows the
+ * system-card authoring idiom — inline styles with `--ggui-*`
+ * CSS-variable hooks and {@link useColorScheme} adaptation — and
+ * because the dynamic-import posture keeps it out of the runtime's
+ * base module graph.
+ *
+ * No ThemeProvider on purpose: the adjacent user render owns the
+ * document's `--ggui-*` variable layer (its own theme injection wrote
+ * `:root`), and wrapping this card in a ThemeProvider would overwrite
+ * those variables last-writer-wins. Inline `var(--ggui-*, fallback)`
+ * styles pick up the render's theme when present; the
+ * scheme-conditional fallbacks keep the card readable when no theme
+ * variables were injected at all.
+ */
+import * as React from 'react';
+import { useColorScheme } from './host-detect.js';
+const FONT_FAMILY = "var(--ggui-font-family-sans, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif)";
+/**
+ * Scheme-conditional style palette. The `var(--ggui-*, …)` fallbacks
+ * flip between the neutral light values (mirroring the host-chrome
+ * twin) and dark-readable equivalents so the card stays legible on
+ * hosts that render the iframe over a dark surface without injecting
+ * theme variables.
+ */
+function buildStyles(scheme) {
+    const dark = scheme === 'dark';
+    return {
+        root: {
+            display: 'inline-flex',
+            alignItems: 'center',
+            gap: 4,
+            fontFamily: FONT_FAMILY,
+            fontSize: 12,
+            lineHeight: 1.2,
+            color: dark
+                ? 'var(--ggui-color-neutral-500, #9ca3af)'
+                : 'var(--ggui-color-neutral-500, #6b7280)',
+        },
+        verdictButton: {
+            appearance: 'none',
+            background: dark
+                ? 'var(--ggui-color-neutral-50, #1f2937)'
+                : 'var(--ggui-color-neutral-50, #f9fafb)',
+            border: dark
+                ? '1px solid var(--ggui-color-neutral-200, #374151)'
+                : '1px solid var(--ggui-color-neutral-200, #e5e7eb)',
+            borderRadius: 'var(--ggui-shape-radius-sm, 4px)',
+            padding: '2px 8px',
+            fontFamily: 'inherit',
+            fontSize: 'inherit',
+            color: dark
+                ? 'var(--ggui-color-neutral-600, #d1d5db)'
+                : 'var(--ggui-color-neutral-600, #4b5563)',
+            cursor: 'pointer',
+        },
+        dismissButton: {
+            appearance: 'none',
+            background: 'transparent',
+            border: 'none',
+            padding: '2px 4px',
+            fontFamily: 'inherit',
+            fontSize: 'inherit',
+            color: dark
+                ? 'var(--ggui-color-neutral-400, #6b7280)'
+                : 'var(--ggui-color-neutral-400, #9ca3af)',
+            cursor: 'pointer',
+        },
+        commentForm: {
+            display: 'inline-flex',
+            alignItems: 'center',
+            gap: 4,
+            margin: 0,
+        },
+        commentInput: {
+            fontFamily: 'inherit',
+            fontSize: 'inherit',
+            padding: '2px 6px',
+            minWidth: 140,
+            border: dark
+                ? '1px solid var(--ggui-color-neutral-200, #374151)'
+                : '1px solid var(--ggui-color-neutral-200, #e5e7eb)',
+            borderRadius: 'var(--ggui-shape-radius-sm, 4px)',
+            background: dark
+                ? 'var(--ggui-color-neutral-50, #111827)'
+                : 'var(--ggui-color-neutral-50, #ffffff)',
+            color: dark
+                ? 'var(--ggui-color-neutral-800, #e5e7eb)'
+                : 'var(--ggui-color-neutral-800, #1f2937)',
+        },
+    };
+}
+export function UiFeedbackCard({ emit, sessionId, toolName, }) {
+    const [phase, setPhase] = React.useState('idle');
+    const [comment, setComment] = React.useState('');
+    const scheme = useColorScheme();
+    const styles = buildStyles(scheme);
+    const send = React.useCallback((verdict, commentText) => {
+        const trimmed = commentText?.trim();
+        emit({
+            kind: 'ui-feedback',
+            verdict,
+            ...(trimmed !== undefined && trimmed.length > 0 ? { comment: trimmed } : {}),
+            ...(sessionId !== undefined ? { sessionId } : {}),
+            ...(toolName !== undefined ? { toolName } : {}),
+        });
+        setPhase('sent');
+    }, [emit, sessionId, toolName]);
+    const onCommentSubmit = React.useCallback((e) => {
+        e.preventDefault();
+        send('other', comment);
+    }, [send, comment]);
+    if (phase === 'dismissed')
+        return null;
+    return (_jsxs("div", { "data-ggui-ui-feedback": true, role: "group", "aria-label": "Share feedback on this UI", style: styles.root, children: [phase === 'sent' ? (_jsx("span", { "data-ggui-ui-feedback-thanks": true, children: "Thanks for the feedback" })) : phase === 'comment' ? (_jsxs("form", { onSubmit: onCommentSubmit, style: styles.commentForm, "data-ggui-ui-feedback-comment-form": true, children: [_jsx("input", { type: "text", value: comment, onChange: (e) => setComment(e.target.value), placeholder: "What happened?", "aria-label": "Feedback comment", "data-ggui-ui-feedback-comment": true, style: styles.commentInput, autoFocus: true }), _jsx("button", { type: "submit", style: styles.verdictButton, "data-ggui-ui-feedback-send": true, children: "Send" })] })) : (_jsxs(_Fragment, { children: [_jsx("button", { type: "button", style: styles.verdictButton, "data-ggui-ui-feedback-verdict": "love", onClick: () => send('love'), children: "Love" }), _jsx("button", { type: "button", style: styles.verdictButton, "data-ggui-ui-feedback-verdict": "dislike", onClick: () => send('dislike'), children: "Dislike" }), _jsx("button", { type: "button", style: styles.verdictButton, "data-ggui-ui-feedback-verdict": "other", onClick: () => setPhase('comment'), children: "Other\u2026" })] })), _jsx("button", { type: "button", style: styles.dismissButton, "aria-label": "Dismiss feedback", "data-ggui-ui-feedback-dismiss": true, onClick: () => setPhase('dismissed'), children: '×' })] }));
+}

package/dist/ui-feedback-chrome.d.ts

@@ -0,0 +1,40 @@
+import type { ObservabilityEmitter } from './observability.js';
+export interface UiFeedbackChromeOptions {
+    /**
+     * Observability sink the card emits `ui-feedback` events into.
+     * Production passes the boot path's emitter (default
+     * `postObservabilityToParent`); tests inject a recorder.
+     */
+    readonly emit: ObservabilityEmitter;
+    /** GguiSession id stamped onto every emitted event, when known. */
+    readonly sessionId?: string;
+    /** Producing tool name stamped onto every emitted event, when known. */
+    readonly toolName?: string;
+    /**
+     * Window whose `parent` is consulted for the sink-reachability
+     * gate. Defaults to the global `window`; tests inject fakes so the
+     * gate is exercisable without mutating jsdom's window graph.
+     */
+    readonly win?: Window;
+}
+export interface UiFeedbackChromeHandle {
+    /** The appended `[data-ggui-ui-feedback-chrome]` container. */
+    readonly container: HTMLElement;
+    /** Tear down the React root + remove the container. */
+    unmount(): void;
+}
+/**
+ * Mount the in-iframe UI-feedback affordance, or do nothing.
+ *
+ * Returns `null` without touching the DOM when the gate fails (no
+ * parent window — top-level tab / non-browser environment). Otherwise
+ * appends a `<div data-ggui-ui-feedback-chrome>` to `doc.body` (after
+ * the session root, which the boot path appended first) and renders
+ * the card into it. Idempotent per document: a re-entrant mount
+ * replaces any previous chrome container — one affordance per
+ * document, never two.
+ *
+ * Fire-and-forget from the boot path's perspective: chrome must never
+ * block or fail the boot, so callers `void` the promise.
+ */
+export declare function mountUiFeedbackChrome(doc: Document, opts: UiFeedbackChromeOptions): Promise<UiFeedbackChromeHandle | null>;

package/dist/ui-feedback-chrome.js

@@ -0,0 +1,83 @@
+/**
+ * In-iframe UI-feedback chrome mount (ggui#244).
+ *
+ * Mounts {@link import('./system-cards/UiFeedbackCard.js').UiFeedbackCard}
+ * in its own container ADJACENT to the session root (appended to
+ * `document.body`, so it sits below the rendered UI) — the same
+ * append-my-own-root posture as `status-dom.ts#ensureStatusDom`.
+ * Interaction egress is the existing `ggui:observe` renderer → host
+ * postMessage envelope: the card builds a `ui-feedback`
+ * {@link import('./observability.js').ObservabilityEvent} arm and hands
+ * it to the injected emitter (production binds
+ * `postObservabilityToParent`).
+ *
+ * Sink-reachability gate — never render a dead affordance:
+ *
+ *   - `window.parent !== window` → a parent window exists, the
+ *     `ggui:observe` envelope has somewhere to go → mount. Parents
+ *     that don't understand the envelope ignore it (best-effort emit;
+ *     one postMessage of cost).
+ *   - `window.parent === window` → top-level tab (the `/r/<shortCode>`
+ *     share-link viewer) → NO mount. There is no parent to receive
+ *     the envelope, so a rendered affordance would drop every click
+ *     on the floor.
+ *
+ * Hosts that own DOM chrome around the iframe wire exactly ONE
+ * feedback surface: either their own chrome (`onUiFeedback` on the
+ * host-side SDK components) or this in-iframe affordance's
+ * `ui-feedback` arm via `onObserve` — never both.
+ *
+ * The card + react-dom are dynamic-imported so this module stays
+ * feather-weight in the runtime's base graph (mirrors the system-card
+ * branch in `render-item.ts`); the import cost is only paid when the
+ * gate passes.
+ */
+import { createElement } from 'react';
+/**
+ * Mount the in-iframe UI-feedback affordance, or do nothing.
+ *
+ * Returns `null` without touching the DOM when the gate fails (no
+ * parent window — top-level tab / non-browser environment). Otherwise
+ * appends a `<div data-ggui-ui-feedback-chrome>` to `doc.body` (after
+ * the session root, which the boot path appended first) and renders
+ * the card into it. Idempotent per document: a re-entrant mount
+ * replaces any previous chrome container — one affordance per
+ * document, never two.
+ *
+ * Fire-and-forget from the boot path's perspective: chrome must never
+ * block or fail the boot, so callers `void` the promise.
+ */
+export async function mountUiFeedbackChrome(doc, opts) {
+    const win = opts.win ?? (typeof window !== 'undefined' ? window : undefined);
+    // Gate: mount only when a parent window exists to receive the
+    // `ggui:observe` envelope. `win.parent === win` is the top-level-tab
+    // signature; a nullish parent means a detached/nonstandard context.
+    if (win === undefined || win.parent === null || win.parent === win) {
+        return null;
+    }
+    const [reactDomClient, cardMod] = await Promise.all([
+        import('react-dom/client'),
+        import('./system-cards/UiFeedbackCard.js'),
+    ]);
+    // Idempotency: a re-entrant mount replaces the previous chrome
+    // container wholesale (remove + fresh element) rather than calling
+    // `createRoot` twice on one node — React warns on double-rooting a
+    // container, and chrome carries no state worth preserving.
+    doc.querySelector('[data-ggui-ui-feedback-chrome]')?.remove();
+    const container = doc.createElement('div');
+    container.setAttribute('data-ggui-ui-feedback-chrome', '');
+    doc.body.appendChild(container);
+    const root = reactDomClient.createRoot(container);
+    root.render(createElement(cardMod.UiFeedbackCard, {
+        emit: opts.emit,
+        ...(opts.sessionId !== undefined ? { sessionId: opts.sessionId } : {}),
+        ...(opts.toolName !== undefined ? { toolName: opts.toolName } : {}),
+    }));
+    return {
+        container,
+        unmount() {
+            root.unmount();
+            container.remove();
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ggui-ai/iframe-runtime",
-  "version": "0.5.0-rc.1",
+  "version": "0.6.0",
   "description": "The iframe-local ggui runtime: a self-contained ESM bundle that boots inside an MCP Apps host iframe, runs the protocol-version handshake, opens the live-channel WebSocket, and mounts the rendered UI. Bundles React, ReactDOM, and the ggui design system so generated component code has a single seam to read from.",
   "keywords": [
     "ggui",
@@ -35,12 +35,12 @@
     "qrcode-generator": "^2.0.4",
     "react": "^19.0.0",
     "react-dom": "^19.0.0",
-    "@ggui-ai/live-channel": "0.5.0-rc.1",
-    "@ggui-ai/design": "0.5.0-rc.1",
-    "@ggui-ai/gadgets": "0.5.0-rc.1",
-    "@ggui-ai/preview-a2ui": "0.5.0-rc.1",
-    "@ggui-ai/protocol": "0.5.0-rc.1",
-    "@ggui-ai/wire": "0.5.0-rc.1"
+    "@ggui-ai/live-channel": "0.6.0",
+    "@ggui-ai/preview-a2ui": "0.6.0",
+    "@ggui-ai/gadgets": "0.6.0",
+    "@ggui-ai/protocol": "0.6.0",
+    "@ggui-ai/design": "0.6.0",
+    "@ggui-ai/wire": "0.6.0"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": "^1.27.0"