@assistant-ui/react-generative-ui 0.0.24 → 0.1.0

package/src/answeredValues.test.ts

@@ -1,33 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { findAnsweredValues } from "./answeredValues";
-
-describe("findAnsweredValues", () => {
-  it("returns the latest action's object input", () => {
-    expect(
-      findAnsweredValues({
-        entries: [
-          {
-            type: "action",
-            payload: { $input: { choice: "first" } },
-          },
-          { type: "human-response", payload: { choice: "ignored" } },
-          {
-            type: "action",
-            payload: { $input: { choice: "last" } },
-          },
-        ],
-      }),
-    ).toEqual({ choice: "last" });
-  });
-
-  it("ignores actions whose input is not a plain object", () => {
-    expect(
-      findAnsweredValues({
-        entries: [
-          { type: "action", payload: { $input: { choice: "kept" } } },
-          { type: "action", payload: { $input: ["not", "an", "object"] } },
-        ],
-      }),
-    ).toEqual({ choice: "kept" });
-  });
-});

package/src/answeredValues.tsx

@@ -1,70 +0,0 @@
-import * as React from "react";
-
-type AnsweredValues = Readonly<Record<string, unknown>>;
-
-type ToolInteractionLog = {
-  readonly entries: readonly {
-    readonly type: string;
-    readonly payload: unknown;
-  }[];
-};
-
-let answeredValuesContext:
-  | React.Context<AnsweredValues | undefined>
-  | undefined;
-const supportsContext = typeof React.createContext === "function";
-const useValuesContext = supportsContext ? React.useContext : () => undefined;
-
-const getAnsweredValuesContext = () =>
-  supportsContext
-    ? (answeredValuesContext ??= React.createContext<
-        AnsweredValues | undefined
-      >(undefined))
-    : undefined;
-
-const isPlainObject = (value: unknown): value is AnsweredValues => {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    return false;
-  }
-  const prototype = Object.getPrototypeOf(value);
-  return prototype === Object.prototype || prototype === null;
-};
-
-export const findAnsweredValues = (
-  interactions: ToolInteractionLog | undefined,
-): AnsweredValues | undefined => {
-  const entries = interactions?.entries;
-  if (!entries) return undefined;
-
-  for (let index = entries.length - 1; index >= 0; index--) {
-    const interaction = entries[index]!;
-    if (interaction.type !== "action" || !isPlainObject(interaction.payload)) {
-      continue;
-    }
-    const input = interaction.payload["$input"];
-    if (isPlainObject(input)) return input;
-  }
-  return undefined;
-};
-
-export const AnsweredValuesProvider = ({
-  values,
-  children,
-}: {
-  values: AnsweredValues | undefined;
-  children: React.ReactNode;
-}) => {
-  const Context = getAnsweredValuesContext();
-  return Context ? (
-    <Context.Provider value={values}>{children}</Context.Provider>
-  ) : (
-    children
-  );
-};
-
-export const useAnsweredValue = (name: string | undefined): unknown => {
-  const values = useValuesContext(getAnsweredValuesContext()!);
-  return name !== undefined && values && Object.hasOwn(values, name)
-    ? values[name]
-    : undefined;
-};

package/src/buildPresentParameters.test.ts

