Skip to content

The Open Standard for Generative UI

7.5 KB
Raw Blame
import {
  createLibrary,
  defineComponent,
  FormNameContext,
  useIsStreaming,
  useStateField,
} from "@openuidev/react-lang";
import { act } from "react";
import { createRoot } from "react-dom/client";
import { renderToStaticMarkup } from "react-dom/server";
import { describe, expect, it, vi } from "vitest";
import { z } from "zod/v4";
import { createA2UIClient } from "../client";
import { A2UIRenderer } from "../Renderer";
import type { RendererToAgentMessage } from "../types";

const TextContent = defineComponent({
  name: "TextContent",
  description: "Text",
  props: z.object({ text: z.string() }),
  component: ({ props, statementId }) => <span data-statement={statementId}>{props.text}</span>,
});

const Stack = defineComponent({
  name: "Stack",
  description: "Stack",
  props: z.object({ children: z.array(TextContent.ref) }),
  component: ({ props, renderNode }) => <div>{renderNode(props.children)}</div>,
});

const library = createLibrary({ components: [Stack, TextContent], root: "Stack" });

const Field = defineComponent({
  name: "Field",
  description: "Interactive test field",
  props: z.object({ name: z.string() }),
  component: ({ props }) => {
    const field = useStateField<string>(props.name);
    const isStreaming = useIsStreaming();
    return (
      <button
        data-streaming={String(isStreaming)}
        disabled={isStreaming}
        onClick={() => field.setValue("[email protected]")}
      >
        {field.value ?? ""}
      </button>
    );
  },
});

const Form = defineComponent({
  name: "Form",
  description: "Test form",
  props: z.object({ name: z.string(), fields: z.array(Field.ref) }),
  component: ({ props, renderNode }) => (
    <FormNameContext.Provider value={props.name}>
      {renderNode(props.fields)}
    </FormNameContext.Provider>
  ),
});

const formLibrary = createLibrary({ components: [Form, Field], root: "Form" });

describe("A2UIRenderer", () => {
  it("renders the active A2UI surface through the OpenUI Lang React renderer", async () => {
    const client = createA2UIClient({
      schema: library.toJSONSchema(),
      rootName: library.root,
    });
    await client.process({
      version: "v1.0",
      createSurface: { surfaceId: "main", catalogId: "com.example:test" },
    });
    await client.process({
      version: "v1.0",
      updateComponents: {
        surfaceId: "main",
        components: ["root = Stack([greeting])", 'greeting = TextContent("Hello A2UI")'],
      },
    });

    const html = renderToStaticMarkup(
      <A2UIRenderer client={client} surfaceId="main" library={library} />,
    );
    expect(html).toContain("Hello A2UI");
    expect(html).toContain('data-statement="greeting"');
  });

  it("renders nothing after the surface is deleted", async () => {
    const client = createA2UIClient({ schema: library.toJSONSchema() });
    await client.process({
      version: "v1.0",
      createSurface: { surfaceId: "main", catalogId: "com.example:test" },
    });
    await client.process({
      version: "v1.0",
      deleteSurface: { surfaceId: "main" },
    });

    expect(
      renderToStaticMarkup(<A2UIRenderer client={client} surfaceId="main" library={library} />),
    ).toBe("");
  });

  it("keeps live form input and the A2UI data model converged", async () => {
    const client = createA2UIClient({
      schema: formLibrary.toJSONSchema(),
      rootName: formLibrary.root,
    });
    await client.process({
      version: "v1.0",
      createSurface: {
        surfaceId: "main",
        dataModel: { contact: { email: "[email protected]" } },
        components: ['root = Form("contact", [email])', 'email = Field("email")'],
      },
    });

    const container = document.createElement("div");
    document.body.append(container);
    const root = createRoot(container);
    const onStateUpdate = vi.fn();
    const revisionBeforeInput = client.getSurface("main")!.revision;

    await act(async () => {
      root.render(
        <A2UIRenderer
          client={client}
          surfaceId="main"
          library={formLibrary}
          onStateUpdate={onStateUpdate}
        />,
      );
    });
    const button = container.querySelector("button")!;
    expect(button.textContent).toBe("[email protected]");

    await act(async () => {
      button.dispatchEvent(new MouseEvent("click", { bubbles: true }));
    });
    expect(button.textContent).toBe("[email protected]");
    expect(client.getSurface("main")?.dataModel).toEqual({
      contact: { email: "[email protected]" },
    });
    expect(client.getSurface("main")?.revision).toBe(revisionBeforeInput + 1);
    expect(onStateUpdate).toHaveBeenCalledTimes(1);

    await act(async () => {
      await Promise.resolve();
    });
    expect(client.getSurface("main")?.dataModel).toEqual({
      contact: { email: "[email protected]" },
    });

    await act(async () => {
      await client.process({
        version: "v1.0",
        updateDataModel: {
          surfaceId: "main",
          path: "/contact/email",
          value: "[email protected]",
        },
      });
    });
    expect(button.textContent).toBe("[email protected]");
    expect(client.getSurface("main")?.dataModel).toEqual({
      contact: { email: "[email protected]" },
    });

    await act(async () => root.unmount());
    container.remove();
  });

  it("forwards the A2UI transport streaming state", async () => {
    const client = createA2UIClient({
      schema: formLibrary.toJSONSchema(),
      rootName: formLibrary.root,
    });
    await client.process({
      version: "v1.0",
      createSurface: {
        surfaceId: "main",
        components: ['root = Form("contact", [email])', 'email = Field("email")'],
      },
    });
    const container = document.createElement("div");
    const root = createRoot(container);

    await act(async () => {
      root.render(
        <A2UIRenderer client={client} surfaceId="main" library={formLibrary} isStreaming />,
      );
    });
    expect(container.querySelector("button")?.disabled).toBe(true);
    expect(container.querySelector("button")?.dataset.streaming).toBe("true");

    await act(async () => root.unmount());
  });

  it("routes OpenUI Query calls through A2UI callAgentFunction by default", async () => {
    const messages: RendererToAgentMessage[] = [];
    const client = createA2UIClient({
      schema: library.toJSONSchema(),
      rootName: library.root,
      createId: () => "query-call-1",
      onMessage: (message) => messages.push(message),
    });
    await client.process({
      version: "v1.0",
      createSurface: {
        surfaceId: "main",
        components: [
          'data = Query("lookup", {id: 42}, {text: "Loading"})',
          "root = Stack([greeting])",
          "greeting = TextContent(data.text)",
        ],
      },
    });
    const container = document.createElement("div");
    const root = createRoot(container);

    await act(async () => {
      root.render(<A2UIRenderer client={client} surfaceId="main" library={library} />);
      await new Promise((resolve) => setTimeout(resolve, 0));
    });
    expect(messages.at(-1)).toEqual({
      version: "v1.0",
      callAgentFunction: {
        surfaceId: "main",
        functionCallId: "query-call-1",
        callFunction: { call: "lookup", args: { id: 42 } },
      },
    });

    await act(async () => {
      await client.process({
        version: "v1.0",
        agentFunctionResponse: {
          functionCallId: "query-call-1",
          value: { text: "Loaded from agent" },
        },
      });
      await new Promise((resolve) => setTimeout(resolve, 0));
    });
    expect(container.textContent).toContain("Loaded from agent");

    await act(async () => root.unmount());
  });
});