@copilotkit/react-core 2.0.0-next.1 → 2.0.0-rc.0

package/dist/MarkdownRendererContext-CRKFzsEB.d.mts

@@ -0,0 +1,954 @@
+import { AbstractAgent } from "@ag-ui/client";
+import React$1, { ComponentType, ReactNode } from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+import { StreamingMarkdownRendererProps } from "@copilotkit/markdown-renderer/react";
+import { A2UIFunctionPermissions, A2UIFunctionReturnType, A2UIOperation, ChildRef, GenerativeUIComponentManifest, GenerativeUIFunctionManifest, GenerativeUIRejectedOperation, GenerativeUISurfaceContent, GenerativeUISurfaceStatus, GenerativeUISurfaceSummary, GenerativeUIUserEvent, StandardSchemaV1 } from "@copilotkit/shared";
+import { ActivityMessage } from "@ag-ui/core";
+import { SurfaceModel } from "@a2ui/web_core/v0_9";
+
+//#region src/generative-ui/errors.d.ts
+type GenerativeUIErrorCode = "function_not_found" | "function_conflict" | "invalid_arguments" | "handler_failed" | "invalid_event_args" | "event_forward_failed" /** A function value or check could not be computed. */ | "expression_error" /** A function the caller may not call: `openUrl` from the agent. */ | "invalid_function_call" /** An event arrived while the agent was running: it was not sent. */ | "agent_busy";
+declare class GenerativeUIError extends Error {
+  readonly code: GenerativeUIErrorCode;
+  constructor(code: GenerativeUIErrorCode, message: string);
+}
+type GenerativeUIInvokeResult = {
+  ok: true;
+  result: unknown;
+} | {
+  ok: false;
+  error: GenerativeUIError;
+};
+type Components<UI extends GenerativeUI<any>> = GenerativeUIDefinitionsOf<UI>["components"];
+type EventsOf<UI extends GenerativeUI<any>, Component extends keyof Components<UI>> = Components<UI>[Component]["events"] extends Record<string, unknown> ? Components<UI>[Component]["events"] : {};
+type IsUnion<T, U = T> = T extends unknown ? [U] extends [T] ? false : true : never;
+/** One member of a union. Used only after IsUnion proved the members equal. */
+type OneOf<U> = UnionToIntersection<U extends unknown ? () => U : never> extends (() => infer R) ? R : never;
+/** Every event name that a component of the UI declares, bases included. */
+type GenerativeUIEventName<UI extends GenerativeUI<any>> = { [Component in keyof Components<UI>]: keyof EventsOf<UI, Component> & string }[keyof Components<UI>];
+type EventArgs<UI extends GenerativeUI<any>, Name extends string> = { [Component in keyof Components<UI>]: Name extends keyof EventsOf<UI, Component> ? GenerativeUIEventInput<Name, EventsOf<UI, Component>[Name], GenerativeUIDefinitionsOf<UI>["functions"]> : never }[keyof Components<UI>];
+/**
+ * Type of an event prop as seen by a component, looked up by event name in
+ * the generative UI that renders the component:
+ * `onSubmit?: GenerativeUIEventHandler<typeof ui, "onSubmit">`.
+ *
+ * The argument is the event `parameters` input. A matched event without
+ * `parameters` takes the input of its function.
+ *
+ * When components of the UI declare the event with different arguments, the
+ * result is not callable and names the conflict.
+ */
+type GenerativeUIEventHandler<UI extends GenerativeUI<any>, Name extends GenerativeUIEventName<UI>> = true extends IsUnion<EventArgs<UI, Name>> ? {
+  readonly error: `"${Name}" has different parameters on different components of this generative UI`;
+} : (args: OneOf<EventArgs<UI, Name>>) => Promise<GenerativeUIInvokeResult>;
+interface GenerativeUIErrorInfo {
+  kind: "render" | "props" | "operation" | "function" | "event";
+  surfaceId: string;
+  componentId?: string;
+  error: Error;
+}
+//#endregion
+//#region src/generative-ui/schema.d.ts
+/** Any Standard Schema: zod, Valibot, ArkType, and more. */
+type GenerativeUISchema = StandardSchemaV1;
+/** The output type of a schema: what validation gives back. */
+type SchemaOutput<Schema> = Schema extends StandardSchemaV1<any, infer Output> ? Output : never;
+/** The input type of a schema: what validation takes. */
+type SchemaInput<Schema> = Schema extends StandardSchemaV1<infer Input, any> ? Input : never;
+//#endregion
+//#region src/generative-ui/catalog.d.ts
+type GenerativeUISlotKind = "single" | "multiple";
+/**
+ * The schema of the props of a component: any Standard Schema of an object,
+ * for example `z.object({ ... })` or `v.object({ ... })`. The model gets
+ * the props as JSON Schema, so the schema must give one: Standard JSON
+ * Schema (zod 4.2+, ArkType, Valibot with `toStandardJsonSchema`) or zod 3.
+ * It must validate synchronously, because props are checked while a
+ * surface renders.
+ */
+type PropsSchema = StandardSchemaV1<Record<string, unknown>, Record<string, unknown>>;
+/** An event prop of a component. */
+interface GenerativeUIEventDefinition {
+  description?: string;
+  /**
+   * Arguments the component passes when it calls the event prop. An event
+   * that matches a declared function can leave this out. Then the function
+   * parameters are used.
+   */
+  parameters?: GenerativeUISchema;
+}
+/**
+ * A function that generated UI can call. The handler comes from
+ * `useGenerativeUIFunction`.
+ */
+interface GenerativeUIFunctionDefinition extends A2UIFunctionPermissions {
+  description?: string;
+  parameters: GenerativeUISchema;
+  /**
+   * Who may call it. `"rendererOnly"` (the default, as in A2UI 1.0): event
+   * bindings and prop values. `"agentOnly"`: `callRendererFunction`.
+   * `"rendererOrAgent"`: both. The agent calls only what you allow.
+   */
+  allowedCallers?: A2UIFunctionPermissions["allowedCallers"];
+  /**
+   * True for a function that runs only from a user gesture, like `openUrl`.
+   * It is then for the renderer only.
+   */
+  requiresUserActivation?: boolean;
+  /** What the handler gives back, as A2UI 1.0 names it. */
+  returnType?: A2UIFunctionReturnType;
+}
+/**
+ * Gives a bound prop its value. It gets the full state and the model-set
+ * props of the node, before the props schema parses them (no defaults or
+ * transforms). It runs in the browser and must be pure.
+ */
+type GenerativeUISelector = (state: Record<string, unknown>, props: Record<string, unknown>) => unknown;
+/**
+ * Method syntax makes the parameters bivariant. So a selector with typed
+ * parameters fits this runtime type.
+ */
+type RuntimeSelector = {
+  select(state: Record<string, unknown>, props: Record<string, unknown>): unknown;
+}["select"];
+/** One component of a generative UI, as the renderer reads it. */
+interface GenerativeUIComponentDefinition {
+  component: ComponentType<any>;
+  description?: string;
+  /**
+   * Positional prefix across props, slots and events for catalog consumers.
+   * Remaining visible keys follow in declaration order (props, slots, events).
+   * A2UI exports encode this as property order, not a protocol field.
+   */
+  parameterOrder?: readonly string[];
+  /** All data props: the props the model sets and the bound props. */
+  props?: PropsSchema;
+  /** Explicit selectors for bound props. */
+  bind?: Record<string, RuntimeSelector>;
+  /** Callback props. */
+  events?: Record<string, GenerativeUIEventDefinition>;
+  /**
+   * Child props, filled with rendered child components. A "multiple" slot
+   * takes a list of component ids, or a template `{ componentId, path }`
+   * that renders one component for each item of the list at `path`.
+   */
+  slots?: Record<string, GenerativeUISlotKind>;
+  /**
+   * Props that the component can write. Each one gets a setter prop named
+   * `set` + the prop name: `value` gets `setValue`. When the model binds the
+   * prop to `{ "@path" }`, the setter writes the surface data model at that
+   * path, and the agent can no longer change that path. Else the setter
+   * changes local state only.
+   */
+  writable?: readonly string[];
+  /**
+   * Who applies the `accessibility` envelope of the component: by default
+   * the engine, in a wrapper element around the component. `"self"` for a
+   * component that must not be wrapped (a table row or cell) and applies
+   * the attributes itself with `useGenerativeUIAccessibility()`.
+   */
+  accessibility?: "wrapper" | "self";
+}
+/** A component after `createGenerativeUI` resolved its bindings. */
+interface ResolvedGenerativeUIComponent extends GenerativeUIComponentDefinition {
+  /**
+   * One selector for each bound prop. A prop with the name of a top-level
+   * state key reads `state[key]`. A `bind` entry wins over the name rule.
+   */
+  selectors: Record<string, GenerativeUISelector>;
+  /** Event name to the name of the declared function it calls. */
+  eventFunctions: Record<string, string>;
+  /** The keys of `props`, read from its JSON Schema. */
+  propKeys: readonly string[];
+  /**
+   * The component references in `props` (`child()`, `childList()`), at any
+   * depth. The renderer replaces each one with the rendered component. The
+   * `slots` of the definition are not in here.
+   */
+  childRefs: readonly ChildRef[];
+  /** Who applies the `accessibility` envelope; see the definition. */
+  accessibility: "wrapper" | "self";
+}
+/** Type-level data of one component, kept in `GenerativeUI["definitions"]`. */
+interface GenerativeUIComponentTypes {
+  /** The `props` schema, or `unknown` when the component has none. */
+  props: unknown;
+  /** The `events` object, or `unknown` when the component has none. */
+  events: unknown;
+  /** The `slots` object, or `unknown` when the component has none. */
+  slots: unknown;
+  /** The `writable` list, or `unknown` when the component has none. */
+  writable: unknown;
+}
+/** Type-level data of a generative UI, with the keys of its bases merged in. */
+interface GenerativeUIDefinitions {
+  state: Record<string, GenerativeUISchema>;
+  functions: Record<string, GenerativeUIFunctionDefinition>;
+  components: Record<string, GenerativeUIComponentTypes>;
+}
+/**
+ * Experimental. The result of `createGenerativeUI`: the components the model
+ * can render, the app state they read, and the functions they call. Give it
+ * to the provider (`generativeUI={{ ui }}`) and to the typed hooks.
+ */
+interface GenerativeUI<Definitions extends GenerativeUIDefinitions = GenerativeUIDefinitions> {
+  /** Surfaces pin to this id. */
+  readonly id: string;
+  /** State schemas, bases first. */
+  readonly state: ReadonlyMap<string, GenerativeUISchema>;
+  /** Declared functions, bases first. */
+  readonly functions: ReadonlyMap<string, GenerativeUIFunctionDefinition>;
+  /** Components, bases first. */
+  readonly components: ReadonlyMap<string, ResolvedGenerativeUIComponent>;
+  /** What the model sees: model-set props and unmatched events only. */
+  readonly manifestComponents: Record<string, GenerativeUIComponentManifest>;
+  /** Type only, never set at runtime. */
+  readonly definitions?: Definitions;
+  /**
+   * A copy without the named components. The model no longer sees them, so
+   * the prompt gets smaller. State and functions stay. Call it once, at
+   * module level, like `createGenerativeUI`.
+   *
+   * @throws Error when a name is not a component of this UI.
+   *
+   * @example
+   * ```ts
+   * const ui = createGenerativeUI({
+   *   id: "acme/app@1",
+   *   extends: [standardUI.omit(["Map", "Chart"])],
+   *   components: {},
+   * });
+   * ```
+   */
+  omit<Names extends keyof Definitions["components"] & string>(names: readonly Names[]): GenerativeUI<OmitComponents<Definitions, Names>>;
+}
+/** Definitions without some components. */
+type OmitComponents<Definitions extends GenerativeUIDefinitions, Names extends PropertyKey> = {
+  state: Definitions["state"];
+  functions: Definitions["functions"];
+  components: Omit<Definitions["components"], Names>;
+};
+type AnyGenerativeUI = GenerativeUI<any>;
+/**
+ * Any function or class component. Unlike `ComponentType`, checking a value
+ * against it does not read the component's props type. So a component can
+ * type its props from `typeof ui` without a circular type reference.
+ */
+type AnyComponent = ((...args: never) => unknown) | (abstract new (...args: never) => unknown);
+type Simplify<T> = { [Key in keyof T]: T[Key] } & {};
+/** `A | B` to `A & B`. */
+type UnionToIntersection<U> = (U extends unknown ? (value: U) => void : never) extends ((value: infer I) => void) ? I : never;
+type OutputOf<Schema> = SchemaOutput<Schema>;
+type InputOf<Schema> = SchemaInput<Schema>;
+/** The prop names. None for a component without `props`. */
+type PropKeys<Props> = Props extends PropsSchema ? keyof OutputOf<Props> & string : never;
+/** The input type of one prop of a props schema. */
+type PropInput<Props, Key> = Key extends keyof InputOf<Props> ? InputOf<Props>[Key] : never;
+/** The type-level data of a generative UI. */
+type GenerativeUIDefinitionsOf<UI extends AnyGenerativeUI> = NonNullable<UI["definitions"]>;
+type StateValues<State> = Simplify<{ [Key in keyof State]: OutputOf<State[Key]> }>;
+/**
+ * The state object of a generative UI, bases included. Selectors get it, and
+ * `useGenerativeUIState(ui, key, value)` sets one key of it.
+ */
+type GenerativeUIStateOf<UI extends AnyGenerativeUI> = StateValues<GenerativeUIDefinitionsOf<UI>["state"]>;
+/** The declared functions of a generative UI, bases included. */
+type GenerativeUIFunctionsOf<UI extends AnyGenerativeUI> = GenerativeUIDefinitionsOf<UI>["functions"];
+/** The name of a declared function of a generative UI. */
+type GenerativeUIFunctionName<UI extends AnyGenerativeUI> = keyof GenerativeUIFunctionsOf<UI> & string;
+/**
+ * The name of a component of a generative UI, bases included. For
+ * `GenerativeUI<any>`, it is `string`.
+ */
+type GenerativeUIComponentName<UI extends AnyGenerativeUI> = keyof GenerativeUIDefinitionsOf<UI>["components"] & string;
+type FunctionInput<Functions, Name> = Name extends keyof Functions ? Functions[Name] extends GenerativeUIFunctionDefinition ? InputOf<Functions[Name]["parameters"]> : never : never;
+/** What a caller passes to a declared function (the schema input). */
+type GenerativeUIFunctionInput<UI extends AnyGenerativeUI, Name extends GenerativeUIFunctionName<UI>> = FunctionInput<GenerativeUIFunctionsOf<UI>, Name>;
+/**
+ * What the handler of a declared function gets: the parsed arguments (the
+ * schema output, with defaults set).
+ */
+type GenerativeUIFunctionArgs<UI extends AnyGenerativeUI, Name extends GenerativeUIFunctionName<UI>> = OutputOf<GenerativeUIFunctionsOf<UI>[Name]["parameters"]>;
+/**
+ * The function an event calls: the function with the same name, else the
+ * name without `on` and with a lowercase first letter. `never` when none.
+ */
+type MatchedFunction<Name extends string, Functions> = Name extends keyof Functions ? Name : Name extends `on${infer Rest}` ? Uncapitalize<Rest> extends keyof Functions ? Uncapitalize<Rest> : never : never;
+/**
+ * The argument type of an event prop. The event `parameters` input when it
+ * declares them, else the input of the matched function.
+ */
+type GenerativeUIEventInput<Name extends string, Event, Functions> = "parameters" extends keyof Event ? InputOf<Event["parameters" & keyof Event]> : FunctionInput<Functions, MatchedFunction<Name, Functions>>;
+type DataProps<Props> = Props extends PropsSchema ? OutputOf<Props> : {};
+type EventProps<Events, Functions> = Events extends Record<string, unknown> ? { [Name in keyof Events]?: (args: GenerativeUIEventInput<Name & string, Events[Name], Functions>) => Promise<GenerativeUIInvokeResult> } : {};
+type SlotProps<Slots> = Slots extends Record<string, unknown> ? { [Name in keyof Slots]?: ReactNode } : {};
+type WritableKeys<Writable> = Writable extends readonly (infer Key)[] ? Key & string : never;
+/** One setter for each writable prop: `value` gets `setValue`. */
+type SetterProps<Props, Writable> = { [Key in WritableKeys<Writable> & PropKeys<Props> as `set${Capitalize<Key>}`]: (value: PropInput<Props, Key>) => void };
+/**
+ * Props that the renderer passes to a component:
+ * `function CheckoutForm(props: GenerativeUIComponentProps<typeof ui, "CheckoutForm">)`.
+ * Data props are the parsed `props` schema, bound props included. Event and
+ * slot props are present only when they are bound or filled. Each writable
+ * prop gets a setter (`value` gets `setValue`), which is always present.
+ */
+type GenerativeUIComponentProps<UI extends AnyGenerativeUI, Name extends keyof GenerativeUIDefinitionsOf<UI>["components"] & string> = Simplify<DataProps<GenerativeUIDefinitionsOf<UI>["components"][Name]["props"]> & EventProps<GenerativeUIDefinitionsOf<UI>["components"][Name]["events"], GenerativeUIDefinitionsOf<UI>["functions"]> & SlotProps<GenerativeUIDefinitionsOf<UI>["components"][Name]["slots"]> & SetterProps<GenerativeUIDefinitionsOf<UI>["components"][Name]["props"], GenerativeUIDefinitionsOf<UI>["components"][Name]["writable"]>>;
+type BaseDefinitions<Bases extends readonly AnyGenerativeUI[]> = GenerativeUIDefinitionsOf<Bases[number]>;
+type MergedState<Bases extends readonly AnyGenerativeUI[], State> = Simplify<UnionToIntersection<BaseDefinitions<Bases>["state"]> & State>;
+type MergedFunctions<Bases extends readonly AnyGenerativeUI[], Functions> = Simplify<UnionToIntersection<BaseDefinitions<Bases>["functions"]> & Functions>;
+/** Props keys with the name of a top-level state key. */
+type NameKeys<Props, State> = PropKeys<Props> & keyof State;
+type SelectorFor<Props, State, Key extends PropKeys<Props>> = (state: StateValues<State>, props: Simplify<Omit<InputOf<Props>, NameKeys<Props, State> | Key>>) => PropInput<Props, Key>;
+type BindSelectors<Props, State> = { [Key in PropKeys<Props>]?: SelectorFor<Props, State, Key> };
+/** Name-bound keys whose state type does not fit the prop schema input. */
+type MismatchedNameKeys<Props, State> = { [Key in NameKeys<Props, State>]: [OutputOf<State[Key]>] extends [PropInput<Props, Key>] ? never : Key }[NameKeys<Props, State>];
+/**
+ * `bind` is optional. When a prop has the name of a state key but the state
+ * type does not fit, `bind` must give that prop a selector.
+ */
+type BindField<Props, State> = [MismatchedNameKeys<Props, State>] extends [never] ? {
+  bind?: BindSelectors<Props, State>;
+} : {
+  bind: BindSelectors<Props, State> & { [Key in MismatchedNameKeys<Props, State>]-?: SelectorFor<Props, State, Key> };
+};
+/** `unknown` (no props) or an object schema. Else `props` gets an error. */
+type PropsCheck<Props> = unknown extends Props ? unknown : Props extends PropsSchema ? unknown : {
+  props?: PropsSchema;
+};
+type MatchCheck<Name extends string, Event, Functions> = [MatchedFunction<Name, Functions>] extends [never] ? "parameters" extends keyof Event ? unknown : {
+  parameters: GenerativeUISchema;
+} : "parameters" extends keyof Event ? [OutputOf<Event["parameters" & keyof Event]>] extends [FunctionInput<Functions, MatchedFunction<Name, Functions>>] ? unknown : {
+  parameters: `The output of these parameters does not fit the input of function "${MatchedFunction<Name, Functions> & string}".`;
+} : unknown;
+/**
+ * `unknown` when the event is valid. Else a type the event does not fit, so
+ * `tsc` reports the error on the event.
+ */
+type EventCheck<Name extends string, Event, Functions> = Event extends GenerativeUIEventDefinition ? MatchCheck<Name, Event, Functions> : GenerativeUIEventDefinition;
+type EventsCheck<Events, Functions> = { [Name in keyof Events]: EventCheck<Name & string, Events[Name], Functions> };
+/** Props that a component can list in `writable`: not bound by name. */
+type WritableKey<Props, State> = Exclude<PropKeys<Props>, NameKeys<Props, State>>;
+/**
+ * Each component config is split over four mapped types. Each one infers
+ * one part (props, events, slots, writable) of every component. The checks
+ * are in `NoInfer`, so they do not change what is inferred. They are not
+ * intersected with schema types directly, because two schema class types do
+ * not intersect cleanly.
+ */
+type ComponentsConfig<Props, Events, Slots, Writable, State, Functions> = { [Name in keyof Props]: {
+  component: AnyComponent;
+  description?: string;
+  parameterOrder?: readonly string[];
+  props?: Props[Name];
+  accessibility?: "wrapper" | "self";
+} & NoInfer<PropsCheck<Props[Name]> & BindField<Props[Name], State>> } & { [Name in keyof Events]: {
+  events?: Events[Name] & NoInfer<EventsCheck<Events[Name], Functions>>;
+} } & { [Name in keyof Slots]: {
+  slots?: Slots[Name] & Record<string, GenerativeUISlotKind>;
+} } & { [Name in keyof Writable]: {
+  writable?: Writable[Name] & NoInfer<readonly WritableKey<Props[Name & keyof Props], State>[]>;
+} };
+/** The config of `createGenerativeUI`. */
+interface CreateGenerativeUIConfig<Bases extends readonly AnyGenerativeUI[], State extends Record<string, GenerativeUISchema>, Functions extends Record<string, GenerativeUIFunctionDefinition>, Props extends Record<string, unknown>, Events extends Record<string, unknown>, Slots extends Record<string, unknown>, Writable extends Record<string, unknown>> {
+  /** Surfaces pin to it. Use a versioned id, for example "acme/store@1". */
+  id: string;
+  /** Bases. Their state, functions and components merge in, in order. */
+  extends?: Bases;
+  /** App state schemas, by top-level key. Put it before `components`. */
+  state?: State;
+  /** Functions that components can call. */
+  functions?: Functions;
+  /**
+   * New React components for components of the bases, by name. The model
+   * sees the same component: its description, props, events and slots stay.
+   * The new component gets the same props as the one it replaces.
+   */
+  overrides?: NoInfer<OverridesConfig<Bases>>;
+  /** The components the model can render. */
+  components: ComponentsConfig<Props, Events, Slots, Writable, MergedState<Bases, State>, MergedFunctions<Bases, Functions>>;
+}
+/** The definitions of the bases, merged. */
+type BasesDefinitions<Bases extends readonly AnyGenerativeUI[]> = ResultDefinitions<Bases, {}, {}, {}, {}, {}, {}>;
+/** One new React component for each component of the bases that it names. */
+type OverridesConfig<Bases extends readonly AnyGenerativeUI[]> = { [Name in keyof BasesDefinitions<Bases>["components"] & string]?: {
+  component: ComponentType<BasesDefinitions<Bases> extends infer Definitions extends GenerativeUIDefinitions ? GenerativeUIComponentProps<GenerativeUI<Definitions>, Name> : never>;
+} };
+type OwnComponents<Props, Events, Slots, Writable> = { [Name in keyof Props]: {
+  props: Props[Name];
+  events: Name extends keyof Events ? Events[Name] : unknown;
+  slots: Name extends keyof Slots ? Slots[Name] : unknown;
+  writable: Name extends keyof Writable ? Writable[Name] : unknown;
+} };
+type ResultDefinitions<Bases extends readonly AnyGenerativeUI[], State, Functions, Props, Events, Slots, Writable> = {
+  state: MergedState<Bases, State>;
+  functions: MergedFunctions<Bases, Functions>;
+  components: Simplify<UnionToIntersection<BaseDefinitions<Bases>["components"]> & OwnComponents<Props, Events, Slots, Writable>>;
+};
+/**
+ * The id of the catalog that declared each component of `ui`. A component
+ * from `extends` keeps the id of its base. Not exported from the package.
+ */
+/**
+ * Experimental. Declares the components the model can render, the app state
+ * they read, and the functions they call.
+ *
+ * - A prop with the name of a top-level state key is bound to that state.
+ * - `bind: { prop: (state, props) => value }` binds a prop to a selector.
+ * - An event binds to the function with its name, else to the name without
+ *   `on` (`onAddToCart` calls `addToCart`).
+ * - `writable: ["value"]` gives the component a `setValue` prop. See
+ *   `GenerativeUIComponentDefinition.writable`.
+ *
+ * The model does not see bound props or matched events.
+ *
+ * @param config - `id`, then optional `extends`, `state`, `functions` and
+ *   `overrides`, then `components`. Put `state` before `components`, so the selectors
+ *   get typed state.
+ * @throws Error when a name comes from two places, an override names no
+ *   component of the bases, `props` is not an object
+ *   schema with a JSON Schema, a key is reserved or used
+ *   twice on a component, an event matches two functions, an unmatched event
+ *   has no `parameters`, a `bind` key is not a prop, a `writable` key is not
+ *   a prop or is a bound prop, or a setter name is already a key of the
+ *   component. Also throws when `parameterOrder` contains duplicate or unknown
+ *   keys, or an ordered component declares integer-index keys whose JSON object
+ *   enumeration order cannot be controlled.
+ *
+ * @example
+ * ```ts
+ * const ui = createGenerativeUI({
+ *   id: "acme/store@1",
+ *   state: { cart: cartSchema },
+ *   functions: { addToCart: { parameters: z.object({ productId: z.string() }) } },
+ *   components: {
+ *     CartSummary: {
+ *       component: CartSummary,
+ *       props: z.object({ count: z.number() }),
+ *       bind: { count: (state) => state.cart.count },
+ *     },
+ *   },
+ * });
+ * ```
+ */
+declare function createGenerativeUI<Bases extends readonly AnyGenerativeUI[] = [], State extends Record<string, GenerativeUISchema> = {}, Functions extends Record<string, GenerativeUIFunctionDefinition> = {}, Props extends Record<string, unknown> = {}, Events extends Record<string, unknown> = {}, Slots extends Record<string, unknown> = {}, Writable extends Record<string, unknown> = {}>(config: CreateGenerativeUIConfig<Bases, State, Functions, Props, Events, Slots, Writable>): GenerativeUI<ResultDefinitions<Bases, State, Functions, Props, Events, Slots, Writable>>;
+//#endregion
+//#region src/generative-ui/accessibility.d.ts
+/**
+ * The `accessibility` of the A2UI 1.0 component envelope, with its dynamic
+ * values resolved. Every component may carry it next to `id` and
+ * `component`; it is not a prop of the component.
+ */
+interface GenerativeUIAccessibility {
+  /** A short name for assistive technologies, 1 to 3 words. */
+  label?: string;
+  /** Instructions, format requirements, or what an action does. */
+  description?: string;
+  /** How screen readers announce changes (WAI-ARIA `aria-live`). */
+  live?: "off" | "polite" | "assertive";
+  /** True hides the component and its children from assistive technologies. */
+  hidden?: boolean;
+}
+/** The ARIA attributes of a resolved `accessibility`, ready to spread. */
+interface GenerativeUIAriaAttributes {
+  "aria-label"?: string;
+  "aria-description"?: string;
+  "aria-live"?: "off" | "polite" | "assertive";
+  "aria-hidden"?: true;
+}
+/**
+ * Experimental. The ARIA attributes of the `accessibility` that the model
+ * gave the component being rendered, to spread on its root element. The
+ * standard components do this; a custom component does it itself:
+ *
+ * @example
+ * ```tsx
+ * function Panel({ children }: { children?: ReactNode }) {
+ *   const aria = useGenerativeUIAccessibility();
+ *   return <section {...aria}>{children}</section>;
+ * }
+ * ```
+ *
+ * Outside of generated UI it gives `{}`.
+ */
+declare function useGenerativeUIAccessibility(): GenerativeUIAriaAttributes;
+//#endregion
+//#region src/generative-ui/dispatcher.d.ts
+/**
+ * Holds the latest handler of one mounted `useGenerativeUIFunction`. The hook
+ * updates `current` on each render, so it registers only once per mount.
+ */
+interface GenerativeUIHandlerRef {
+  current: (args: any) => unknown;
+}
+/** The component of a surface that called a function. */
+interface GenerativeUIInvocationOrigin {
+  surfaceId: string;
+  componentId: string;
+}
+/**
+ * What called a function: a component of a surface, or the agent with a
+ * `callRendererFunction` operation.
+ */
+type GenerativeUICallOrigin = GenerativeUIInvocationOrigin | {
+  functionCallId: string;
+};
+interface GenerativeUIDispatcher {
+  /**
+   * Call a declared function with arguments from generated UI or from the
+   * agent. Never throws: every failure becomes `{ ok: false, error }`.
+   */
+  invoke(name: string, args: unknown, origin: GenerativeUICallOrigin): Promise<GenerativeUIInvokeResult>;
+  /** The declared functions that have exactly one mounted handler, as JSON Schema. */
+  listExposed(): Record<string, GenerativeUIFunctionManifest>;
+  /**
+   * Mount a handler for a declared function. Returns the function that
+   * unmounts it. Calling the returned function more than once is safe.
+   */
+  register(name: string, ref: GenerativeUIHandlerRef): () => void;
+  /** How many handlers are mounted for `name`, for the inspector. */
+  handlerCount(name: string): number;
+}
+//#endregion
+//#region src/generative-ui/surface-manager.d.ts
+interface ManagedSurface {
+  readonly key: string;
+  readonly threadId: string;
+  readonly surfaceId: string;
+  readonly agentId: string | undefined;
+  /** Replaced by an empty model when the surface closes, to free its data. */
+  model: SurfaceModel<any>;
+  readonly createdAt: number;
+  target: string;
+  status: GenerativeUISurfaceStatus;
+  deleted: boolean;
+  /** Its first createSurface was rejected, so it never existed. */
+  failed: boolean;
+  /** Rejections reported by the runtime. */
+  serverRejected: GenerativeUIRejectedOperation[];
+  /** Rejections detected while applying operations in the browser. */
+  clientRejected: GenerativeUIRejectedOperation[];
+  /** The committed operations of the latest content, for the inspector. */
+  operations: readonly A2UIOperation[];
+}
+interface GenerativeUISurfaceManagerOptions {
+  onOperationRejected?: (info: {
+    surfaceId: string;
+    index: number;
+    reason: string;
+  }) => void;
+}
+/** What one mount of a target tells the model. */
+interface GenerativeUITargetOptions {
+  /** Where the target is on the page and what to show in it. */
+  description?: string;
+  /**
+   * The only components that the surfaces of the target can use. Left out,
+   * every component of the UI is allowed.
+   */
+  components?: readonly string[];
+}
+/** A mounted target, as the manifest lists it. */
+interface GenerativeUIMountedTarget {
+  id: string;
+  description?: string;
+  components?: string[];
+}
+/**
+ * Framework-agnostic store of generated surfaces. One web_core SurfaceModel per
+ * (threadId, surfaceId), shared by every mount. Applies only newly committed
+ * operations, validates each before applying it, and owns app state and the
+ * data model paths that the user wrote, so agent updates cannot overwrite
+ * them. App state never goes into a surface's data model. Selectors read it
+ * with `getState()`.
+ */
+declare class GenerativeUISurfaceManager {
+  private readonly ui;
+  private readonly options;
+  private readonly surfaces;
+  private readonly bookkeeping;
+  private readonly listeners;
+  /** Mounts of each target id, in mount order. */
+  private readonly targets;
+  private state;
+  /**
+   * User-owned data model values, by surface key, then by path. Kept when a
+   * surface is rebuilt. Cleared when the surface is deleted.
+   */
+  private readonly owned;
+  /**
+   * Keys of the surfaces that a `deleteSurface` removed. A surface id is
+   * unique for the life of the page, so a key stays here when its surface is
+   * built again.
+   */
+  private readonly deletedKeys;
+  /**
+   * Surfaces that share their data model, by surface key: the parts of a
+   * chat surface that the prose lift split. A user write to one part goes
+   * to every part, so an input in one part drives a binding in another.
+   */
+  private readonly linked;
+  private readonly webCoreCatalog;
+  private activeThreadId;
+  private version;
+  constructor(ui: GenerativeUI, options?: GenerativeUISurfaceManagerOptions);
+  subscribe: (listener: () => void) => (() => void);
+  getVersion: () => number;
+  private notify;
+  setActiveThread(threadId: string | undefined): void;
+  getActiveThread(): string | undefined;
+  ingest(threadId: string, agentId: string | undefined, content: GenerativeUISurfaceContent): void;
+  /** The surface of a `key` (see `surfaceKey`), unless it is deleted. */
+  getSurfaceByKey(key: string): ManagedSurface | undefined;
+  getSurface(threadId: string, surfaceId: string): ManagedSurface | undefined;
+  getSurfaceForTarget(target: string, threadId?: string | undefined): ManagedSurface | undefined;
+  /**
+   * A surface whose first createSurface was rejected, so the chat can show
+   * the error where the surface would be. `undefined` for any other surface.
+   */
+  getFailedSurface(threadId: string, surfaceId: string): ManagedSurface | undefined;
+  /**
+   * The surfaces of a thread, for the model. A surface with user-owned
+   * values lists them in `dataModel`, so the model can read what the user
+   * entered. A surface with dropped operations lists them in `rejected`, so
+   * the model can fix them on the next run. A deleted surface, or one that
+   * was never created, has a `status`, so the model knows that the id is
+   * not a live surface.
+   */
+  describeSurfaces(threadId: string): Record<string, GenerativeUISurfaceSummary>;
+  /** Every surface that is not deleted, oldest first, for the inspector. */
+  debugSurfaces(): {
+    surfaceId: string;
+    threadId: string;
+    agentId: string | undefined;
+    target: string;
+    status: GenerativeUISurfaceStatus;
+    operations: readonly A2UIOperation[];
+    dataModel: any;
+    userValues: {
+      [k: string]: unknown;
+    };
+    rejected: ({
+      source: "runtime";
+      index: number;
+      reason: string;
+    } | {
+      source: "browser";
+      index: number;
+      reason: string;
+    })[];
+  }[];
+  /**
+   * Marks a target as mounted. Returns the function that unmounts it. Calling
+   * that function more than once has no effect.
+   *
+   * @param id - The target id.
+   * @param options - The description and the allowed components of this mount.
+   */
+  registerTarget(id: string, options?: GenerativeUITargetOptions): () => void;
+  /**
+   * The mounted targets. Each has the description and the component list of
+   * its earliest mount that has one.
+   */
+  getMountedTargets(): GenerativeUIMountedTarget[];
+  /**
+   * The component list of the earliest mount of `id` that has one.
+   * `undefined` when no mount of `id` limits its components.
+   */
+  private targetComponents;
+  /** The components that `validateOperation` allows on a surface. */
+  private allowedComponentsFor;
+  /**
+   * The app state object. It is the same object until a key changes, so it
+   * can be a `useSyncExternalStore` snapshot.
+   */
+  getState: () => Readonly<Record<string, unknown>>;
+  /** Sets one state key. Notifies only when the value changed. */
+  setState(key: string, value: unknown): void;
+  /** Removes one state key. Notifies only when the key was set. */
+  removeState(key: string): void;
+  /**
+   * Makes the surfaces of `surfaceIds` share their data model: a user write
+   * to one of them goes to all of them (see `setOwnedValue`). The markdown
+   * transport links the parts of a chat surface that the prose lift split.
+   * A later call for one of the surfaces replaces its group.
+   *
+   * @param threadId - The thread of the surfaces.
+   * @param surfaceIds - The surface ids of the group. One id clears a link.
+   */
+  linkSurfaces(threadId: string, surfaceIds: readonly string[]): void;
+  /**
+   * Writes a user value into the data model of a surface, and marks `path`
+   * as user-owned. Then agent writes to that path, or below it, are ignored.
+   * An agent write above it keeps the user value. Ownership ends when the
+   * surface is deleted. Does nothing for an unknown or deleted surface. The
+   * surfaces linked to it (see `linkSurfaces`) get the same write.
+   *
+   * @param key - The `key` of the surface.
+   * @param path - An absolute JSON pointer, for example "/form/email".
+   * @param value - The new value. It is copied.
+   * @throws Error when a path segment is "__proto__", "constructor" or
+   *   "prototype", or when the path does not fit the data (for example, a
+   *   segment above it holds a string).
+   */
+  setOwnedValue(key: string, path: string, value: unknown): void;
+  private writeOwnedValue;
+  /**
+   * Writes the user-owned values into the new, empty data model of a rebuilt
+   * surface. The agent operations are applied after it.
+   */
+  private restoreOwnedValues;
+  /**
+   * The value that an agent write puts at `path`, with the user-owned values
+   * below `path` written back into it. `undefined` when `path` is user-owned
+   * or below a user-owned path, so the agent cannot write it. Throws when a
+   * user value does not fit the new value.
+   */
+  private mergeOwnedValues;
+  private extendsApplied;
+  private createSurface;
+  private disposeSurface;
+  /**
+   * Marks a surface deleted and frees its components and data. The record
+   * stays, so the model is still told about the id and the bookkeeping does
+   * not rebuild the surface for content that was already applied.
+   */
+  private closeSurface;
+  /** The surfaces of a thread that a part of `surfaceId` reads, for tests. */
+  getLinkedSurfaceIds(threadId: string, surfaceId: string): string[];
+  /**
+   * Drops the node keys that the app sets: bound props and matched events.
+   * The model does not see them, so a model value for one is ignored, not
+   * rejected. This runs before validation, because validation rejects keys
+   * that are not in the manifest. It never changes the given operation.
+   */
+  private dropAppSetKeys;
+  private dropAppSetNodeKeys;
+  /**
+   * The surfaces that `validateOperation` gets for one operation of the
+   * content of `surface`.
+   *
+   * - `knownSurfaces`: the surface, when it exists before the operation. It
+   *   does not exist before its first createSurface, or after a delete.
+   * - `createdSurfaces`: the surface, when a createSurface at this position
+   *   uses its id again. That is the case after the first operation, and for
+   *   a surface that was deleted before, unless the content replays that
+   *   delete.
+   */
+  private surfacesFor;
+  private applyOperation;
+  /** The first node with props of the wrong type, as a reason. */
+  private nodesProblem;
+  /**
+   * Writes an agent value at `path` and keeps the user-owned values. A write
+   * to a user-owned path is ignored, not rejected. Gives the reason when the
+   * value does not fit the data, else `undefined`.
+   */
+  private writeAgentData;
+  private checkNodeProps;
+  private upsertNode;
+}
+//#endregion
+//#region src/generative-ui/standard/tokens.d.ts
+declare const RADII: readonly ["2xs", "xs", "sm", "md", "lg", "xl", "2xl", "3xl", "4xl", "full"];
+declare const TEXT_COLORS: readonly ["default", "prose", "primary", "emphasis", "secondary", "tertiary", "success", "info", "warning", "caution", "danger", "discovery"];
+declare const BORDER_COLORS: readonly ["default", "subtle", "strong", "info", "warning", "caution", "success", "danger", "discovery"];
+declare const BACKGROUNDS: readonly ["surface", "surface-secondary", "surface-tertiary", "surface-elevated", "surface-elevated-secondary", "surface-inverted", "surface-soft", "info", "warning", "caution", "success", "danger", "discovery", "info-solid", "warning-solid", "caution-solid", "success-solid", "danger-solid", "discovery-solid"];
+//#endregion
+//#region src/generative-ui/theme.d.ts
+type TextColor = (typeof TEXT_COLORS)[number];
+type BorderColor = (typeof BORDER_COLORS)[number];
+type Background = (typeof BACKGROUNDS)[number];
+type Radius = Exclude<(typeof RADII)[number], "full">;
+type Tint = "info" | "warning" | "caution" | "success" | "danger" | "discovery";
+type ChartSeries = 1 | 2 | 3 | 4 | 5 | 6;
+/** Every CSS variable that the standard components read. */
+type GenerativeUIThemeVariable = `--a2ui-color-text-${TextColor}` | `--a2ui-color-${Background}` | `--a2ui-color-border-${BorderColor}` | `--a2ui-color-${Tint}-soft` | `--a2ui-radius-${Radius}` | `--a2ui-chart-${ChartSeries}` | "--a2ui-color-accent" | "--a2ui-color-on-accent" | "--a2ui-color-panel" | "--a2ui-color-control" | "--a2ui-color-focus" | "--a2ui-color-shimmer" | "--a2ui-color-chart-cursor" | "--a2ui-color-slider-track" | "--a2ui-color-badge-secondary" | "--a2ui-color-border-control" | "--a2ui-color-highlight-green" | "--a2ui-color-highlight-orange" | "--a2ui-color-highlight-pink" | "--a2ui-color-backdrop" | "--a2ui-color-overlay" | "--a2ui-color-rating" | "--a2ui-shadow-xs" | "--a2ui-shadow-sm" | "--a2ui-shadow-soft" | "--a2ui-shadow-md" | "--a2ui-font-family" | "--a2ui-heading-margin" | "--a2ui-block-margin";
+/** Values for the theme variables. A name that is not one is a type error. */
+type GenerativeUIThemeVariables = { [Variable in GenerativeUIThemeVariable]?: string };
+/** The values of one color scheme, plus the map style of that scheme. */
+type GenerativeUIThemeValues = GenerativeUIThemeVariables & {
+  /** A MapLibre style URL for the Map component. */mapStyle?: string;
+};
+/**
+ * The look of generated UI. Values at the top level apply in light and in
+ * dark mode. Values in `dark` replace them in dark mode. Dark mode is on
+ * when an ancestor of the surface has the `dark` class, like the CopilotKit
+ * chat.
+ *
+ * @example
+ * ```ts
+ * const theme: GenerativeUITheme = {
+ *   "--a2ui-color-accent": "#d97706",
+ *   "--a2ui-font-family": "Inter, sans-serif",
+ *   dark: { "--a2ui-color-panel": "#1f2937" },
+ * };
+ * ```
+ */
+type GenerativeUITheme = GenerativeUIThemeValues & {
+  dark?: GenerativeUIThemeValues;
+};
+//#endregion
+//#region src/generative-ui/runtime-context.d.ts
+interface GenerativeUIErrorBoundaryConfig {
+  /** Replaces the default per-component fallback. */
+  fallback?: (props: {
+    error: Error;
+    retry: () => void;
+    surfaceId: string;
+    componentId: string;
+  }) => ReactNode;
+  /** Called for render, props, operation, function and event failures. */
+  onError?: (info: GenerativeUIErrorInfo) => void;
+}
+interface GenerativeUIBaseConfig {
+  /**
+   * The result of `createGenerativeUI`: the components the model can render,
+   * the app state they read and the functions they call.
+   */
+  ui: GenerativeUI;
+  /**
+   * The agents that get the generative UI. When omitted, every agent gets
+   * it. Other agents get no envelope.
+   */
+  agentIds?: string[];
+  /**
+   * Values for the `--a2ui-*` CSS variables and the map style. Top-level
+   * values apply in both modes. `dark` changes them in dark mode, which is
+   * on under a `.dark` class, like the CopilotKit chat.
+   */
+  theme?: GenerativeUITheme;
+  /** Fallback UI and error reporting for generated UI. */
+  errorBoundary?: GenerativeUIErrorBoundaryConfig;
+}
+/**
+ * The tool transport: the model calls the `render_ui` tool, and the runtime
+ * validates each operation before it streams it to the client.
+ */
+interface GenerativeUIToolConfig extends GenerativeUIBaseConfig {
+  /** Leave it out, or set "tool". */
+  transport?: "tool";
+  sendContext?: never;
+  includeCatalog?: never;
+}
+/**
+ * The markdown transport: the model writes the operations in ```a2ui fences
+ * in its reply. The client reads and validates them.
+ */
+interface GenerativeUIMarkdownConfig extends GenerativeUIBaseConfig {
+  transport: "markdown";
+  /**
+   * Send the component schema and the fence guideline as context entries.
+   * Set `false` when the backend builds its own prompt from the envelope.
+   * Default `true`.
+   */
+  sendContext?: boolean;
+  /**
+   * Send the component schemas in the envelope (`catalog.components`).
+   * Default `true`.
+   */
+  includeCatalog?: boolean;
+}
+/**
+ * Experimental. The `generativeUI` prop of `CopilotKitProvider`. Set
+ * `transport: "markdown"` to get the markdown options.
+ *
+ * @example
+ * ```tsx
+ * <CopilotKitProvider generativeUI={{ ui }} />
+ * <CopilotKitProvider generativeUI={{ ui, transport: "markdown", sendContext: false }} />
+ * ```
+ */
+type GenerativeUIConfig = GenerativeUIToolConfig | GenerativeUIMarkdownConfig;
+interface GenerativeUIRuntime {
+  manager: GenerativeUISurfaceManager;
+  dispatcher: GenerativeUIDispatcher;
+  /** The generative UI given to the provider as `generativeUI={{ ui }}`. */
+  ui: GenerativeUI;
+  /** How the model sends operations. "tool" when the config leaves it out. */
+  transport: "tool" | "markdown";
+  /** The latest `generativeUI` config of the provider. */
+  readonly config: GenerativeUIConfig;
+  /** The latest `theme`. Each surface root sets its CSS variables. */
+  theme?: GenerativeUITheme;
+  forwardEvent: (event: GenerativeUIUserEvent, agentId: string | undefined) => Promise<GenerativeUIInvokeResult>;
+  reportError: (info: GenerativeUIErrorInfo) => void;
+  readonly errorFallback?: GenerativeUIErrorBoundaryConfig["fallback"];
+}
+declare function useGenerativeUIRuntime(): GenerativeUIRuntime | null;
+//#endregion
+//#region src/types/react-activity-message-renderer.d.ts
+interface ReactActivityMessageRenderer<TActivityContent> {
+  /**
+   * Activity type to match when rendering. Use "*" as a wildcard renderer.
+   */
+  activityType: string;
+  /**
+   * Optional agent ID to scope the renderer to a particular agent.
+   */
+  agentId?: string;
+  /**
+   * Schema describing the activity content payload.
+   */
+  content: StandardSchemaV1<any, TActivityContent>;
+  /**
+   * React component invoked to render the activity message.
+   */
+  render: React.ComponentType<{
+    activityType: string;
+    content: TActivityContent;
+    message: ActivityMessage;
+    agent: AbstractAgent | undefined;
+  }>;
+}
+//#endregion
+//#region src/generative-ui/chat.d.ts
+interface GenerativeUIChatSurfaceProps {
+  surfaceId: string;
+  isStreaming: boolean;
+  /**
+   * Set when operations from the latest render_ui call were rejected. The
+   * message is user-facing; `error.cause` holds the same list as `rejected`.
+   */
+  error?: Error;
+  /** Rejected operations from the latest render_ui call, with validator reasons. */
+  rejected: GenerativeUIRejectedOperation[];
+  children: ReactNode;
+}
+declare function DefaultGenerativeUIChatCard({
+  surfaceId,
+  isStreaming,
+  error,
+  children
+}: GenerativeUIChatSurfaceProps): react_jsx_runtime0.JSX.Element;
+//#endregion
+//#region src/providers/MarkdownRendererContext.d.ts
+/** Props every markdown renderer (built-in or plugged-in) receives. */
+interface MarkdownRendererProps {
+  /** Raw, possibly-partial (streaming) markdown string. */
+  content: string;
+  /** Hint that the message is still streaming, for cursor/affordance use. */
+  isStreaming?: boolean;
+  className?: string;
+}
+/**
+ * Config for the built-in default renderer. Pass this (instead of a component)
+ * as `markdownRenderer` to configure the built-in renderer without writing a
+ * wrapper — e.g. `markdownRenderer={{ nodeRenderers: { codeBlock: Shiki } }}`.
+ */
+type DefaultMarkdownRendererProps = Pick<StreamingMarkdownRendererProps, "nodeRenderers" | "caret" | "options" | "className" | "onLinkClick" | "onCitationClick">;
+/** A markdown renderer: a component, OR config for the built-in default. */
+type MarkdownRenderer = React$1.ComponentType<MarkdownRendererProps> | DefaultMarkdownRendererProps;
+declare const MarkdownRendererProvider: React$1.FC<{
+  renderer?: MarkdownRenderer;
+  children: React$1.ReactNode;
+}>;
+/**
+ * The markdown renderer set at the provider level, or `undefined` when none was
+ * supplied. Message components fall back to the built-in
+ * `StreamingMarkdownDefaultRenderer` (via `CopilotChatAssistantMessage.MarkdownRenderer`)
+ * when this is `undefined`.
+ */
+declare function useMarkdownRenderer(): MarkdownRenderer | undefined;
+//#endregion
+export { GenerativeUIFunctionInput as A, GenerativeUIInvokeResult as B, GenerativeUIComponentDefinition as C, GenerativeUIEventDefinition as D, GenerativeUIDefinitionsOf as E, SchemaInput as F, GenerativeUIError as I, GenerativeUIErrorCode as L, GenerativeUISlotKind as M, GenerativeUIStateOf as N, GenerativeUIFunctionArgs as O, createGenerativeUI as P, GenerativeUIErrorInfo as R, GenerativeUI as S, GenerativeUIComponentProps as T, GenerativeUIThemeVariables as _, useMarkdownRenderer as a, useGenerativeUIAccessibility as b, ReactActivityMessageRenderer as c, GenerativeUIMarkdownConfig as d, GenerativeUIToolConfig as f, GenerativeUIThemeVariable as g, GenerativeUIThemeValues as h, MarkdownRendererProvider as i, GenerativeUIFunctionName as j, GenerativeUIFunctionDefinition as k, GenerativeUIConfig as l, GenerativeUITheme as m, MarkdownRenderer as n, DefaultGenerativeUIChatCard as o, useGenerativeUIRuntime as p, MarkdownRendererProps as r, GenerativeUIChatSurfaceProps as s, DefaultMarkdownRendererProps as t, GenerativeUIErrorBoundaryConfig as u, GenerativeUIAccessibility as v, GenerativeUIComponentName as w, CreateGenerativeUIConfig as x, GenerativeUIAriaAttributes as y, GenerativeUIEventHandler as z };
+//# sourceMappingURL=MarkdownRendererContext-CRKFzsEB.d.mts.map