@@ -1,246 +0,0 @@
-import type { JSONSchema7, JSONSchema7Definition } from "json-schema";
-import { describe, expect, it, vi } from "vitest";
-import { z } from "zod";
-import { buildPresentParameters } from "./buildPresentParameters";
-
-const component = (properties: z.ZodType) => ({
-  description: "A component",
-  properties,
-  render: () => null,
-});
-
-function resolve(root: JSONSchema7, value: JSONSchema7Definition) {
-  let schema = value as JSONSchema7;
-  if (schema.$ref === "#") return root;
-  if (schema.$ref) {
-    expect(schema.$ref).toMatch(/^#\//);
-    let target: unknown = root;
-    for (const segment of schema.$ref.slice(2).split("/")) {
-      const key = decodeURIComponent(segment)
-        .replace(/~1/g, "/")
-        .replace(/~0/g, "~");
-      target = (target as Record<string, unknown> | undefined)?.[key];
-    }
-    expect(target).toBeDefined();
-    schema = target as JSONSchema7;
-  }
-  return schema;
-}
-
-describe("component schema references", () => {
-  it("retains recursive definitions used by a component prop", () => {
-    const Tree = z.object({
-      label: z.string(),
-      get descendants() {
-        return z.array(Tree);
-      },
-    });
-    const schema = buildPresentParameters({
-      Tree: component(z.object({ tree: Tree })),
-    });
-    const tree = resolve(schema, schema.properties!.tree!);
-    expect(tree.properties!.label).toEqual({ type: "string" });
-    const descendants = tree.properties!.descendants as JSONSchema7;
-    expect(resolve(schema, descendants.items as JSONSchema7Definition)).toBe(
-      tree,
-    );
-  });
-
-  it("keeps definitions with the same generated name isolated across components", () => {
-    const TextTree = z.object({
-      value: z.string(),
-      get descendants() {
-        return z.array(TextTree);
-      },
-    });
-    const NumberTree = z.object({
-      value: z.number(),
-      get descendants() {
-        return z.array(NumberTree);
-      },
-    });
-    const schema = buildPresentParameters({
-      node: component(z.object({ textTree: TextTree })),
-      children: component(z.object({ numberTree: NumberTree })),
-    });
-    const textTree = resolve(schema, schema.properties!.textTree!);
-    const numberTree = resolve(schema, schema.properties!.numberTree!);
-    expect(textTree.properties!.value).toEqual({ type: "string" });
-    expect(numberTree.properties!.value).toEqual({ type: "number" });
-    expect(
-      resolve(
-        schema,
-        (textTree.properties!.descendants as JSONSchema7)
-          .items as JSONSchema7Definition,
-      ),
-    ).toBe(textTree);
-    expect(
-      resolve(
-        schema,
-        (numberTree.properties!.descendants as JSONSchema7)
-          .items as JSONSchema7Definition,
-      ),
-    ).toBe(numberTree);
-    expect(resolve(schema, schema.properties!.children!).anyOf).toBeDefined();
-    expect((schema.$defs!.node as JSONSchema7).properties!.$type).toBeDefined();
-  });
-
-  it("rebases root references to component props instead of the generated UI node", () => {
-    const Props = z.object({
-      label: z.string(),
-      get nested() {
-        return z.array(Props);
-      },
-    });
-    const schema = buildPresentParameters({ Recursive: component(Props) });
-    const nested = schema.properties!.nested as JSONSchema7;
-    const props = resolve(schema, nested.items as JSONSchema7Definition);
-    expect(props.properties!.label).toEqual({ type: "string" });
-    expect(props.properties!.$type).toBeUndefined();
-    expect(props.required).toEqual(["label", "nested"]);
-  });
-
-  it("rebases recursive references inside unions and records", () => {
-    const Tree = z.object({
-      get branches() {
-        return z.record(z.string(), z.union([z.string(), Tree]));
-      },
-    });
-    const schema = buildPresentParameters({
-      Tree: component(z.object({ tree: Tree })),
-    });
-    const tree = resolve(schema, schema.properties!.tree!);
-    const branches = tree.properties!.branches as JSONSchema7;
-    const variants = (branches.additionalProperties as JSONSchema7).anyOf!;
-    expect(resolve(schema, variants[1]!)).toBe(tree);
-  });
-
-  it("retains recursive definitions referenced from tuple items", () => {
-    const Tree = z.object({
-      label: z.string(),
-      get descendants() {
-        return z.array(Tree);
-      },
-    });
-    const schema = buildPresentParameters({
-      Pair: component(z.object({ pair: z.tuple([Tree, z.string()]) })),
-    });
-    const pair = schema.properties!.pair as JSONSchema7 & {
-      prefixItems?: JSONSchema7Definition[];
-    };
-    const first = (pair.prefixItems ??
-      (pair.items as JSONSchema7Definition[]))[0]!;
-    const tree = resolve(schema, first);
-    expect(tree.properties!.label).toEqual({ type: "string" });
-    expect(
-      resolve(
-        schema,
-        (tree.properties!.descendants as JSONSchema7)
-          .items as JSONSchema7Definition,
-      ),
-    ).toBe(tree);
-  });
-
-  it("rebases prefixItems in draft 2020-12 converter output", () => {
-    const raw = {
-      $schema: "https://json-schema.org/draft/2020-12/schema",
-      $id: "https://example.com/pair",
-      type: "object",
-      properties: {
-        pair: {
-          type: "array",
-          prefixItems: [{ $ref: "#/$defs/item" }, { type: "string" }],
-        },
-      },
-      $defs: {
-        item: {
-          type: "object",
-          properties: {
-            descendants: { type: "array", items: { $ref: "#/$defs/item" } },
-          },
-        },
-      },
-    };
-    const schema = buildPresentParameters({
-      Pair: component(raw as unknown as z.ZodType),
-    });
-    const pair = schema.properties!.pair as JSONSchema7 & {
-      prefixItems: JSONSchema7Definition[];
-    };
-    const item = resolve(schema, pair.prefixItems[0]!);
-    expect(item.properties!.descendants).toBeDefined();
-    expect(
-      resolve(
-        schema,
-        (item.properties!.descendants as JSONSchema7)
-          .items as JSONSchema7Definition,
-      ),
-    ).toBe(item);
-    const embedded = schema.$defs!.component0 as JSONSchema7;
-    expect(Object.keys(embedded)).not.toContain("$schema");
-    expect(Object.keys(embedded)).not.toContain("$id");
-  });
-
-  it("strips root resource metadata from embedded component schemas", () => {
-    const Tree = z.object({
-      get descendants() {
-        return z.array(Tree);
-      },
-    });
-    const schema = buildPresentParameters({
-      Tree: component(z.object({ tree: Tree })),
-    });
-    const embedded = schema.$defs!.component0 as JSONSchema7;
-    expect(Object.keys(embedded)).not.toContain("$schema");
-    expect(embedded.type).toBe("object");
-  });
-
-  it("omits component definitions whose properties all lose the duplicate-name merge", () => {
-    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
-    try {
-      const StringTree = z.object({
-        get tree() {
-          return z.array(StringTree);
-        },
-      });
-      const NumberTree = z.object({
-        value: z.number(),
-        get tree() {
-          return z.array(NumberTree);
-        },
-      });
-      const schema = buildPresentParameters({
-        first: component(z.object({ tree: StringTree })),
-        second: component(z.object({ tree: NumberTree })),
-      });
-      expect(Object.keys(schema.$defs!)).toEqual([
-        "node",
-        "children",
-        "component0",
-      ]);
-      expect(warn).toHaveBeenCalledOnce();
-    } finally {
-      warn.mockRestore();
-    }
-  });
-
-  it("leaves literal reference-shaped data and non-recursive schemas unchanged", () => {
-    const literal = {
-      $ref: "#/literal",
-      properties: { nested: { $ref: "#" } },
-    };
-    const schema = buildPresentParameters({
-      Card: component(
-        z.object({
-          label: z.string().meta({ examples: [literal], default: literal }),
-        }),
-      ),
-    });
-    expect(schema.properties!.label).toEqual({
-      type: "string",
-      examples: [literal],
-      default: literal,
-    });
-    expect(Object.keys(schema.$defs!)).toEqual(["node", "children"]);
-  });
-});

package/src/buildPresentParameters.ts

@@ -1,130 +0,0 @@
-import { toJSONSchema } from "assistant-stream";
-import type { JSONSchema7, JSONSchema7Definition } from "json-schema";
-import { TYPE_KEY } from "./constants";
-import type { GenerativeUILibrary } from "./types";
-import { scopeSchema } from "./scopeSchema";
-
-/**
- * Builds the JSON schema for the `present` tool from a {@link GenerativeUILibrary}.
- *
- * The model produces a node `{ $type, $key?, ...props }` where `$type` selects
- * a component, the optional `$key` pins a stable identity for list items that
- * may reorder, and the rest are its props. The schema is a flat object: `$type`
- * is an enum of the component names, every component's props are merged into
- * one optional bag, and `children` recurses via `$defs` so the tree can nest.
- *
- * It is intentionally flat rather than a per-`$type` discriminated union. Tool /
- * function-call schemas (OpenAI and others) require the top-level parameters to
- * be a plain object and reject a top-level `oneOf`/`anyOf`/`enum`. So props can't
- * be refined per `$type` at the root; the model is guided instead by `$type`'s
- * description (which lists each component) and each prop's own description. The
- * renderer validates nothing here — an unknown `$type` or stray prop is handled
- * at render time — so a looser schema only costs the model a hint, not safety.
- */
-export function buildPresentParameters(
-  library: GenerativeUILibrary,
-): JSONSchema7 {
-  const names = Object.keys(library);
-
-  // Merge every component's props into one optional bag. `$`-prefixed keys and
-  // `children` are framework-reserved (see ir.ts), so drop any author-declared
-  // copies. On a name clash the first component's schema wins — props are an
-  // advisory hint here, not a strict per-component contract.
-  const props = new Map<string, JSONSchema7Definition>();
-  const propOwners = new Map<string, string[]>();
-  const componentSchemas: Record<string, JSONSchema7> = {};
-  for (const [index, name] of names.entries()) {
-    const definition = `component${index}`;
-    const { schema: propsSchema, referenced } = scopeSchema(
-      toJSONSchema(library[name]!.properties),
-      `#/$defs/${definition}`,
-    );
-    if (propsSchema.type !== "object") {
-      throw new Error(
-        `[@assistant-ui/react-generative-ui] Component "${name}": ` +
-          "`properties` must be an object schema (e.g. `z.object({ ... })`).",
-      );
-    }
-    let merged = false;
-    for (const [key, schema] of Object.entries(propsSchema.properties ?? {})) {
-      if (key.startsWith("$") || key === "children") continue;
-      // secure-json-parse rejects the whole tool-argument payload on this key,
-      // so advertising it would cost the model the node rather than one prop.
-      if (key === "__proto__") continue;
-      if (!props.has(key)) {
-        props.set(key, schema);
-        merged = true;
-      }
-      propOwners.set(key, [...(propOwners.get(key) ?? []), name]);
-    }
-    if (referenced && merged) {
-      // `$schema` is only valid at a schema-resource root, and an embedded
-      // `$id` would both collide across components and re-base the pointers
-      // scopeSchema just rewrote to be document-root relative.
-      const { $schema: _, $id: _id, ...embedded } = propsSchema;
-      componentSchemas[definition] = embedded;
-    }
-  }
-
-  if (process.env["NODE_ENV"] !== "production") {
-    for (const [key, owners] of propOwners) {
-      if (owners.length < 2) continue;
-      // eslint-disable-next-line no-console
-      console.warn(
-        `[@assistant-ui/react-generative-ui] Prop "${key}" is declared by ` +
-          `${formatComponentList(owners)}; keeping "${owners[0]}"'s schema. ` +
-          "Rename or align the prop type to avoid an ambiguous schema.",
-      );
-    }
-  }
-
-  // Carry each component's description on the `$type` enum, since there are no
-  // per-branch schemas to hang them on anymore.
-  const typeDescription =
-    names.length > 0
-      ? `The component to render. ${names
-          .map((name) => `"${name}": ${library[name]!.description}`)
-          .join("; ")}`
-      : "The component to render.";
-
-  const node: JSONSchema7 = {
-    type: "object",
-    properties: {
-      [TYPE_KEY]: { type: "string", enum: names, description: typeDescription },
-      $key: {
-        description:
-          "Stable identity for this UI node. Use it for list items that may reorder.",
-        anyOf: [{ type: "string" }, { type: "number" }],
-      },
-      ...Object.fromEntries(props),
-      children: { $ref: "#/$defs/children" },
-    },
-    required: [TYPE_KEY],
-  };
-
-  const children: JSONSchema7 = {
-    description: "Nested generative UI rendered inside this component.",
-    anyOf: [
-      { type: "string" },
-      { $ref: "#/$defs/node" },
-      {
-        type: "array",
-        items: { anyOf: [{ type: "string" }, { $ref: "#/$defs/node" }] },
-      },
-    ],
-  };
-
-  return {
-    ...node,
-    $defs: { node, children, ...componentSchemas },
-  };
-}
-
-function formatComponentList(names: string[]) {
-  if (names.length <= 2) return names.map((name) => `"${name}"`).join(" and ");
-
-  return `${names
-    .slice(0, -1)
-    .map((name) => `"${name}"`)
-    .join(", ")}, and "${names[names.length - 1]}"`;
-}

package/src/constants.ts

@@ -1,17 +0,0 @@
-/**
- * The wire key naming the component to render.
- *
- * The model emits nodes as flat objects `{ [TYPE_KEY]: name, ...props }`. We
- * use `$type` rather than `type` so a component's own `type` prop (e.g. a
- * button's `type="submit"`) flows through as an ordinary prop without
- * colliding with the discriminator. It mirrors the `$type` discriminator
- * convention used by JSON polymorphism elsewhere.
- */
-export const TYPE_KEY = "$type";
-
-export const GENERATED_NAME_ATTR = "data-aui-generated-name";
-
-export const FIELD_NAME_ATTR = "data-aui-field-name";
-export const FIELD_VALUE_ATTR = "data-aui-field-value";
-
-export const CHECKBOX_GROUP_ATTR = "data-aui-checkbox-group";

package/src/convert/boundSpec.test.ts

@@ -1,192 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  CHILDREN_CAP,
-  MAX_ELEMENT_DEPTH,
-  NODE_BUDGET,
-  boundSpec,
-  clampReasonDetail,
-  type ClampReason,
-} from "./boundSpec";
-
-const walk = (spec: unknown) => {
-  const reasons: ClampReason[] = [];
-  const result = boundSpec(spec, (reason) => reasons.push(reason));
-  return { reasons, result };
-};
-
-const nest = (levels: number): unknown =>
-  levels === 0
-    ? { type: "Text" }
-    : { type: "Box", children: [nest(levels - 1)] };
-
-describe("boundSpec", () => {
-  it("copies an object without children and passes primitives through", () => {
-    const leaf = { type: "Text", props: { value: "hi" } };
-    const { reasons, result } = walk(leaf);
-
-    expect({ reasons, result }).toEqual({ reasons: [], result: leaf });
-    expect(result).not.toBe(leaf);
-    expect(walk("text").result).toBe("text");
-    expect(walk(null).result).toBe(null);
-  });
-
-  it("copies a node with children instead of mutating the caller's object", () => {
-    const spec = { type: "Box", children: [] };
-    const { result } = walk(spec);
-
-    expect(result).toEqual(spec);
-    expect(result).not.toBe(spec);
-  });
-
-  it("clamps any level wider than the children cap", () => {
-    const { reasons, result } = walk(Array(CHILDREN_CAP + 1).fill("x"));
-
-    expect(reasons).toEqual(["children"]);
-    expect(result as unknown[]).toHaveLength(CHILDREN_CAP);
-  });
-
-  it("bounds an array whose reported length is fabricated", () => {
-    const hostile = new Proxy(["a", "b"], {
-      get: (target, prop, receiver) =>
-        prop === "length"
-          ? Number.MAX_SAFE_INTEGER
-          : Reflect.get(target, prop, receiver),
-    });
-
-    const { reasons, result } = walk(hostile);
-
-    expect(reasons).toEqual(["children"]);
-    expect(result as unknown[]).toHaveLength(CHILDREN_CAP);
-  });
-
-  it("bounds an array that hijacks its own slice", () => {
-    const hostile = new Proxy(["a", "b"], {
-      get: (target, prop, receiver) =>
-        prop === "slice"
-          ? () => Array(CHILDREN_CAP * 2).fill("x")
-          : Reflect.get(target, prop, receiver),
-    });
-
-    expect(walk(hostile).result).toEqual(["a", "b"]);
-  });
-
-  it("bounds an array that redirects Symbol.species to a foreign object", () => {
-    function HostileCtor() {
-      return { map: () => Array(500).fill({ type: "Text" }), length: 0 };
-    }
-    const constructor = { [Symbol.species]: HostileCtor };
-    const hostile = new Proxy([{ type: "Text" }, { type: "Text" }], {
-      get: (target, prop, receiver) =>
-        prop === "constructor"
-          ? constructor
-          : Reflect.get(target, prop, receiver),
-    });
-
-    const { reasons, result } = walk(hostile);
-
-    expect(reasons).toEqual([]);
-    expect(result).toEqual([{ type: "Text" }, { type: "Text" }]);
-  });
-
-  it("bounds a record that hides its children behind a has trap", () => {
-    const hostileChildren = new Proxy([{ type: "Text" }], {
-      get: (target, prop, receiver) =>
-        prop === "length"
-          ? Number.MAX_SAFE_INTEGER
-          : Reflect.get(target, prop, receiver),
-    });
-    const hostile = new Proxy(
-      { type: "Box", children: hostileChildren } as Record<string, unknown>,
-      {
-        has: (target, prop) => prop !== "children" && Reflect.has(target, prop),
-      },
-    );
-
-    const { reasons, result } = walk(hostile);
-
-    expect(reasons).toEqual(["children"]);
-    expect((result as { children: unknown[] }).children).toHaveLength(
-      CHILDREN_CAP,
-    );
-  });
-
-  it("bounds a record that answers a later read of children differently", () => {
-    let reads = 0;
-    const hostile = new Proxy(
-      { type: "Box", children: undefined } as Record<string, unknown>,
-      {
-        get: (target, prop, receiver) => {
-          if (prop !== "children") return Reflect.get(target, prop, receiver);
-          reads += 1;
-          return reads === 1
-            ? undefined
-            : Array(CHILDREN_CAP * 2).fill({ type: "Text" });
-        },
-      },
-    );
-
-    const { reasons, result } = walk(hostile);
-
-    expect(reasons).toEqual([]);
-    expect((result as { children: unknown }).children).toBeUndefined();
-  });
-
-  it("accepts nesting exactly at the element-depth ceiling", () => {
-    expect(walk(nest(MAX_ELEMENT_DEPTH)).reasons).toEqual([]);
-  });
-
-  it("drops nodes one level past the element-depth ceiling", () => {
-    const { reasons, result } = walk(nest(MAX_ELEMENT_DEPTH + 1));
-
-    expect(reasons).toEqual(["depth"]);
-    expect(JSON.stringify(result)).toContain('"children":null');
-  });
-
-  it("spends a single budget across shared references and reports it once", () => {
-    let spec: unknown = { type: "Text" };
-    for (let level = 0; level < 20; level += 1) {
-      spec = { type: "Box", children: [spec, spec] };
-    }
-
-    expect(walk(spec).reasons).toEqual(["budget"]);
-  });
-
-  it("cuts a node that is its own ancestor", () => {
-    const cyclic: Record<string, unknown> = { type: "Box" };
-    cyclic["children"] = [cyclic];
-
-    const { reasons, result } = walk(cyclic);
-
-    expect(reasons).toEqual(["cycle"]);
-    expect(result).toEqual({ type: "Box", children: [null] });
-  });
-
-  it("keeps a repeated sibling that is not an ancestor", () => {
-    const shared = { type: "Box", children: [] };
-
-    const { reasons, result } = walk({
-      type: "Row",
-      children: [shared, shared],
-    });
-
-    expect(reasons).toEqual([]);
-    expect(result).toEqual({ type: "Row", children: [shared, shared] });
-  });
-});
-
-describe("clampReasonDetail", () => {
-  it("renders one detail per reason", () => {
-    expect(clampReasonDetail("budget")).toBe(
-      `the tree was truncated after ${NODE_BUDGET} nodes.`,
-    );
-    expect(clampReasonDetail("cycle")).toBe(
-      "a self-referencing node was dropped.",
-    );
-    expect(clampReasonDetail("depth")).toBe(
-      `nodes deeper than ${MAX_ELEMENT_DEPTH} levels were dropped.`,
-    );
-    expect(clampReasonDetail("children")).toBe(
-      `children were clamped to ${CHILDREN_CAP} entries.`,
-    );
-  });
-});