@copilotkit/react-core 1.80.0 → 1.81.0

package/dist/index.umd.js

@@ -1,10 +1,10 @@
 "use client";
 
 (function(global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('react'), require('@copilotkit/core'), require('@ag-ui/client'), require('@copilotkit/shared'), require('react/jsx-runtime'), require('@ag-ui/core'), require('zod'), require('@copilotkit/mcp-apps-renderer/activity'), require('@copilotkit/a2ui-renderer'), require('zod-to-json-schema'), require('react-dom'), require('react-markdown'), require('@copilotkit/runtime-client-gql')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react', '@copilotkit/core', '@ag-ui/client', '@copilotkit/shared', 'react/jsx-runtime', '@ag-ui/core', 'zod', '@copilotkit/mcp-apps-renderer/activity', '@copilotkit/a2ui-renderer', 'zod-to-json-schema', 'react-dom', 'react-markdown', '@copilotkit/runtime-client-gql'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitReactCore = {}), global.React,global.CopilotKitCore,global.AgUIClient,global.CopilotKitShared,global.ReactJsxRuntime,global._ag_ui_core,global.Zod,global.CopilotKitMcpAppsRendererActivity,global.CopilotKitA2UIRenderer,global.zod_to_json_schema,global.ReactDOM,global.ReactMarkdown,global.CopilotKitRuntimeClientGQL));
-})(this, function(exports, react, _copilotkit_core, _ag_ui_client, _copilotkit_shared, react_jsx_runtime, _ag_ui_core, zod, _copilotkit_mcp_apps_renderer_activity, _copilotkit_a2ui_renderer, zod_to_json_schema, react_dom, react_markdown, _copilotkit_runtime_client_gql) {
+  typeof exports === 'object' && typeof module !== 'undefined' ?  factory(exports, require('react'), require('@copilotkit/core'), require('@ag-ui/client'), require('@copilotkit/shared'), require('react/jsx-runtime'), require('@ag-ui/core'), require('zod'), require('@copilotkit/mcp-apps-renderer/activity'), require('@copilotkit/a2ui-renderer'), require('zod-to-json-schema'), require('@a2ui/web_core/v0_9'), require('react-dom'), require('react-markdown'), require('@copilotkit/runtime-client-gql')) :
+  typeof define === 'function' && define.amd ? define(['exports', 'react', '@copilotkit/core', '@ag-ui/client', '@copilotkit/shared', 'react/jsx-runtime', '@ag-ui/core', 'zod', '@copilotkit/mcp-apps-renderer/activity', '@copilotkit/a2ui-renderer', 'zod-to-json-schema', '@a2ui/web_core/v0_9', 'react-dom', 'react-markdown', '@copilotkit/runtime-client-gql'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.CopilotKitReactCore = {}), global.React,global.CopilotKitCore,global.AgUIClient,global.CopilotKitShared,global.ReactJsxRuntime,global._ag_ui_core,global.Zod,global.CopilotKitMcpAppsRendererActivity,global.CopilotKitA2UIRenderer,global.zod_to_json_schema,global._a2ui_web_core_v0_9,global.ReactDOM,global.ReactMarkdown,global.CopilotKitRuntimeClientGQL));
+})(this, function(exports, react, _copilotkit_core, _ag_ui_client, _copilotkit_shared, react_jsx_runtime, _ag_ui_core, zod, _copilotkit_mcp_apps_renderer_activity, _copilotkit_a2ui_renderer, zod_to_json_schema, _a2ui_web_core_v0_9, react_dom, react_markdown, _copilotkit_runtime_client_gql) {
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 //#region \0rolldown/runtime.js
 	var __create = Object.create;
@@ -615,7 +615,7 @@ react_markdown = __toESM(react_markdown);
 
 //#endregion
 //#region package.json
-	var version = "1.80.0";
+	var version = "1.81.0";
 
 //#endregion
 //#region src/v2/components/CopilotKitInspector.tsx
@@ -1888,7 +1888,7 @@ react_markdown = __toESM(react_markdown);
 				const groupedOperations = (0, react.useMemo)(() => {
 					const groups = /* @__PURE__ */ new Map();
 					for (const operation of operations) {
-						const surfaceId = getOperationSurfaceId(operation) ?? _copilotkit_a2ui_renderer.DEFAULT_SURFACE_ID;
+						const surfaceId = getOperationSurfaceId$1(operation) ?? _copilotkit_a2ui_renderer.DEFAULT_SURFACE_ID;
 						if (!groups.has(surfaceId)) groups.set(surfaceId, []);
 						groups.get(surfaceId).push(operation);
 					}
@@ -2110,7 +2110,7 @@ react_markdown = __toESM(react_markdown);
 	* @param operation - One A2UI operation, of any shape.
 	* @returns The surface id, or null when the operation names none.
 	*/
-	function getOperationSurfaceId(operation) {
+	function getOperationSurfaceId$1(operation) {
 		if (!operation || typeof operation !== "object") return null;
 		const nested = operation?.createSurface?.surfaceId ?? operation?.updateComponents?.surfaceId ?? operation?.updateDataModel?.surfaceId ?? operation?.deleteSurface?.surfaceId;
 		if (typeof nested === "string") return nested;
@@ -2223,6 +2223,4452 @@ react_markdown = __toESM(react_markdown);
 		return null;
 	}
 
+//#endregion
+//#region src/v2/generative-ui/action-message.ts
+/** Context keys that supply the message's first line, in priority order. */
+	const TEXT_KEYS = ["message", "label"];
+	function isNonEmptyString(value) {
+		return typeof value === "string" && value.trim().length > 0;
+	}
+	/** `choose_plan`, `choose-plan` and `choosePlan` all become "Choose plan". */
+	function humanize(name) {
+		const spaced = name.replace(/[_-]+/g, " ").replace(/([a-z])([A-Z])/g, "$1 $2").trim();
+		return spaced.charAt(0).toUpperCase() + spaced.slice(1).toLowerCase();
+	}
+	function formatContextValue(value) {
+		return typeof value === "object" ? JSON.stringify(value) : String(value);
+	}
+	/**
+	* Turns a user event that no function handles into the text of a visible
+	* user message.
+	*
+	* The first line is, in order: `userMessage`, `context.message`,
+	* `context.label`, the label of the source component (from `resolveLabel`),
+	* or the event name made readable (`choose_plan` becomes "Choose plan").
+	* Each other context field follows as one `key: value` line. Objects are
+	* written as JSON. `null` and `undefined` fields are skipped.
+	*
+	* @param event - The user event, as sent by a surface.
+	* @param resolveLabel - Finds the visible label of a component by id. Build
+	*   one with {@link createComponentLabelResolver}.
+	*
+	* @example
+	* ```ts
+	* buildActionMessageText({
+	*   name: "choose_plan",
+	*   surfaceId: "plans",
+	*   componentId: "team-button",
+	*   userMessage: "I pick the Team plan",
+	*   context: { seats: 12 },
+	* });
+	* // "I pick the Team plan\n\nseats: 12"
+	* ```
+	*/
+	function buildActionMessageText(event, resolveLabel) {
+		const { context, userMessage } = event;
+		const explicit = [userMessage, ...TEXT_KEYS.map((key) => context[key])].find(isNonEmptyString);
+		const resolved = explicit ? void 0 : resolveLabel?.(event.componentId);
+		const head = explicit ?? (isNonEmptyString(resolved) ? resolved.trim() : humanize(event.name));
+		const lines = Object.entries(context).filter(([key, value]) => !TEXT_KEYS.includes(key) && value !== void 0 && value !== null).map(([key, value]) => `${key}: ${formatContextValue(value)}`);
+		return lines.length > 0 ? `${head}\n\n${lines.join("\n")}` : head;
+	}
+	function ownText(component) {
+		if (!component) return void 0;
+		if (isNonEmptyString(component.label)) return component.label;
+		if (isNonEmptyString(component.text)) return component.text;
+	}
+	function childIds(component) {
+		const { child, children } = component;
+		const single = typeof child === "string" ? [child] : [];
+		const multiple = Array.isArray(children) ? children.filter((id) => typeof id === "string") : [];
+		return [...single, ...multiple];
+	}
+	/** The components that an operation adds, inline or in an update. */
+	function componentsOf(operation) {
+		if ("createSurface" in operation) return operation.createSurface.components ?? [];
+		if ("updateComponents" in operation) return operation.updateComponents.components;
+		return [];
+	}
+	/**
+	* Builds a function that finds the visible label of a component on a surface.
+	*
+	* The label is the component's own string `label`, else its string `text`,
+	* else the first `child` or `children` component that has a string `label`
+	* or `text`. When a component id is defined more than once, the last
+	* definition wins, as in the renderer.
+	*
+	* @param operations - The committed operations of the surface.
+	*
+	* @example
+	* ```ts
+	* const resolveLabel = createComponentLabelResolver(surface.operations);
+	* buildActionMessageText(event, resolveLabel);
+	* ```
+	*/
+	function createComponentLabelResolver(operations) {
+		const byId = /* @__PURE__ */ new Map();
+		for (const operation of operations) {
+			const components = componentsOf(operation);
+			for (const component of components) byId.set(component.id, component);
+		}
+		return (componentId) => {
+			const component = byId.get(componentId);
+			if (!component) return void 0;
+			const own = ownText(component);
+			if (own) return own;
+			const ids = childIds(component);
+			for (const id of ids) {
+				const text = ownText(byId.get(id));
+				if (text) return text;
+			}
+		};
+	}
+
+//#endregion
+//#region src/v2/generative-ui/json-schema.ts
+/**
+	* JSON Schema for a Standard Schema (zod v3 via zod-to-json-schema),
+	* inlined, no `$schema`. A prop marked by `child()` or `childList()`
+	* becomes an A2UI `$ref` to `ComponentId` or `ChildList`.
+	*/
+	function toJsonSchema(schema) {
+		const { $schema: _omit, ...rest } = (0, _copilotkit_shared.schemaToJsonSchema)(schema, { zodToJsonSchema: (s) => (0, zod_to_json_schema.zodToJsonSchema)(s, { $refStrategy: "none" }) });
+		return (0, _copilotkit_shared.applyChildRefMarks)(rest);
+	}
+
+//#endregion
+//#region src/v2/generative-ui/catalog.ts
+/** The A2UI component envelope: `id`, `component`, `catalogId`, `accessibility`, `metadata`. */
+	const RESERVED_KEYS = new Set([
+		"id",
+		"component",
+		..._copilotkit_shared.A2UI_COMPONENT_ENVELOPE_KEYS
+	]);
+	/** The id of the catalog that declared each component, for the inspector. */
+	const componentCatalogs = /* @__PURE__ */ new WeakMap();
+	/**
+	* 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.
+	*/
+	function componentCatalogIds(ui) {
+		return componentCatalogs.get(ui) ?? /* @__PURE__ */ new Map();
+	}
+	/**
+	* The catalogs that an operation can name: the id of `ui`, then the ids of
+	* the catalogs in its `extends` that declared a component. Not exported
+	* from the package.
+	*/
+	function catalogIdsOf(ui) {
+		const declared = componentCatalogs.get(ui)?.values() ?? [];
+		return [...new Set([ui.id, ...declared])];
+	}
+	/** The setter prop of a writable prop: `value` gives `setValue`. */
+	function setterNameOf(key) {
+		return `set${key.charAt(0).toUpperCase()}${key.slice(1)}`;
+	}
+
+//#endregion
+//#region src/v2/generative-ui/manifest.ts
+/**
+	* The built-in functions (the A2UI basic catalog plus calc and series) as
+	* manifest entries. Their args are described by the short signature, not
+	* by a full JSON Schema: the renderer checks them when they run. An app
+	* function of the same name replaces the entry.
+	*/
+	function builtInFunctionManifests() {
+		return Object.fromEntries(Object.entries(_copilotkit_shared.GENERATIVE_UI_FUNCTIONS).map(([name, fn]) => [name, {
+			description: fn.description,
+			parameters: {
+				type: "object",
+				description: fn.parameters
+			},
+			returnType: fn.returnType,
+			allowedCallers: fn.allowedCallers,
+			...fn.requiresUserActivation ? { requiresUserActivation: true } : {}
+		}]));
+	}
+	/**
+	* Builds the per-run manifest. Never contains handlers or renderers.
+	*
+	* - `functions`: the built-in functions, then the declared functions with
+	*   exactly one mounted handler.
+	* - `targets`: the chat first, then each mounted `<GenerativeUISurface>`,
+	*   with its `description` and its `components` when it has them.
+	*/
+	function buildGenerativeUIManifest(runtime, threadId) {
+		const { ui, manager, dispatcher } = runtime;
+		const inlineTargets = manager.getMountedTargets().filter((target) => target.id !== _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET).map(({ id, ...rest }) => ({
+			id,
+			kind: "inline",
+			...rest
+		}));
+		return {
+			catalogId: ui.id,
+			catalogIds: catalogIdsOf(ui),
+			components: ui.manifestComponents,
+			functions: {
+				...Object.fromEntries(Object.entries(builtInFunctionManifests()).filter(([name]) => !ui.functions.has(name))),
+				...dispatcher.listExposed()
+			},
+			targets: [{
+				id: _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET,
+				kind: "chat"
+			}, ...inlineTargets],
+			surfaces: threadId ? manager.describeSurfaces(threadId) : {}
+		};
+	}
+	/**
+	* Builds the envelope that a run sends as `forwardedProps.copilotkit.ui`,
+	* from the per-run manifest. It has the A2UI v1.0 renderer capabilities
+	* shape: one inline catalog with the id of the UI, and the CopilotKit data
+	* in `metadata.extensions`.
+	*
+	* The inline catalog has no `components` only for the markdown transport
+	* with `includeCatalog: false`. It has `instructions` for the markdown
+	* transport, or when given.
+	*
+	* @param runtime - The generative UI runtime of the provider.
+	* @param threadId - The thread of the run. Its surfaces go in `copilotkit_surfaces`.
+	* @param options - The transport and what to send.
+	*
+	* @example
+	* ```ts
+	* const envelope = buildGenerativeUIEnvelope(runtime, agent.threadId, {
+	*   transport: "tool",
+	*   includeCatalog: true,
+	*   contextSent: false,
+	* });
+	* envelope["v1.0"].supportedCatalogIds; // [runtime.ui.id]
+	* ```
+	*/
+	function buildGenerativeUIEnvelope(runtime, threadId, options) {
+		const { transport, includeCatalog, contextSent, action } = options;
+		const manifest = buildGenerativeUIManifest(runtime, threadId);
+		const instructions = options.instructions ?? (transport === "markdown" ? (0, _copilotkit_shared.buildGenerativeUIMarkdownGuidelines)((0, _copilotkit_shared.generativeUIGuideFeatures)(manifest)) : void 0);
+		const omitComponents = transport === "markdown" && !includeCatalog;
+		return {
+			"v1.0": {
+				supportedCatalogIds: manifest.catalogIds ?? [manifest.catalogId],
+				inlineCatalogs: [{
+					catalogId: manifest.catalogId,
+					protocolVersion: "1.0",
+					...omitComponents ? {} : { components: manifest.components },
+					functions: manifest.functions,
+					...instructions === void 0 ? {} : { instructions }
+				}]
+			},
+			metadata: { extensions: {
+				copilotkit_format: _copilotkit_shared.COPILOTKIT_UI_ENVELOPE_FORMAT,
+				copilotkit_transport: transport,
+				copilotkit_targets: manifest.targets,
+				copilotkit_surfaces: manifest.surfaces,
+				copilotkit_contextSent: contextSent,
+				...action === void 0 ? {} : { copilotkit_action: action }
+			} }
+		};
+	}
+
+//#endregion
+//#region src/v2/generative-ui/is-record.ts
+/** True for a plain object: not null, not an array. Internal, not exported. */
+	function isRecord(value) {
+		return typeof value === "object" && value !== null && !Array.isArray(value);
+	}
+
+//#endregion
+//#region src/v2/generative-ui/markdown/context.ts
+/** Objects nested deeper than this show as `object`. */
+	const MAX_OBJECT_DEPTH = 2;
+	/** A prop must appear verbatim in at least this many components to be hoisted. */
+	const COMMON_PROP_MIN_COMPONENTS = 8;
+	/** A JSON Schema of a list of schemas (`anyOf`, `oneOf`), else an empty list. */
+	function schemaList(value) {
+		return Array.isArray(value) ? value.filter(isRecord) : [];
+	}
+	/**
+	* Puts a top-level union in parentheses, so that `[]` applies to all of
+	* it. A union inside braces needs none.
+	*/
+	function asArrayItem(type) {
+		let outside = type;
+		for (let inner = outside.replace(/\{[^{}]*\}/g, ""); inner !== outside;) {
+			outside = inner;
+			inner = outside.replace(/\{[^{}]*\}/g, "");
+		}
+		return outside.includes(" | ") ? `(${type})[]` : `${type}[]`;
+	}
+	/**
+	* A JSON Schema as a short TypeScript-like type, for example
+	* `{ label: string; size?: "sm" | "md" }`.
+	*/
+	function compactType(schema, depth) {
+		const ref = (0, _copilotkit_shared.childRefKind)(schema);
+		if (ref === "single") return "componentId";
+		if (ref === "multiple") return "componentId[] | { componentId: string; path: string }";
+		if ("const" in schema) return JSON.stringify(schema.const);
+		if (Array.isArray(schema.enum)) return schema.enum.map((value) => JSON.stringify(value)).join(" | ");
+		const variants = [...schemaList(schema.anyOf), ...schemaList(schema.oneOf)];
+		if (variants.length > 0) return variants.map((variant) => compactType(variant, depth)).join(" | ");
+		return (Array.isArray(schema.type) ? schema.type : [schema.type]).map((type) => {
+			switch (type) {
+				case "string":
+				case "boolean":
+				case "null": return type;
+				case "number":
+				case "integer": return "number";
+				case "array": return isRecord(schema.items) ? asArrayItem(compactType(schema.items, depth)) : "unknown[]";
+				case "object": return compactObject(schema, depth);
+				default: return "unknown";
+			}
+		}).join(" | ");
+	}
+	/** An object schema as `{ key: type; other?: type }`. */
+	function compactObject(schema, depth) {
+		const properties = isRecord(schema.properties) ? schema.properties : {};
+		const entries = Object.entries(properties);
+		if (entries.length === 0) return isRecord(schema.additionalProperties) ? `Record<string, ${compactType(schema.additionalProperties, depth + 1)}>` : "object";
+		if (depth >= MAX_OBJECT_DEPTH) return "object";
+		const required = Array.isArray(schema.required) ? schema.required : [];
+		return `{ ${entries.map(([key, value]) => {
+			const type = isRecord(value) ? compactType(value, depth + 1) : "unknown";
+			return `${key}${required.includes(key) ? "" : "?"}: ${type}`;
+		}).join("; ")} }`;
+	}
+	/** A schema as its type, with its description after `//`. */
+	function describedType(schema, depth) {
+		const type = compactType(schema, depth);
+		return typeof schema.description === "string" ? `${type} // ${schema.description}` : type;
+	}
+	/** The props of a component: `{ "label": "string", "size?": "..." }`. */
+	function compactProps(schema) {
+		const properties = isRecord(schema.properties) ? schema.properties : {};
+		const required = Array.isArray(schema.required) ? schema.required : [];
+		const props = {};
+		for (const [key, value] of Object.entries(properties)) {
+			if (!isRecord(value)) continue;
+			const name = required.includes(key) ? key : `${key}?`;
+			props[name] = describedType(value, 1);
+		}
+		return props;
+	}
+	/**
+	* The prop set worth listing once. Candidates are (key, type) pairs that at
+	* least {@link COMMON_PROP_MIN_COMPONENTS} components carry verbatim. The
+	* candidate subset of each component is a possible common set, scored by
+	* the characters it saves (set size times the components that contain all
+	* of it). `undefined` when no set is shared by enough components.
+	*/
+	function findCommonProps(propsList) {
+		const pairKey = (key, type) => `${key}\u0000${type}`;
+		const counts = /* @__PURE__ */ new Map();
+		for (const props of propsList) for (const [key, type] of Object.entries(props)) {
+			const id = pairKey(key, type);
+			counts.set(id, (counts.get(id) ?? 0) + 1);
+		}
+		let best;
+		let bestScore = 0;
+		const seen = /* @__PURE__ */ new Set();
+		for (const props of propsList) {
+			const subset = Object.entries(props).filter(([key, type]) => (counts.get(pairKey(key, type)) ?? 0) >= COMMON_PROP_MIN_COMPONENTS);
+			if (subset.length < 2) continue;
+			const signature = subset.map(([key, type]) => pairKey(key, type)).join("\n");
+			if (seen.has(signature)) continue;
+			seen.add(signature);
+			const members = propsList.filter((other) => subset.every(([key, type]) => other[key] === type)).length;
+			if (members < COMMON_PROP_MIN_COMPONENTS) continue;
+			const score = subset.reduce((total, [key, type]) => total + key.length + type.length, 0) * (members - 1);
+			if (score > bestScore) {
+				bestScore = score;
+				best = Object.fromEntries(subset);
+			}
+		}
+		return best;
+	}
+	/**
+	* The component schema of the markdown transport, from the per-run
+	* manifest. It is smaller than the manifest: each prop is one short type,
+	* and the props that many components share verbatim (the layout props of
+	* the containers) are listed once in `commonProps`; a component that takes
+	* them is flagged `includesCommonProps`.
+	* It has the catalog id, the targets with their descriptions and their
+	* component lists, the functions with their parameters, the components
+	* with their props, events and slots, and the surfaces of the thread. A surface lists the
+	* values that the user set and the operations that the client dropped.
+	*
+	* @param manifest - The manifest from `buildGenerativeUIManifest`.
+	* @returns A JSON-ready object.
+	*
+	* @example
+	* ```ts
+	* const value = JSON.stringify(
+	*   buildCompactGenerativeUISchema(buildGenerativeUIManifest(runtime, threadId)),
+	* );
+	* ```
+	*/
+	function buildCompactGenerativeUISchema(manifest) {
+		const components = {};
+		for (const [name, component] of Object.entries(manifest.components)) {
+			const events = Object.entries(component.events ?? {}).map(([event, definition]) => [event, definition.description ?? compactType(definition.parameters, 0)]);
+			components[name] = {
+				...component.description ? { description: component.description } : {},
+				props: compactProps(component.props),
+				...events.length > 0 ? { events: Object.fromEntries(events) } : {},
+				...component.slots ? { slots: component.slots } : {}
+			};
+		}
+		const common = findCommonProps(Object.values(components).map((component) => component.props));
+		if (common) {
+			const commonKeys = Object.keys(common);
+			for (const component of Object.values(components)) {
+				if (!commonKeys.every((key) => component.props[key] === common[key])) continue;
+				component.includesCommonProps = true;
+				component.props = Object.fromEntries(Object.entries(component.props).filter(([key]) => !(key in common)));
+			}
+		}
+		const functions = Object.fromEntries(Object.entries(manifest.functions).map(([name, fn]) => {
+			const signature = fn.parameters.description;
+			const hasSignature = typeof signature === "string" && signature.startsWith("{") && Object.keys(fn.parameters).length === 2;
+			const callers = (0, _copilotkit_shared.functionCallers)(fn);
+			return [name, {
+				...fn.description ? { description: fn.description } : {},
+				parameters: hasSignature ? signature : compactType(fn.parameters, 0),
+				...callers.agent && _copilotkit_shared.GENERATIVE_UI_AGENT_FUNCTION_CALLS ? { callers: callers.renderer ? "UI or agent" : "agent only" } : {}
+			}];
+		}));
+		return {
+			catalogId: manifest.catalogId,
+			targets: manifest.targets,
+			functions,
+			...common ? { commonProps: common } : {},
+			components,
+			surfaces: manifest.surfaces
+		};
+	}
+	/**
+	* Registers the two context entries of the markdown transport: the compact
+	* component schema and the fence guideline. Both go only to `agentIds`.
+	*
+	* The schema is built again at each run start and when a
+	* `<GenerativeUISurface>` mounts, unmounts, or changes its description or
+	* its components, so its targets, functions, and surfaces stay current. The surfaces are those of the running thread.
+	*
+	* @param copilotkit - The CopilotKit core of the provider.
+	* @param runtime - The generative UI runtime parts, or null without one.
+	* @param options - `enabled` and `agentIds`.
+	*
+	* @example
+	* ```ts
+	* useGenerativeUIMarkdownContext(copilotkit, core, {
+	*   enabled: config?.transport === "markdown" && config.sendContext !== false,
+	*   agentIds: config?.agentIds,
+	* });
+	* ```
+	*/
+	function useGenerativeUIMarkdownContext(copilotkit, runtime, options) {
+		const { enabled, agentIds } = options;
+		const agentIdsKey = agentIds === void 0 ? "" : JSON.stringify(agentIds);
+		(0, react.useEffect)(() => {
+			if (!runtime || !enabled) return;
+			const scopedAgentIds = agentIdsKey ? JSON.parse(agentIdsKey) : void 0;
+			const scope = scopedAgentIds ? { agentIds: scopedAgentIds } : {};
+			let guidelineId;
+			let guidelineValue;
+			let schemaId;
+			let schemaValue;
+			const refreshSchema = (threadId) => {
+				const manifest = buildGenerativeUIManifest(runtime, threadId);
+				const guideline = (0, _copilotkit_shared.buildGenerativeUIMarkdownGuidelines)((0, _copilotkit_shared.generativeUIGuideFeatures)(manifest));
+				if (guideline !== guidelineValue) {
+					if (guidelineId !== void 0) copilotkit.removeContext(guidelineId);
+					guidelineValue = guideline;
+					guidelineId = copilotkit.addContext({
+						description: _copilotkit_shared.GENERATIVE_UI_MARKDOWN_GUIDELINES_DESCRIPTION,
+						value: guideline,
+						...scope
+					});
+				}
+				const value = JSON.stringify(buildCompactGenerativeUISchema(manifest));
+				if (value === schemaValue) return;
+				if (schemaId !== void 0) copilotkit.removeContext(schemaId);
+				schemaValue = value;
+				schemaId = copilotkit.addContext({
+					description: _copilotkit_shared.GENERATIVE_UI_MARKDOWN_SCHEMA_CONTEXT_DESCRIPTION,
+					value,
+					...scope
+				});
+			};
+			refreshSchema(runtime.manager.getActiveThread());
+			let targetsKey = JSON.stringify(runtime.manager.getMountedTargets());
+			const unsubscribeManager = runtime.manager.subscribe(() => {
+				const nextKey = JSON.stringify(runtime.manager.getMountedTargets());
+				if (nextKey === targetsKey) return;
+				targetsKey = nextKey;
+				refreshSchema(runtime.manager.getActiveThread());
+			});
+			const subscription = copilotkit.subscribe({ onAgentRunStarted: ({ agent }) => refreshSchema(agent.threadId) });
+			return () => {
+				subscription.unsubscribe();
+				unsubscribeManager();
+				if (guidelineId !== void 0) copilotkit.removeContext(guidelineId);
+				if (schemaId !== void 0) copilotkit.removeContext(schemaId);
+			};
+		}, [
+			copilotkit,
+			runtime,
+			enabled,
+			agentIdsKey
+		]);
+	}
+
+//#endregion
+//#region src/v2/generative-ui/debug-source.ts
+/**
+	* What a run of `threadId` sends: its envelope, and the text that goes into
+	* the prompt of the model because of it.
+	*
+	* - Tool transport: the runtime adds the `render_ui` guide. It builds it
+	*   from the envelope with `buildGenerativeUIPrompt`, as done here.
+	* - Markdown transport: the provider sends the guideline and the compact
+	*   schema as context entries. With `sendContext: false`, the backend builds
+	*   its own prompt, usually from the `instructions` of the envelope.
+	*/
+	function describeGenerativeUIRun(runtime, threadId, options) {
+		const envelope = buildGenerativeUIEnvelope(runtime, threadId, options);
+		if (options.transport === "tool") return {
+			envelope,
+			prompt: [{
+				title: "render_ui guide",
+				source: "runtime",
+				text: (0, _copilotkit_shared.buildGenerativeUIPrompt)((0, _copilotkit_shared.envelopeToManifest)(envelope))
+			}]
+		};
+		const manifest = buildGenerativeUIManifest(runtime, threadId);
+		if (!options.contextSent) return {
+			envelope,
+			prompt: [{
+				title: "Envelope instructions",
+				source: "backend",
+				text: (0, _copilotkit_shared.envelopeToManifest)(envelope).instructions ?? ""
+			}]
+		};
+		const guideline = (0, _copilotkit_shared.buildGenerativeUIMarkdownGuidelines)((0, _copilotkit_shared.generativeUIGuideFeatures)(manifest));
+		const schema = JSON.stringify(buildCompactGenerativeUISchema(manifest));
+		return {
+			envelope,
+			prompt: [{
+				title: "Markdown guideline",
+				source: "context",
+				text: guideline
+			}, {
+				title: "Component schema",
+				source: "context",
+				text: schema
+			}]
+		};
+	}
+	/** The declared functions, with the JSON Schema of their parameters. */
+	function debugFunctions(runtime) {
+		const functions = {};
+		for (const [name, declared] of runtime.ui.functions) {
+			let parameters = {};
+			try {
+				parameters = toJsonSchema(declared.parameters);
+			} catch {}
+			functions[name] = {
+				...declared.description ? { description: declared.description } : {},
+				parameters,
+				handlers: runtime.dispatcher.handlerCount(name)
+			};
+		}
+		return functions;
+	}
+	/**
+	* The debug source that the provider gives core for the inspector. It builds
+	* a snapshot only when the inspector reads one.
+	*
+	* @param runtime - The generative UI parts of the provider.
+	* @param getOptions - The envelope options and agent ids of the current config.
+	* @returns The source, and `recordRun` for each run start.
+	*/
+	function createGenerativeUIDebugSource(runtime, getOptions) {
+		const listeners = /* @__PURE__ */ new Set();
+		let lastRun;
+		const notify = () => {
+			for (const listener of [...listeners]) listener();
+		};
+		return {
+			source: {
+				getSnapshot() {
+					const { options, agentIds } = getOptions();
+					const threadId = runtime.manager.getActiveThread();
+					const manifest = buildGenerativeUIManifest(runtime, threadId);
+					return {
+						catalogId: runtime.ui.id,
+						transport: options.transport,
+						...agentIds ? { agentIds } : {},
+						components: runtime.ui.manifestComponents,
+						componentCatalogs: Object.fromEntries(componentCatalogIds(runtime.ui)),
+						functions: debugFunctions(runtime),
+						state: { ...runtime.manager.getState() },
+						targets: manifest.targets,
+						activeThreadId: threadId,
+						surfaces: runtime.manager.debugSurfaces(),
+						lastRun,
+						nextRun: {
+							agentId: void 0,
+							threadId,
+							...describeGenerativeUIRun(runtime, threadId, options)
+						}
+					};
+				},
+				subscribe(listener) {
+					listeners.add(listener);
+					const unsubscribe = runtime.manager.subscribe(listener);
+					return () => {
+						listeners.delete(listener);
+						unsubscribe();
+					};
+				}
+			},
+			recordRun(run) {
+				lastRun = run;
+				notify();
+			}
+		};
+	}
+
+//#endregion
+//#region src/v2/generative-ui/errors.ts
+	var GenerativeUIError = class extends Error {
+		constructor(code, message) {
+			super(message);
+			this.name = "GenerativeUIError";
+			this.code = code;
+		}
+	};
+
+//#endregion
+//#region src/v2/generative-ui/functions.ts
+/**
+	* The renderer-side functions of the A2UI 1.0 basic catalog. Each one takes
+	* resolved args (no bindings left in them) and gives a plain value. They
+	* run synchronously, so a prop bound to one updates in the same render as
+	* the data it reads. The signatures the model sees are in
+	* `@copilotkit/shared` (`A2UI_BASIC_FUNCTIONS`).
+	*/
+	/** Thrown for a bad call: an unknown function, bad args, or a bad value. */
+	var ExpressionError = class extends Error {
+		constructor(message) {
+			super(message);
+			this.name = "ExpressionError";
+		}
+	};
+	/** The boolean of a DynamicBoolean: a ValidationResult counts as `valid`. */
+	function truthOf(value) {
+		if ((0, _copilotkit_shared.isValidationResult)(value)) return value.valid;
+		return Boolean(value);
+	}
+	const valid = () => ({ valid: true });
+	/** A failed result. `code` names the failure, the same for every locale. */
+	const invalid = (message, code) => ({
+		valid: false,
+		message,
+		code
+	});
+	function text(value) {
+		if (value === void 0 || value === null) return "";
+		return typeof value === "string" ? value : String(value);
+	}
+	function numberOf$1(value) {
+		if (typeof value === "number") return value;
+		if (typeof value === "string" && value.trim() !== "") return Number(value);
+		return NaN;
+	}
+	function optionalNumber(value, name) {
+		if (value === void 0 || value === null) return void 0;
+		const parsed = numberOf$1(value);
+		if (Number.isNaN(parsed)) throw new ExpressionError(`${name} must be a number`);
+		return parsed;
+	}
+	const EMAIL = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+	/** The locale of the user. `undefined` lets Intl pick the default. */
+	function locale() {
+		return typeof navigator !== "undefined" ? navigator.language : void 0;
+	}
+	function numberFormat(args, options) {
+		const decimals = optionalNumber(args.decimals, "decimals");
+		return new Intl.NumberFormat(locale(), {
+			...options,
+			useGrouping: args.grouping !== false,
+			...decimals === void 0 ? {} : {
+				minimumFractionDigits: decimals,
+				maximumFractionDigits: decimals
+			}
+		});
+	}
+	/** A date from an ISO string, a timestamp, or a Date. */
+	function dateOf(value) {
+		const date = value instanceof Date ? value : typeof value === "number" ? new Date(value) : typeof value === "string" ? new Date(/^\d{4}-\d{2}-\d{2}$/.test(value) ? `${value}T00:00` : value) : void 0;
+		if (date === void 0 || Number.isNaN(date.getTime())) throw new ExpressionError("value must be a date");
+		return date;
+	}
+	const pad = (value, width) => String(value).padStart(width, "0");
+	/**
+	* A TR35 field is a run of one letter ("EEE" is one abbreviated weekday,
+	* not three), and text in single quotes is literal. Letters that are not
+	* fields stay as they are.
+	*/
+	const DATE_FIELD = /([A-Za-z])\1*|'(?:[^']|'')*'/g;
+	function formatDatePattern(date, pattern) {
+		const parts = (options) => new Intl.DateTimeFormat(locale(), options).format(date);
+		const hours12 = date.getHours() % 12 || 12;
+		const numeric = (value, width) => width >= 2 ? pad(value, 2) : String(value);
+		return pattern.replace(DATE_FIELD, (token) => {
+			if (token.startsWith("'")) return token.slice(1, -1).replace(/''/g, "'");
+			const width = token.length;
+			switch (token[0]) {
+				case "y": return width === 2 ? pad(date.getFullYear() % 100, 2) : String(date.getFullYear());
+				case "M":
+					if (width >= 4) return parts({ month: "long" });
+					if (width === 3) return parts({ month: "short" });
+					return numeric(date.getMonth() + 1, width);
+				case "d": return numeric(date.getDate(), width);
+				case "E": return parts({ weekday: width >= 4 ? "long" : "short" });
+				case "H": return numeric(date.getHours(), width);
+				case "h": return numeric(hours12, width);
+				case "m": return pad(date.getMinutes(), 2);
+				case "s": return pad(date.getSeconds(), 2);
+				case "a": return date.getHours() < 12 ? "AM" : "PM";
+				default: return token;
+			}
+		});
+	}
+	/** Opens an http(s) URL in a new tab. Any other scheme is refused. */
+	function openUrlSafely(url) {
+		if (typeof url !== "string" || url === "") throw new ExpressionError("url must be a string");
+		if (typeof window === "undefined") return;
+		let parsed;
+		try {
+			parsed = new URL(url, window.location.href);
+		} catch {
+			throw new ExpressionError(`"${url}" is not a URL`);
+		}
+		if (parsed.protocol !== "https:" && parsed.protocol !== "http:") throw new ExpressionError(`openUrl takes only http(s) URLs, not ${parsed.protocol}`);
+		window.open(parsed.href, "_blank", "noopener,noreferrer");
+	}
+	/**
+	* The basic functions, except `formatString`, which needs the resolver.
+	* `calc` and `series` are added by `resolve.ts`, which imports both.
+	*/
+	const BASIC_FUNCTIONS = {
+		required: ({ value }) => {
+			return value === void 0 || value === null || value === "" || Array.isArray(value) && value.length === 0 ? invalid("Required", "required") : valid();
+		},
+		regex: ({ value, pattern }) => {
+			if (typeof pattern !== "string") throw new ExpressionError("pattern must be a string");
+			let expression;
+			try {
+				expression = new RegExp(pattern, "u");
+			} catch {
+				throw new ExpressionError(`"${pattern}" is not a regular expression`);
+			}
+			return expression.test(text(value)) ? valid() : invalid("Invalid format", "pattern");
+		},
+		length: ({ value, min, max }) => {
+			const size = text(value).length;
+			const low = optionalNumber(min, "min");
+			const high = optionalNumber(max, "max");
+			if (low !== void 0 && size < low) return invalid(`At least ${low} characters`, "tooShort");
+			if (high !== void 0 && size > high) return invalid(`At most ${high} characters`, "tooLong");
+			return valid();
+		},
+		numeric: ({ value, min, max }) => {
+			const parsed = numberOf$1(value);
+			if (Number.isNaN(parsed)) return invalid("Must be a number", "notANumber");
+			const low = optionalNumber(min, "min");
+			const high = optionalNumber(max, "max");
+			if (low !== void 0 && parsed < low) return invalid(`At least ${low}`, "tooSmall");
+			if (high !== void 0 && parsed > high) return invalid(`At most ${high}`, "tooLarge");
+			return valid();
+		},
+		email: ({ value }) => EMAIL.test(text(value)) ? valid() : invalid("Invalid email address", "email"),
+		formatNumber: (args) => {
+			const parsed = numberOf$1(args.value);
+			if (Number.isNaN(parsed)) throw new ExpressionError("value must be a number");
+			return numberFormat(args, {}).format(parsed);
+		},
+		formatCurrency: (args) => {
+			const parsed = numberOf$1(args.value);
+			if (Number.isNaN(parsed)) throw new ExpressionError("value must be a number");
+			if (typeof args.currency !== "string" || args.currency === "") throw new ExpressionError("currency must be an ISO 4217 code");
+			try {
+				return numberFormat(args, {
+					style: "currency",
+					currency: args.currency
+				}).format(parsed);
+			} catch {
+				throw new ExpressionError(`"${args.currency}" is not a currency code`);
+			}
+		},
+		formatDate: ({ value, format }) => {
+			if (typeof format !== "string") throw new ExpressionError("format must be a string");
+			return formatDatePattern(dateOf(value), format);
+		},
+		pluralize: (args) => {
+			const parsed = numberOf$1(args.value);
+			if (Number.isNaN(parsed)) throw new ExpressionError("value must be a number");
+			const category = new Intl.PluralRules(locale()).select(parsed);
+			return text((parsed === 0 ? args.zero : void 0) ?? args[category] ?? args.other);
+		},
+		and: ({ values }) => {
+			if (!Array.isArray(values)) throw new ExpressionError("values must be a list");
+			return values.every(truthOf);
+		},
+		or: ({ values }) => {
+			if (!Array.isArray(values)) throw new ExpressionError("values must be a list");
+			return values.some(truthOf);
+		},
+		not: ({ value }) => !truthOf(value),
+		openUrl: ({ url }) => {
+			openUrlSafely(url);
+		}
+	};
+	/** True when the basic function `name` must run from a user gesture. */
+	function requiresUserActivation(name) {
+		return _copilotkit_shared.GENERATIVE_UI_FUNCTIONS[name]?.requiresUserActivation === true;
+	}
+	/** True when a basic function gives a ValidationResult. */
+	function givesValidationResult(name) {
+		return _copilotkit_shared.GENERATIVE_UI_FUNCTIONS[name]?.returnType === "validationResult";
+	}
+
+//#endregion
+//#region src/v2/generative-ui/dispatcher.ts
+	const messageOf = (error) => error instanceof Error ? error.message : String(error);
+	/**
+	* Creates the registry of functions that generated UI may call.
+	*
+	* A function is callable when it is declared in `getDeclared()` and exactly
+	* one handler is mounted for it with `register`. Names are resolved at call
+	* time and fail closed. Nothing is sent to the agent.
+	* Neither `invoke` nor `listExposed` throws.
+	*
+	* @param options.getDeclared - Returns the declared functions.
+	* @param options.onError - Gets each failed call.
+	*
+	* @example
+	* ```ts
+	* const dispatcher = createGenerativeUIDispatcher({
+	*   getDeclared: () => new Map(Object.entries(ui.functions)),
+	* });
+	* const unregister = dispatcher.register("addToCart", handlerRef);
+	* await dispatcher.invoke("addToCart", { productId: "p1" }, origin);
+	* unregister();
+	* ```
+	*/
+	/**
+	* True while the browser counts the current task as user-activated (a
+	* click, a key press). Where the API is missing (older browsers, test
+	* environments), the gesture is assumed.
+	*/
+	function hasUserActivation() {
+		if (typeof navigator === "undefined") return true;
+		const activation = navigator.userActivation;
+		return activation === void 0 || activation.isActive;
+	}
+	/**
+	* The permissions of a declared function as the manifest states them: the
+	* callers always written out, so a reader needs no default.
+	*/
+	function permissionsOf(fn) {
+		const callers = (0, _copilotkit_shared.functionCallers)(fn);
+		return {
+			allowedCallers: callers.renderer && callers.agent ? "rendererOrAgent" : callers.agent ? "agentOnly" : "rendererOnly",
+			...fn.requiresUserActivation ? { requiresUserActivation: true } : {}
+		};
+	}
+	function createGenerativeUIDispatcher(options) {
+		const handlers = /* @__PURE__ */ new Map();
+		const resolveUnchecked = (name) => {
+			const declared = options.getDeclared().get(name);
+			if (!declared) return {
+				ok: false,
+				error: new GenerativeUIError("function_not_found", `No generative UI function named "${name}" is declared in createGenerativeUI({ functions })`)
+			};
+			const mounted = [...handlers.get(name) ?? []];
+			const [ref] = mounted;
+			if (!ref) return {
+				ok: false,
+				error: new GenerativeUIError("function_not_found", `"${name}" is declared, but no useGenerativeUIFunction handler is mounted for it`)
+			};
+			if (mounted.length > 1) return {
+				ok: false,
+				error: new GenerativeUIError("function_conflict", `"${name}" has ${mounted.length} useGenerativeUIFunction handlers mounted. Mount exactly one.`)
+			};
+			return {
+				ok: true,
+				declared,
+				ref
+			};
+		};
+		const isDeclared = (name) => {
+			try {
+				return options.getDeclared().has(name);
+			} catch {
+				return false;
+			}
+		};
+		const resolve = (name) => {
+			try {
+				return resolveUnchecked(name);
+			} catch (error) {
+				return {
+					ok: false,
+					error: new GenerativeUIError("handler_failed", `"${name}" could not be resolved: ${messageOf(error)}`)
+				};
+			}
+		};
+		const validateArgs = async (name, schema, args) => {
+			try {
+				const validation = await schema["~standard"].validate(args);
+				if (!validation.issues) return {
+					ok: true,
+					value: validation.value
+				};
+				return {
+					ok: false,
+					error: new GenerativeUIError("invalid_arguments", `Invalid arguments for "${name}": ${validation.issues.map((i) => `${(i.path ?? []).map((p) => typeof p === "object" ? p.key : p).join(".") || "args"}: ${i.message}`).join("; ")}`)
+				};
+			} catch (error) {
+				return {
+					ok: false,
+					error: new GenerativeUIError("invalid_arguments", `Invalid arguments for "${name}": ${messageOf(error)}`)
+				};
+			}
+		};
+		const failWith = (name, origin, error) => {
+			try {
+				options.onError?.({
+					name,
+					origin,
+					error
+				});
+			} catch {}
+			return {
+				ok: false,
+				error
+			};
+		};
+		/**
+		* Why `origin` may not call a function with these permissions now, as an
+		* error, or `undefined` when it may. The agent is refused what is for the
+		* renderer; a component is refused what is for the agent, and a gesture
+		* function when the browser counts no user activation.
+		*/
+		const callerError = (name, fn, origin) => {
+			const isComponent = "componentId" in origin;
+			if (!isComponent && !_copilotkit_shared.GENERATIVE_UI_AGENT_FUNCTION_CALLS) return new GenerativeUIError("invalid_function_call", _copilotkit_shared.GENERATIVE_UI_AGENT_FUNCTION_CALLS_OFF_REASON);
+			const problem = (0, _copilotkit_shared.callerProblem)(name, fn, isComponent ? "renderer" : "agent");
+			if (problem !== void 0) return new GenerativeUIError("invalid_function_call", problem);
+			if (isComponent && fn.requiresUserActivation && !hasUserActivation()) return new GenerativeUIError("invalid_function_call", `function "${name}" runs only from a user gesture; this event was not one`);
+		};
+		/**
+		* Runs a basic function of the A2UI catalog. They are value functions of
+		* the renderer: the agent cannot call them, and one that needs a user
+		* gesture runs only from an event binding.
+		*/
+		const invokeBasic = (name, args, origin) => {
+			const refused = callerError(name, _copilotkit_shared.GENERATIVE_UI_FUNCTIONS[name], origin);
+			if (refused) return failWith(name, origin, refused);
+			if (args !== void 0 && !(typeof args === "object" && args !== null && !Array.isArray(args))) return failWith(name, origin, new GenerativeUIError("invalid_arguments", `Invalid arguments for "${name}": args must be an object`));
+			try {
+				return {
+					ok: true,
+					result: BASIC_FUNCTIONS[name](args ?? {})
+				};
+			} catch (error) {
+				return failWith(name, origin, new GenerativeUIError(error instanceof ExpressionError ? "invalid_arguments" : "handler_failed", `"${name}" failed: ${messageOf(error)}`));
+			}
+		};
+		return {
+			async invoke(name, args, origin) {
+				const resolved = resolve(name);
+				if (!resolved.ok && resolved.error.code === "function_not_found" && !isDeclared(name) && Object.prototype.hasOwnProperty.call(BASIC_FUNCTIONS, name)) return invokeBasic(name, args, origin);
+				if (!resolved.ok) return failWith(name, origin, resolved.error);
+				const refused = callerError(name, resolved.declared, origin);
+				if (refused) return failWith(name, origin, refused);
+				const validated = await validateArgs(name, resolved.declared.parameters, args ?? {});
+				if (!validated.ok) return failWith(name, origin, validated.error);
+				try {
+					return {
+						ok: true,
+						result: await resolved.ref.current(validated.value)
+					};
+				} catch (error) {
+					return failWith(name, origin, new GenerativeUIError("handler_failed", `"${name}" failed: ${messageOf(error)}`));
+				}
+			},
+			listExposed() {
+				let names;
+				try {
+					names = [...options.getDeclared().keys()];
+				} catch {
+					return {};
+				}
+				const listed = {};
+				for (const name of names) {
+					const resolved = resolve(name);
+					if (!resolved.ok) continue;
+					if (!(0, _copilotkit_shared.functionCallers)(resolved.declared).renderer && !_copilotkit_shared.GENERATIVE_UI_AGENT_FUNCTION_CALLS) continue;
+					const { description, parameters, returnType } = resolved.declared;
+					try {
+						listed[name] = {
+							...description ? { description } : {},
+							parameters: toJsonSchema(parameters),
+							...returnType ? { returnType } : {},
+							...permissionsOf(resolved.declared)
+						};
+					} catch {}
+				}
+				return listed;
+			},
+			register(name, ref) {
+				const mounted = handlers.get(name) ?? /* @__PURE__ */ new Set();
+				mounted.add(ref);
+				handlers.set(name, mounted);
+				return () => {
+					mounted.delete(ref);
+				};
+			},
+			handlerCount: (name) => handlers.get(name)?.size ?? 0
+		};
+	}
+
+//#endregion
+//#region src/v2/generative-ui/markdown/source.ts
+/**
+	* Values by key, from the latest build. A value that a build does not use
+	* is dropped at the end of that build, so the cache does not grow.
+	*/
+	var BuildMemo = class {
+		constructor() {
+			this.previous = /* @__PURE__ */ new Map();
+			this.current = /* @__PURE__ */ new Map();
+		}
+		/**
+		* The value of `key`. It is computed when no earlier value is there, or
+		* when `isFresh` says that the earlier value is out of date.
+		*/
+		get(key, compute, isFresh = () => true) {
+			let value = this.current.get(key) ?? this.previous.get(key);
+			if (value === void 0 || !isFresh(value)) value = compute();
+			this.current.set(key, value);
+			return value;
+		}
+		endBuild() {
+			this.previous = this.current;
+			this.current = /* @__PURE__ */ new Map();
+		}
+	};
+	/** The results of the builds of one thread. See `BuildMarkdownSurfacesOptions.cache`. */
+	var MarkdownBuildCache = class {
+		constructor() {
+			this.segments = new BuildMemo();
+			this.fences = new BuildMemo();
+			this.drafts = new BuildMemo();
+			this.readdressed = /* @__PURE__ */ new WeakMap();
+		}
+		endBuild() {
+			this.segments.endBuild();
+			this.fences.endBuild();
+			this.drafts.endBuild();
+		}
+	};
+	/** True when both lists hold the same objects in the same order. */
+	function sameItems(a, b) {
+		return a.length === b.length && a.every((item, index) => item === b[index]);
+	}
+	function isString(value) {
+		return typeof value === "string";
+	}
+	/** The key of one fence of one message. */
+	function fenceKey(messageId, fenceIndex) {
+		return `${messageId}:${fenceIndex}`;
+	}
+	/**
+	* The operations of a fence body. While the fence streams, the last object
+	* can be unfinished. Of an unfinished updateComponents or createSurface, the
+	* components that are complete render at once (a createSurface also keeps
+	* its data model when all of it arrived). Any other unfinished object is
+	* left out, because a part of a data model value can still change. A final
+	* fence keeps what can be saved from an unfinished object.
+	*/
+	function fenceOperations(text, isStreaming) {
+		const parsed = (0, _copilotkit_core.extractFenceOperations)(text);
+		if (!isStreaming || parsed.partialObject === null) return parsed.operations;
+		const complete = (0, _copilotkit_core.extractFenceOperations)(text.slice(0, text.length - parsed.partialObject.length)).operations;
+		const partial = parsed.operations.length > complete.length ? parsed.operations[parsed.operations.length - 1] : void 0;
+		return partial !== void 0 && (isRecord(partial.updateComponents) || isRecord(partial.createSurface)) ? [...complete, partial] : complete;
+	}
+	/**
+	* An inline createSurface becomes a createSurface with only its surfaceId
+	* and catalog, then an updateDataModel for its data model, then an
+	* updateComponents for its components. The prose lift and the split per
+	* component read only updateComponents, so they then work for an inline
+	* surface too. A createSurface with a data model or components of a wrong
+	* shape does not change, so that validation rejects it with the reason.
+	*/
+	function expandInlineCreate(operations) {
+		return operations.flatMap((op) => {
+			const create = op.createSurface;
+			if (!isRecord(create)) return [op];
+			const { dataModel, components, ...rest } = create;
+			const hasData = isRecord(dataModel);
+			const hasComponents = Array.isArray(components) && components.length > 0;
+			if (!((dataModel === void 0 || hasData) && (components === void 0 || hasComponents)) || !hasData && !hasComponents) return [op];
+			const { surfaceId } = create;
+			const expanded = [{
+				...op,
+				createSurface: rest
+			}];
+			if (hasData) expanded.push({
+				version: op.version,
+				updateDataModel: {
+					surfaceId,
+					path: "/",
+					value: dataModel
+				}
+			});
+			if (hasComponents) expanded.push({
+				version: op.version,
+				updateComponents: {
+					surfaceId,
+					components
+				}
+			});
+			return expanded;
+		});
+	}
+	/**
+	* Each updateComponents becomes one operation per component, in order. The
+	* complete components of a streaming line then give the same first
+	* operations as the finished line, so the operation list only grows and the
+	* manager never has to start the surface again.
+	*/
+	function splitComponentUpdates(operations) {
+		return operations.flatMap((op) => {
+			const update = op.updateComponents;
+			if (!isRecord(update) || !Array.isArray(update.components)) return [op];
+			if (update.components.length <= 1) return [op];
+			return update.components.map((component) => ({
+				...op,
+				updateComponents: {
+					...update,
+					components: [component]
+				}
+			}));
+		});
+	}
+	/** createSurface first, the other operations after it in their order. */
+	function createSurfaceFirst(operations) {
+		const creates = operations.filter((op) => isRecord(op.createSurface));
+		const others = operations.filter((op) => !isRecord(op.createSurface));
+		return [...creates, ...others];
+	}
+	/** True when the component of `name` has the prop `prop`. */
+	function hasProp(ui, name, prop) {
+		const properties = ui.manifestComponents[name]?.props.properties;
+		return isRecord(properties) && Object.hasOwn(properties, prop);
+	}
+	const childRefCache = /* @__PURE__ */ new WeakMap();
+	/** The ids in a slot value: an id, a list of ids, or a template. */
+	function slotIds(value) {
+		if (typeof value === "string") return [value];
+		if (Array.isArray(value)) return value.filter(isString);
+		return isRecord(value) && isString(value.componentId) ? [value.componentId] : [];
+	}
+	/**
+	* A reader of the ids a component renders beyond `child` and `children`:
+	* its declared slots (the `trigger` and `content` of a Modal) and its typed
+	* child references (the `child` of each entry of `tabs`), from its catalog
+	* entry. The prose lift follows these ids like `children`, so a panel is
+	* never cut off from its Tabs. A reference that is bound to the data
+	* model is "unknown": its ids exist only at render time.
+	*/
+	function childIdsReader(ui) {
+		return (component) => {
+			const name = component.component;
+			const entry = typeof name === "string" && Object.hasOwn(ui.manifestComponents, name) ? ui.manifestComponents[name] : void 0;
+			if (!entry) return [];
+			const ids = [];
+			for (const slot of Object.keys(entry.slots ?? {})) if (slot !== "child" && slot !== "children") ids.push(...slotIds(component[slot]));
+			let refs = childRefCache.get(entry.props);
+			if (!refs) {
+				refs = (0, _copilotkit_shared.collectChildRefs)(entry.props);
+				childRefCache.set(entry.props, refs);
+			}
+			if (refs.length === 0) return ids;
+			if ((0, _copilotkit_shared.hasBoundChildRef)(component, refs)) return "unknown";
+			return [...ids, ...(0, _copilotkit_shared.childIdsAtRefs)(component, refs)];
+		};
+	}
+	/** Every component of the operations by id, last definition wins. */
+	function collectComponents(operations) {
+		const byId = /* @__PURE__ */ new Map();
+		for (const op of operations) {
+			const update = op.updateComponents;
+			const list = isRecord(update) ? update.components : void 0;
+			if (!Array.isArray(list)) continue;
+			for (const component of list) if (isRecord(component) && isString(component.id)) byId.set(component.id, component);
+		}
+		return [...byId.values()];
+	}
+	/**
+	* The data model must not be shared between two surfaces. A data model
+	* keeps the object it gets, so an input in one surface would change the
+	* data of the other one.
+	*/
+	function cloneData(value) {
+		return value === void 0 ? void 0 : structuredClone(value);
+	}
+	/** The operation sent to `surfaceId`, with a copy of its data model value. */
+	function readdress(op, surfaceId) {
+		const kind = (0, _copilotkit_shared.getOperationKind)(op);
+		const payload = kind ? op[kind] : void 0;
+		if (!kind || !isRecord(payload)) return op;
+		const next = {
+			...payload,
+			surfaceId
+		};
+		if (kind === "updateDataModel" && "value" in payload) next.value = cloneData(payload.value);
+		return {
+			...op,
+			[kind]: next
+		};
+	}
+	/**
+	* The operations of one sub-surface. Each updateComponents keeps only the
+	* components of the sub-surface, with its own root. The other operations
+	* are sent to the sub-surface. The order stays the same, so a new operation
+	* of the fence only adds operations at the end.
+	*/
+	function subSurfaceOperations(operations, components, surfaceId) {
+		const root = components.find((c) => c.id === _copilotkit_shared.GENERATIVE_UI_ROOT_ID);
+		const ids = new Set(components.map((c) => c.id));
+		const out = [];
+		for (const op of operations) {
+			const update = op.updateComponents;
+			if (!isRecord(update) || !Array.isArray(update.components)) {
+				out.push(readdress(op, surfaceId));
+				continue;
+			}
+			const kept = update.components.filter((c) => isRecord(c) && ids.has(c.id)).map((c) => isRecord(c) && c.id === _copilotkit_shared.GENERATIVE_UI_ROOT_ID ? root : c);
+			if (kept.length === 0) continue;
+			out.push({
+				...op,
+				updateComponents: {
+					...update,
+					surfaceId,
+					components: kept
+				}
+			});
+		}
+		return out;
+	}
+	/**
+	* Prose lift. Text components in the main stack of the surface (titles,
+	* paragraphs, text lists and the dividers between them) become chat
+	* markdown. The surface splits around them: the first surface keeps
+	* `surfaceId`, the next ones are `<surfaceId>#1`, `<surfaceId>#2`, and so
+	* on. A surface with no prose comes back as one part with the same
+	* operations.
+	*/
+	function liftProse(operations, surfaceId, childIds) {
+		const components = collectComponents(operations);
+		const segments = (0, _copilotkit_core.segmentSurfaceProse)(components, { childIds });
+		const [first] = segments;
+		if (segments.length === 1 && first?.kind === "surface" && first.components === components) return [{
+			kind: "surface",
+			surfaceId,
+			operations
+		}];
+		let surfaceIndex = 0;
+		return segments.map((segment) => {
+			if (segment.kind === "markdown") return segment;
+			const id = surfaceIndex === 0 ? surfaceId : `${surfaceId}#${surfaceIndex}`;
+			surfaceIndex++;
+			return {
+				kind: "surface",
+				surfaceId: id,
+				operations: subSurfaceOperations(operations, segment.components, id)
+			};
+		});
+	}
+	/** `validateOperation`, with the operation typed when it is valid. */
+	function checkOperation(op, options) {
+		const validation = (0, _copilotkit_shared.validateOperation)(op, options);
+		if (!validation.ok) return validation;
+		return {
+			ok: true,
+			operation: op
+		};
+	}
+	/**
+	* The content of one surface. Each operation is validated against the
+	* manifest. A valid operation goes in `operations`. A rejected one goes in
+	* `rejected`, with its position and the reason.
+	*/
+	function surfaceContent(surfaceId, draft, operations, options) {
+		const { ui, functions } = options;
+		const knownSurfaces = /* @__PURE__ */ new Set();
+		const manifest = {
+			catalogId: ui.id,
+			catalogIds: catalogIdsOf(ui),
+			components: ui.manifestComponents
+		};
+		const valid = [];
+		const rejected = [];
+		operations.forEach((op, index) => {
+			const result = checkOperation(op, {
+				manifest,
+				knownSurfaces,
+				functions
+			});
+			if (!result.ok) {
+				rejected.push({
+					index,
+					reason: result.reason
+				});
+				return;
+			}
+			valid.push(result.operation);
+			const kind = (0, _copilotkit_shared.getOperationKind)(result.operation);
+			if (kind === "createSurface") knownSurfaces.add(surfaceId);
+			if (kind === "deleteSurface") knownSurfaces.delete(surfaceId);
+		});
+		const create = valid.find((op) => "createSurface" in op);
+		return {
+			surfaceId,
+			target: draft.target,
+			catalogId: create?.createSurface.catalogId ?? ui.id,
+			operations: valid,
+			status: draft.streaming ? "streaming" : "ready",
+			rejected
+		};
+	}
+	/**
+	* Builds the surfaces of a thread from the ```a2ui fences of its assistant
+	* messages, in message order.
+	*
+	* - Operations are grouped by surfaceId across all messages. An operation
+	*   with no surfaceId goes to the first surface of its fence, else to
+	*   `<messageId>-<fenceIndex>`.
+	* - The fence that first writes a surface creates it. The `target=<id>` of
+	*   that fence sets the target. With no target, the surface goes to the
+	*   chat.
+	* - A later fence of the same reply for the same surfaceId updates it. A
+	*   later reply that reuses the id of a chat surface gets a surface of its
+	*   own, `<id>@<messageId>`. A page target is updated from any reply.
+	* - The status is "streaming" while the creating fence streams, else
+	*   "ready".
+	* - Each operation is validated with `validateOperation`. Rejected ones are
+	*   left out and listed in `rejected`.
+	* - Chat surfaces get the prose lift: informational cards lose their box,
+	*   and prose becomes markdown that renders between sub-surfaces
+	*   (`<surfaceId>#<n>`). An inline createSurface is split into its
+	*   createSurface, updateDataModel and updateComponents first.
+	* - A `callRendererFunction` line is not part of a surface. It goes to
+	*   `functionCalls`. A streaming line gives nothing, so a function never
+	*   runs with a part of its args.
+	*
+	* The function is pure. Call it again on each stream update. The manager
+	* applies only the new operations, so unchanged surfaces do not render
+	* again.
+	*
+	* @param messages - The messages of one thread.
+	* @param options - The generative UI, its declared functions, and whether
+	*   the last message can still grow.
+	* @returns `surfaces`, one content for each surface and sub-surface;
+	*   `fences`, the blocks that each fence renders, by `fenceKey` (a fence
+	*   that is not in `fences` renders nothing); `functionCalls`, the function
+	*   calls of the fences in order; and `parts`, the surface ids of the parts
+	*   of each surface, by surface id.
+	*
+	* @example
+	* ```ts
+	* const { surfaces } = buildMarkdownSurfaces(agent.messages, {
+	*   ui,
+	*   functions: {},
+	*   running: agent.isRunning,
+	* });
+	* for (const content of surfaces) manager.ingest(threadId, agentId, content);
+	* ```
+	*/
+	function buildMarkdownSurfaces(messages, options) {
+		const { ui, cache } = options;
+		const drafts = /* @__PURE__ */ new Map();
+		const readdressOnce = (op, surfaceId) => {
+			if (!cache) return readdress(op, surfaceId);
+			let copies = cache.readdressed.get(op);
+			if (!copies) {
+				copies = /* @__PURE__ */ new Map();
+				cache.readdressed.set(op, copies);
+			}
+			let copy = copies.get(surfaceId);
+			if (!copy) {
+				copy = readdress(op, surfaceId);
+				copies.set(surfaceId, copy);
+			}
+			return copy;
+		};
+		/** The surfaces that each fence created, in order. */
+		const created = /* @__PURE__ */ new Map();
+		const functionCalls = [];
+		/** The message that owns each chat surface id, by the id the model wrote. */
+		const chatOwners = /* @__PURE__ */ new Map();
+		const lastMessage = messages[messages.length - 1];
+		/**
+		* A chat surface belongs to the reply that wrote it: the chat is a
+		* transcript, so a later reply that reuses an id gets a surface of its
+		* own (`<id>@<messageId>`) instead of changing the earlier reply. A fence
+		* for a page target keeps its id, because a target is a place on the
+		* page that a later reply updates on purpose.
+		*/
+		const scopedSurfaceId = (requested, messageId, target) => {
+			if (target !== void 0) return requested;
+			const owner = chatOwners.get(requested);
+			if (owner === void 0) {
+				chatOwners.set(requested, messageId);
+				return requested;
+			}
+			return owner === messageId ? requested : `${requested}@${messageId}`;
+		};
+		for (const message of messages) {
+			if (message.role !== "assistant" || !isString(message.content)) continue;
+			const isLastMessage = message === lastMessage;
+			const content = message.content;
+			const segments = cache ? cache.segments.get(content, () => (0, _copilotkit_core.splitA2UIMarkdown)(content)) : (0, _copilotkit_core.splitA2UIMarkdown)(content);
+			for (const segment of segments) {
+				if (segment.type !== "a2ui") continue;
+				const isStreaming = !segment.closed && isLastMessage && options.running;
+				const parseFence = () => {
+					const parsed = fenceOperations(segment.text, isStreaming);
+					const { functionCalls } = (0, _copilotkit_core.prepareSurfaceOperations)({
+						operations: parsed,
+						fallbackSurfaceId: "",
+						catalogId: ui.id
+					});
+					return {
+						operations: parsed,
+						functionCalls
+					};
+				};
+				const fence = cache ? cache.fences.get(`${isStreaming}:${segment.text}`, parseFence) : parseFence();
+				const { operations } = fence;
+				const key = fenceKey(message.id, segment.index);
+				const fenceSurfaceId = operations.map(_copilotkit_core.getMarkdownOperationSurfaceId).find(isString) ?? `${message.id}-${segment.index}`;
+				for (const operation of fence.functionCalls) functionCalls.push({
+					messageId: message.id,
+					fenceIndex: segment.index,
+					operation
+				});
+				const surfaceOperations = operations.filter((op) => (0, _copilotkit_shared.getOperationKind)(op) !== "callRendererFunction");
+				for (const op of surfaceOperations) {
+					const requested = (0, _copilotkit_core.getMarkdownOperationSurfaceId)(op) ?? fenceSurfaceId;
+					const surfaceId = scopedSurfaceId(requested, message.id, segment.target);
+					let draft = drafts.get(surfaceId);
+					if (!draft) {
+						draft = {
+							surfaceId,
+							target: segment.target ?? _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET,
+							operations: [],
+							streaming: isStreaming
+						};
+						drafts.set(surfaceId, draft);
+						created.set(key, [...created.get(key) ?? [], surfaceId]);
+					}
+					draft.operations.push(surfaceId === requested ? op : readdressOnce(op, surfaceId));
+				}
+			}
+		}
+		const canFlattenCards = hasProp(ui, "Card", "variant");
+		const surfaces = [];
+		const partsBySurface = /* @__PURE__ */ new Map();
+		const childIds = childIdsReader(ui);
+		const buildDraft = (draft) => {
+			const operations = splitComponentUpdates(expandInlineCreate(createSurfaceFirst((0, _copilotkit_core.prepareSurfaceOperations)({
+				operations: draft.operations,
+				fallbackSurfaceId: draft.surfaceId,
+				catalogId: ui.id,
+				catalogIds: catalogIdsOf(ui)
+			}).operations)));
+			const parts = draft.target === _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET ? liftProse(canFlattenCards ? (0, _copilotkit_core.flattenInformationalCards)(operations, { childIds }) : operations, draft.surfaceId, childIds) : [{
+				kind: "surface",
+				surfaceId: draft.surfaceId,
+				operations
+			}];
+			const contents = parts.flatMap((part) => part.kind === "surface" ? [surfaceContent(part.surfaceId, draft, part.operations, options)] : []);
+			return {
+				...draft,
+				parts,
+				contents
+			};
+		};
+		for (const draft of drafts.values()) {
+			const built = cache ? cache.drafts.get(draft.surfaceId, () => buildDraft(draft), (last) => last.target === draft.target && last.streaming === draft.streaming && sameItems(last.operations, draft.operations)) : buildDraft(draft);
+			partsBySurface.set(draft.surfaceId, built.parts);
+			surfaces.push(...built.contents);
+		}
+		cache?.endBuild();
+		/** The surface ids of the parts of each split surface, by surface id. */
+		const parts = /* @__PURE__ */ new Map();
+		for (const [surfaceId, surfaceParts] of partsBySurface) {
+			const ids = surfaceParts.flatMap((part) => part.kind === "surface" ? [part.surfaceId] : []);
+			parts.set(surfaceId, ids);
+		}
+		const fences = /* @__PURE__ */ new Map();
+		for (const [key, surfaceIds] of created) {
+			const blocks = [];
+			for (const surfaceId of surfaceIds) {
+				if (drafts.get(surfaceId)?.target !== _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET) continue;
+				for (const part of partsBySurface.get(surfaceId) ?? []) blocks.push(part.kind === "markdown" ? part : {
+					kind: "surface",
+					surfaceId: part.surfaceId
+				});
+			}
+			if (blocks.length > 0) fences.set(key, blocks);
+		}
+		return {
+			surfaces,
+			fences,
+			functionCalls,
+			parts
+		};
+	}
+	/** The declared functions, as `validateOperation` takes them. */
+	function declaredFunctions(ui) {
+		const functions = {};
+		for (const [name, fn] of ui.functions) try {
+			functions[name] = {
+				...fn.description ? { description: fn.description } : {},
+				parameters: toJsonSchema(fn.parameters)
+			};
+		} catch {
+			functions[name] = { parameters: {} };
+		}
+		return functions;
+	}
+	/** True when `list` starts with all the items of `prefix`. */
+	function startsWith(list, prefix) {
+		return list.length >= prefix.length && prefix.every((item, index) => item === list[index]);
+	}
+	/** A content that deletes a surface that the fences no longer write. */
+	function removalContent(surfaceId, catalogId) {
+		return {
+			surfaceId,
+			target: _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET,
+			catalogId,
+			status: "ready",
+			rejected: [],
+			operations: [{
+				version: _copilotkit_shared.A2UI_VERSION,
+				createSurface: {
+					surfaceId,
+					catalogId
+				}
+			}, {
+				version: _copilotkit_shared.A2UI_VERSION,
+				deleteSurface: { surfaceId }
+			}]
+		};
+	}
+	/**
+	* The markdown transport source of one surface manager. It turns the
+	* messages of a thread into surfaces in the manager, and keeps the blocks
+	* that each fence renders.
+	*/
+	var MarkdownSurfaceSource = class {
+		constructor(manager, ui) {
+			this.manager = manager;
+			this.ui = ui;
+			this.fences = /* @__PURE__ */ new Map();
+			this.ingested = /* @__PURE__ */ new Map();
+			this.contents = /* @__PURE__ */ new Map();
+			this.caches = /* @__PURE__ */ new Map();
+			this.functions = declaredFunctions(ui);
+		}
+		/**
+		* Builds the surfaces of `threadId` from `messages` and gives them to the
+		* manager. A surface that an earlier sync of the thread made, and that the
+		* messages no longer write, is deleted. Other threads do not change.
+		*
+		* @param threadId - The thread of the messages.
+		* @param agentId - The agent that owns the thread.
+		* @param messages - All messages of the thread.
+		* @param options - `running`: the last message can still grow.
+		* @returns The function calls of the fences, in order. The source does
+		*   not run them.
+		*/
+		sync(threadId, agentId, messages, options) {
+			let cache = this.caches.get(threadId);
+			if (!cache) {
+				cache = new MarkdownBuildCache();
+				this.caches.set(threadId, cache);
+			}
+			const result = buildMarkdownSurfaces(messages, {
+				ui: this.ui,
+				functions: this.functions,
+				running: options.running,
+				cache
+			});
+			this.fences.set(threadId, result.fences);
+			for (const parts of result.parts.values()) this.manager.linkSurfaces(threadId, parts);
+			const previous = this.ingested.get(threadId) ?? /* @__PURE__ */ new Map();
+			const previousContents = this.contents.get(threadId) ?? /* @__PURE__ */ new Map();
+			const next = /* @__PURE__ */ new Map();
+			const nextContents = /* @__PURE__ */ new Map();
+			for (const content of result.surfaces) {
+				nextContents.set(content.surfaceId, content);
+				const before = previous.get(content.surfaceId);
+				if (before && previousContents.get(content.surfaceId) === content) {
+					next.set(content.surfaceId, before);
+					continue;
+				}
+				const fingerprints = content.operations.map((op) => JSON.stringify(op));
+				if (before && !startsWith(fingerprints, before)) this.manager.ingest(threadId, agentId, {
+					...content,
+					operations: []
+				});
+				this.manager.ingest(threadId, agentId, content);
+				next.set(content.surfaceId, fingerprints);
+			}
+			for (const surfaceId of previous.keys()) {
+				if (next.has(surfaceId)) continue;
+				this.manager.ingest(threadId, agentId, removalContent(surfaceId, this.ui.id));
+			}
+			this.ingested.set(threadId, next);
+			this.contents.set(threadId, nextContents);
+			return result.functionCalls;
+		}
+		/**
+		* The blocks that a fence renders in the chat, from the latest sync of the
+		* thread. `undefined` when the fence renders nothing: it updates a surface
+		* of an earlier fence, its surface is for a named target, or it has no
+		* complete operation yet.
+		*/
+		getFenceBlocks(threadId, messageId, fenceIndex) {
+			return this.fences.get(threadId)?.get(fenceKey(messageId, fenceIndex));
+		}
+	};
+	const sources = /* @__PURE__ */ new WeakMap();
+	/**
+	* The markdown source of a generative UI runtime. There is one source for
+	* each surface manager. The root syncs it, and the chat messages read the
+	* fence blocks from it.
+	*/
+	function getMarkdownSurfaceSource(runtime) {
+		let source = sources.get(runtime.manager);
+		if (!source) {
+			source = new MarkdownSurfaceSource(runtime.manager, runtime.ui);
+			sources.set(runtime.manager, source);
+		}
+		return source;
+	}
+
+//#endregion
+//#region src/v2/generative-ui/calc.ts
+	const MAX_SERIES = 1e3;
+	const OPERATORS = [
+		"&&",
+		"||",
+		"==",
+		"!=",
+		"<=",
+		">=",
+		"<",
+		">",
+		"+",
+		"-",
+		"*",
+		"/",
+		"%",
+		"(",
+		")",
+		",",
+		"?",
+		":",
+		"!"
+	];
+	function tokenize(source) {
+		const tokens = [];
+		let i = 0;
+		while (i < source.length) {
+			const char = source[i];
+			if (/\s/.test(char)) {
+				i++;
+				continue;
+			}
+			if (/[0-9.]/.test(char)) {
+				const match = /^\d*\.?\d+(?:[eE][-+]?\d+)?|^\d+\.?/.exec(source.slice(i));
+				if (!match) throw new ExpressionError(`calc: bad number at "${source.slice(i, i + 8)}"`);
+				tokens.push({
+					kind: "number",
+					value: Number(match[0])
+				});
+				i += match[0].length;
+				continue;
+			}
+			if (char === "'" || char === "\"") {
+				let value = "";
+				i++;
+				while (i < source.length && source[i] !== char) {
+					if (source[i] === "\\" && i + 1 < source.length) i++;
+					value += source[i++];
+				}
+				if (i >= source.length) throw new ExpressionError("calc: unclosed string");
+				i++;
+				tokens.push({
+					kind: "string",
+					value
+				});
+				continue;
+			}
+			if (/[A-Za-z_]/.test(char)) {
+				const match = /^[A-Za-z_][A-Za-z0-9_]*/.exec(source.slice(i));
+				tokens.push({
+					kind: "name",
+					value: match[0]
+				});
+				i += match[0].length;
+				continue;
+			}
+			const op = OPERATORS.find((candidate) => source.startsWith(candidate, i));
+			if (!op) throw new ExpressionError(`calc: unexpected "${char}"`);
+			tokens.push({
+				kind: "op",
+				value: op
+			});
+			i += op.length;
+		}
+		tokens.push({ kind: "end" });
+		return tokens;
+	}
+	function numberOf(value, what) {
+		if (typeof value === "number") {
+			if (!Number.isFinite(value)) throw new ExpressionError(`calc: ${what} is not finite`);
+			return value;
+		}
+		if (typeof value === "boolean") return value ? 1 : 0;
+		if (typeof value === "string" && value.trim() !== "") {
+			const parsed = Number(value);
+			if (Number.isFinite(parsed)) return parsed;
+		}
+		if (value === null || value === void 0) throw new ExpressionError(`calc: ${what} has no value`);
+		throw new ExpressionError(`calc: ${what} is not a number`);
+	}
+	function describe(value) {
+		return typeof value === "string" ? `"${value}"` : String(value);
+	}
+	const MATH = {
+		min: (args) => Math.min(...args),
+		max: (args) => Math.max(...args),
+		abs: ([x]) => Math.abs(x),
+		floor: ([x]) => Math.floor(x),
+		ceil: ([x]) => Math.ceil(x),
+		round: ([x, decimals = 0]) => {
+			const factor = 10 ** Math.trunc(decimals);
+			return Math.round(x * factor) / factor;
+		}
+	};
+	var CalcParser = class {
+		constructor(tokens, scope, source) {
+			this.tokens = tokens;
+			this.scope = scope;
+			this.source = source;
+			this.pos = 0;
+			this.skipDepth = 0;
+		}
+		parse() {
+			const value = this.ternary();
+			if (this.tokens[this.pos].kind !== "end") this.fail(`unexpected "${this.text(this.tokens[this.pos])}"`);
+			return value;
+		}
+		fail(what) {
+			throw new ExpressionError(`calc: ${what} in "${this.source}"`);
+		}
+		text(token) {
+			return token.kind === "end" ? "end" : String(token.value);
+		}
+		peekOp(...ops) {
+			const token = this.tokens[this.pos];
+			return token.kind === "op" && ops.includes(token.value) ? token.value : void 0;
+		}
+		expectOp(op) {
+			if (this.peekOp(op) === void 0) this.fail(`expected "${op}" but found "${this.text(this.tokens[this.pos])}"`);
+			this.pos++;
+		}
+		/**
+		* Parses a part of the expression that the result does not need (the
+		* other branch of `?:`, the right side of a decided `&&` or `||`). It
+		* still has to be parsed to find where it ends, so syntax errors are
+		* reported, but no value is checked or computed: `n == 0 ? 0 : 10 / n`
+		* is a valid guard.
+		*/
+		skipped(parse) {
+			this.skipDepth++;
+			try {
+				parse();
+			} finally {
+				this.skipDepth--;
+			}
+			return null;
+		}
+		/** The number of a value, or 0 while skipping. */
+		num(value, what) {
+			return this.skipDepth > 0 ? 0 : numberOf(value, what);
+		}
+		ternary() {
+			const condition = this.or();
+			if (this.peekOp("?") === void 0) return condition;
+			this.pos++;
+			const takesFirst = truthOf(condition);
+			const whenTrue = takesFirst ? this.ternary() : this.skipped(() => this.ternary());
+			this.expectOp(":");
+			const whenFalse = takesFirst ? this.skipped(() => this.ternary()) : this.ternary();
+			return takesFirst ? whenTrue : whenFalse;
+		}
+		or() {
+			let left = this.and();
+			while (this.peekOp("||")) {
+				this.pos++;
+				if (truthOf(left)) {
+					this.skipped(() => this.and());
+					left = true;
+				} else left = truthOf(this.and());
+			}
+			return left;
+		}
+		and() {
+			let left = this.equality();
+			while (this.peekOp("&&")) {
+				this.pos++;
+				if (!truthOf(left)) {
+					this.skipped(() => this.equality());
+					left = false;
+				} else left = truthOf(this.equality());
+			}
+			return left;
+		}
+		equality() {
+			let left = this.comparison();
+			for (let op = this.peekOp("==", "!="); op; op = this.peekOp("==", "!=")) {
+				this.pos++;
+				const right = this.comparison();
+				const isEqual = typeof left === "number" || typeof right === "number" ? this.num(left, "the left side of ==") === this.num(right, "the right side of ==") : left === right;
+				left = op === "==" ? isEqual : !isEqual;
+			}
+			return left;
+		}
+		comparison() {
+			let left = this.additive();
+			for (let op = this.peekOp("<", "<=", ">", ">="); op; op = this.peekOp("<", "<=", ">", ">=")) {
+				this.pos++;
+				const a = this.num(left, `the left side of ${op}`);
+				const b = this.num(this.additive(), `the right side of ${op}`);
+				left = op === "<" ? a < b : op === "<=" ? a <= b : op === ">" ? a > b : a >= b;
+			}
+			return left;
+		}
+		additive() {
+			let left = this.multiplicative();
+			for (let op = this.peekOp("+", "-"); op; op = this.peekOp("+", "-")) {
+				this.pos++;
+				const right = this.multiplicative();
+				if (op === "+" && (typeof left === "string" || typeof right === "string")) left = `${left ?? ""}${right ?? ""}`;
+				else {
+					const a = this.num(left, `the left side of ${op}`);
+					const b = this.num(right, `the right side of ${op}`);
+					left = op === "+" ? a + b : a - b;
+				}
+			}
+			return left;
+		}
+		multiplicative() {
+			let left = this.unary();
+			for (let op = this.peekOp("*", "/", "%"); op; op = this.peekOp("*", "/", "%")) {
+				this.pos++;
+				const a = this.num(left, `the left side of ${op}`);
+				const b = this.num(this.unary(), `the right side of ${op}`);
+				if (op !== "*" && b === 0 && this.skipDepth === 0) this.fail("division by zero");
+				left = op === "*" ? a * b : op === "/" ? a / b : a % b;
+			}
+			return left;
+		}
+		unary() {
+			if (this.peekOp("-")) {
+				this.pos++;
+				return -this.num(this.unary(), "the operand of -");
+			}
+			if (this.peekOp("!")) {
+				this.pos++;
+				return !truthOf(this.unary());
+			}
+			return this.primary();
+		}
+		primary() {
+			const token = this.tokens[this.pos++];
+			switch (token.kind) {
+				case "number": return token.value;
+				case "string": return token.value;
+				case "name": return this.name(token.value);
+				case "op":
+					if (token.value === "(") {
+						const value = this.ternary();
+						this.expectOp(")");
+						return value;
+					}
+					return this.fail(`unexpected "${token.value}"`);
+				case "end": return this.fail("missing value");
+			}
+		}
+		name(name) {
+			if (name === "true") return true;
+			if (name === "false") return false;
+			if (name === "null") return null;
+			if (this.peekOp("(")) {
+				this.pos++;
+				const args = [];
+				if (this.peekOp(")") === void 0) for (;;) {
+					args.push(this.num(this.ternary(), `an argument of ${name}`));
+					if (this.peekOp(",") === void 0) break;
+					this.pos++;
+				}
+				this.expectOp(")");
+				if (this.skipDepth > 0) return null;
+				const fn = Object.prototype.hasOwnProperty.call(MATH, name) ? MATH[name] : void 0;
+				if (!fn) this.fail(`unknown function ${name}`);
+				if (args.length === 0) this.fail(`${name} needs an argument`);
+				return fn(args);
+			}
+			if (this.skipDepth > 0) return null;
+			if (!Object.prototype.hasOwnProperty.call(this.scope, name)) this.fail(`unknown name ${name}; pass it as an arg`);
+			const value = this.scope[name];
+			if (value !== null && typeof value !== "number" && typeof value !== "string" && typeof value !== "boolean") this.fail(`${name} is not a number, text or boolean (${describe(value)})`);
+			return value;
+		}
+	};
+	/**
+	* Evaluates `expression` with the names in `scope`. Gives a number, a
+	* string, a boolean or null. Throws an {@link ExpressionError} for a bad
+	* expression or a missing name.
+	*/
+	function evaluateCalc(expression, scope) {
+		if (typeof expression !== "string" || expression.trim() === "") throw new ExpressionError("calc: expression must be a string");
+		return new CalcParser(tokenize(expression), scope, expression).parse();
+	}
+	/** The `calc` function: the expression is `args.expression`, the rest is the scope. */
+	function calc(args) {
+		const { expression, ...scope } = args;
+		return evaluateCalc(expression, scope);
+	}
+	const WHOLE_EXPRESSION = /^\$\{([^}]*)\}$/;
+	/**
+	* Fills `item` for one iteration: a string that is one `${...}` gives the
+	* typed value of the expression, a string with `${...}` inside it is
+	* interpolated as text, and objects and arrays are walked.
+	*/
+	function fillItem(item, scope) {
+		if (typeof item === "string") {
+			const whole = WHOLE_EXPRESSION.exec(item);
+			if (whole) return evaluateCalc(whole[1], scope);
+			return item.replace(/\$\{([^}]*)\}/g, (_, expression) => {
+				const value = evaluateCalc(expression, scope);
+				return value === null ? "" : String(value);
+			});
+		}
+		if (Array.isArray(item)) return item.map((entry) => fillItem(entry, scope));
+		if (typeof item === "object" && item !== null) return Object.fromEntries(Object.entries(item).map(([key, value]) => [key, fillItem(value, scope)]));
+		return item;
+	}
+	/**
+	* The `series` function: `count` copies of `item`, with the loop variable
+	* (`variable`, default "i") counting from `start` (default 1) and the other
+	* args in scope of the `${...}` expressions of the item.
+	*/
+	function series(args) {
+		const { count, item, variable, start, ...scope } = args;
+		const length = numberOf(count, "count");
+		if (!Number.isInteger(length) || length < 0) throw new ExpressionError("series: count must be a whole number");
+		if (length > MAX_SERIES) throw new ExpressionError(`series: count is at most ${MAX_SERIES}`);
+		if (item === void 0) throw new ExpressionError("series: item is required");
+		const name = variable === void 0 ? "i" : variable;
+		if (typeof name !== "string" || !/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) throw new ExpressionError("series: variable must be a name");
+		const first = start === void 0 ? 1 : numberOf(start, "start");
+		return Array.from({ length }, (_, index) => fillItem(item, {
+			...scope,
+			[name]: first + index
+		}));
+	}
+
+//#endregion
+//#region src/v2/generative-ui/resolve.ts
+	BASIC_FUNCTIONS.calc = calc;
+	BASIC_FUNCTIONS.series = series;
+	const NO_DATA = { get: () => void 0 };
+	BASIC_FUNCTIONS.formatString = (args) => resolveDynamicValue({
+		"@call": "formatString",
+		args
+	}, {
+		data: NO_DATA,
+		basePath: void 0
+	}).value;
+	/** Adds one segment to a JSON pointer: ("/items", "0") gives "/items/0". */
+	function joinPath(base, segment) {
+		return base === "/" ? `/${segment}` : `${base}/${segment}`;
+	}
+	/**
+	* The absolute data model path of a binding. A path without a leading "/"
+	* is relative to the current template item, or to the root outside of one.
+	*/
+	function resolvePath(path, basePath) {
+		if (path.startsWith("/")) return path;
+		return joinPath(basePath ?? "/", path);
+	}
+	/**
+	* The index of the template item at `basePath`: its last segment.
+	* `undefined` outside of a template.
+	*/
+	function templateIndex(basePath) {
+		if (basePath === void 0) return void 0;
+		const index = Number(basePath.slice(basePath.lastIndexOf("/") + 1));
+		return Number.isInteger(index) ? index : void 0;
+	}
+	/** The value of a ValidationResult where a boolean is expected. */
+	function coerce(value, keep) {
+		return !keep && (0, _copilotkit_shared.isValidationResult)(value) ? value.valid : value;
+	}
+	/**
+	* Resolves `value`. `keepValidation` keeps a ValidationResult as it is; by
+	* default it becomes its `valid` boolean, which is what every prop except
+	* a check condition wants.
+	*/
+	function walk(value, state, keepValidation, scope = "outside") {
+		if (Array.isArray(value)) {
+			let changed = false;
+			const itemScope = scope === "list" ? "check" : "outside";
+			const items = value.map((item) => {
+				const next = walk(item, state, keepValidation, itemScope);
+				if (next !== item) changed = true;
+				return next;
+			});
+			return changed ? items : value;
+		}
+		if (!isRecord(value)) return value;
+		if ((0, _copilotkit_shared.isPathBinding)(value)) {
+			const path = resolvePath(value["@path"], state.context.basePath);
+			state.paths.add(path);
+			return state.context.data.get(path);
+		}
+		if ((0, _copilotkit_shared.isCallBinding)(value)) return call(value, state, keepValidation);
+		if ((0, _copilotkit_shared.isActionBinding)(value)) return value;
+		let changed = false;
+		const entries = Object.entries(value).map(([key, item]) => {
+			const next = walk(item, state, keepValidation || scope === "check" && key === "condition", key === "checks" ? "list" : "outside");
+			if (next !== item) changed = true;
+			return [key, next];
+		});
+		return changed ? Object.fromEntries(entries) : value;
+	}
+	function call(binding, state, keepValidation) {
+		const name = binding["@call"];
+		const rawArgs = binding.args ?? {};
+		if (!isRecord(rawArgs)) throw new ExpressionError(`the args of "${name}" must be an object`);
+		if (name === _copilotkit_shared.A2UI_INDEX_FUNCTION) {
+			const index = templateIndex(state.context.basePath);
+			if (index === void 0) return void 0;
+			const offset = walk(rawArgs.offset, state, false);
+			return index + (typeof offset === "number" ? offset : 0);
+		}
+		if (name === "formatString") {
+			const template = walk(rawArgs.value, state, false);
+			if (typeof template !== "string") throw new ExpressionError("formatString takes a string value");
+			return formatString(template, state);
+		}
+		const fn = Object.prototype.hasOwnProperty.call(BASIC_FUNCTIONS, name) ? BASIC_FUNCTIONS[name] : void 0;
+		if (!fn) throw new ExpressionError(`"${name}" is not a basic function`);
+		if (requiresUserActivation(name)) throw new ExpressionError(`"${name}" is not a value; bind it as the functionCall of an event`);
+		const result = fn(walk(rawArgs, state, false));
+		return givesValidationResult(name) ? coerce(result, keepValidation) : result;
+	}
+	function resolveDynamicValue(value, context, options = {}) {
+		const result = tryResolveDynamicValue(value, context, options);
+		if (!result.ok) throw result.error;
+		return result;
+	}
+	/**
+	* Like {@link resolveDynamicValue}, but a failure comes back as a result
+	* with the paths read so far, so the caller can keep watching them: a
+	* function that fails on an empty field works once the user fills it.
+	*/
+	function tryResolveDynamicValue(value, context, options = {}) {
+		const state = {
+			context,
+			paths: /* @__PURE__ */ new Set()
+		};
+		try {
+			return {
+				ok: true,
+				value: walk(value, state, options.keepValidation ?? false, options.isChecks ? "list" : "outside"),
+				paths: state.paths
+			};
+		} catch (error) {
+			return {
+				ok: false,
+				error: error instanceof Error ? error : new Error(String(error)),
+				paths: state.paths
+			};
+		}
+	}
+	/** True when `value` holds a `{"@path"}` or `{"@call"}` at any depth. */
+	function containsDynamicValue(value) {
+		if (Array.isArray(value)) return value.some(containsDynamicValue);
+		if (!isRecord(value)) return false;
+		if ((0, _copilotkit_shared.isPathBinding)(value) || (0, _copilotkit_shared.isCallBinding)(value)) return true;
+		if ((0, _copilotkit_shared.isActionBinding)(value)) return false;
+		return Object.values(value).some(containsDynamicValue);
+	}
+	/**
+	* The `${...}` grammar of `formatString`:
+	*
+	*   expression := path | literal | call
+	*   path       := "/" segments | identifier ("/" segments)*
+	*   literal    := 'text' | "text" | number | true | false | null
+	*   call       := identifier "(" [ name ":" expression ("," name ":" expression)* ] ")"
+	*
+	* A `\${` in the template is a literal `${`.
+	*/
+	function formatString(template, state) {
+		let out = "";
+		let index = 0;
+		while (index < template.length) {
+			const start = template.indexOf("${", index);
+			if (start === -1) {
+				out += template.slice(index);
+				break;
+			}
+			if (start > 0 && template[start - 1] === "\\") {
+				out += `${template.slice(index, start - 1)}\${`;
+				index = start + 2;
+				continue;
+			}
+			out += template.slice(index, start);
+			const end = matchingBrace(template, start + 2);
+			if (end === -1) throw new ExpressionError("formatString: unclosed ${");
+			const value = new ExpressionParser(template.slice(start + 2, end).trim(), state).parse();
+			out += value === void 0 || value === null ? "" : String(value);
+			index = end + 1;
+		}
+		return out;
+	}
+	/** The index of the `}` that closes the block opened at `from`, or -1. */
+	function matchingBrace(template, from) {
+		let depth = 1;
+		let quote;
+		for (let i = from; i < template.length; i++) {
+			const char = template[i];
+			if (quote) {
+				if (char === "\\") i++;
+				else if (char === quote) quote = void 0;
+				continue;
+			}
+			if (char === "'" || char === "\"") quote = char;
+			else if (char === "{") depth++;
+			else if (char === "}" && --depth === 0) return i;
+		}
+		return -1;
+	}
+	const IDENTIFIER = /@?[A-Za-z_][A-Za-z0-9_-]*/y;
+	const NUMBER = /-?\d+(?:\.\d+)?/y;
+	const PATH_SEGMENT = /[^\s,():'"]+/y;
+	var ExpressionParser = class {
+		constructor(source, state) {
+			this.source = source;
+			this.state = state;
+			this.pos = 0;
+		}
+		parse() {
+			const value = this.expression();
+			this.skipSpace();
+			if (this.pos < this.source.length) throw new ExpressionError(`formatString: unexpected "${this.source.slice(this.pos)}" in \${${this.source}}`);
+			return value;
+		}
+		fail(what) {
+			throw new ExpressionError(`formatString: ${what} in \${${this.source}}`);
+		}
+		skipSpace() {
+			while (this.pos < this.source.length && /\s/.test(this.source[this.pos])) this.pos++;
+		}
+		match(pattern) {
+			pattern.lastIndex = this.pos;
+			const found = pattern.exec(this.source);
+			if (!found) return void 0;
+			this.pos = pattern.lastIndex;
+			return found[0];
+		}
+		expression() {
+			this.skipSpace();
+			const char = this.source[this.pos];
+			if (char === void 0) this.fail("missing expression");
+			if (char === "'" || char === "\"") return this.quoted(char);
+			if (char === "/") return this.path(this.match(PATH_SEGMENT) ?? "/");
+			const number = this.match(NUMBER);
+			if (number !== void 0) return Number(number);
+			const name = this.match(IDENTIFIER);
+			if (name === void 0) this.fail(`unexpected "${char}"`);
+			if (name === "true") return true;
+			if (name === "false") return false;
+			if (name === "null") return null;
+			this.skipSpace();
+			if (this.source[this.pos] === "(") return this.call(name);
+			if (name.startsWith("@")) return call({ "@call": name }, this.state, false);
+			const rest = this.source[this.pos] === "/" ? this.match(PATH_SEGMENT) : "";
+			return this.path(`${name}${rest ?? ""}`);
+		}
+		quoted(quote) {
+			let value = "";
+			this.pos++;
+			while (this.pos < this.source.length) {
+				const char = this.source[this.pos++];
+				if (char === "\\" && this.pos < this.source.length) value += this.source[this.pos++];
+				else if (char === quote) return value;
+				else value += char;
+			}
+			return this.fail("unclosed string");
+		}
+		path(path) {
+			const absolute = resolvePath(path, this.state.context.basePath);
+			this.state.paths.add(absolute);
+			return this.state.context.data.get(absolute);
+		}
+		call(name) {
+			this.pos++;
+			const args = {};
+			this.skipSpace();
+			if (this.source[this.pos] === ")") {
+				this.pos++;
+				return call({
+					"@call": name,
+					args
+				}, this.state, false);
+			}
+			for (;;) {
+				this.skipSpace();
+				const key = this.match(IDENTIFIER);
+				if (key === void 0) this.fail("expected an argument name");
+				this.skipSpace();
+				if (this.source[this.pos] !== ":") this.fail(`expected ":" after ${key}`);
+				this.pos++;
+				args[key] = this.expression();
+				this.skipSpace();
+				const next = this.source[this.pos++];
+				if (next === ")") break;
+				if (next !== ",") this.fail(`expected "," or ")" after ${key}`);
+			}
+			return call({
+				"@call": name,
+				args
+			}, this.state, false);
+		}
+	};
+
+//#endregion
+//#region src/v2/generative-ui/schema.ts
+	const ASYNC_ISSUE = { message: "the schema validates asynchronously; component props and state need a schema that validates synchronously" };
+	function toResult(result) {
+		return result.issues ? {
+			success: false,
+			issues: result.issues
+		} : {
+			success: true,
+			data: result.value
+		};
+	}
+	/**
+	* Validates `value` with `schema`. The result comes back at once when the
+	* schema validates synchronously, else as a promise.
+	*/
+	function validateSchema(schema, value) {
+		const result = schema["~standard"].validate(value);
+		return result instanceof Promise ? result.then(toResult) : toResult(result);
+	}
+	/**
+	* Validates `value` synchronously, for code that runs during render. A
+	* schema that validates asynchronously fails with an issue that says so.
+	*/
+	function validateSchemaSync(schema, value) {
+		const result = validateSchema(schema, value);
+		if (!(result instanceof Promise)) return result;
+		result.catch(() => {});
+		return {
+			success: false,
+			issues: [ASYNC_ISSUE]
+		};
+	}
+	/** True for the issue that `validateSchemaSync` gives for an async schema. */
+	function isAsyncIssue(issue) {
+		return issue === ASYNC_ISSUE;
+	}
+	/** The first key of an issue path: the prop the issue is about. */
+	function issueKey(issue) {
+		const first = issue.path?.[0];
+		const key = typeof first === "object" ? first.key : first;
+		return key === void 0 ? void 0 : String(key);
+	}
+	/**
+	* `props` without the top-level props whose `null` the schema rejected, or
+	* `undefined` when there are none. A model writes `null` for "not set" (an
+	* empty selection, a value it has not filled yet), and A2UI deletes a data
+	* model key that is set to `null`, so a rejected `null` is read as an unset
+	* prop. A prop whose schema accepts `null` keeps it.
+	*/
+	function withoutRejectedNulls(props, issues) {
+		const rejected = /* @__PURE__ */ new Set();
+		for (const issue of issues) {
+			const key = issueKey(issue);
+			if (key !== void 0 && issue.path?.length === 1 && props[key] === null) rejected.add(key);
+		}
+		if (rejected.size === 0) return void 0;
+		return Object.fromEntries(Object.entries(props).filter(([key]) => !rejected.has(key)));
+	}
+	/** `"a.b: message; c: message"`. A path-less issue gets `fallback`. */
+	function formatIssues(issues, fallback = "props") {
+		return issues.map((issue) => {
+			return `${(issue.path ?? []).map((segment) => String(typeof segment === "object" ? segment.key : segment)).join(".") || fallback}: ${issue.message}`;
+		}).join("; ");
+	}
+
+//#endregion
+//#region src/v2/generative-ui/surface-manager.ts
+	function surfaceKey(threadId, surfaceId) {
+		return `${threadId}::${surfaceId}`;
+	}
+	let creationCounter = 0;
+	const FORBIDDEN_SEGMENTS = new Set([
+		"__proto__",
+		"constructor",
+		"prototype"
+	]);
+	/** "/a/b/" to "/a/b". The root stays "/". */
+	function normalizePath(path) {
+		return (path.length > 1 && path.endsWith("/") ? path.slice(0, -1) : path) || "/";
+	}
+	/** True when `path` is `ancestor` or below it. */
+	function isAtOrBelow(path, ancestor) {
+		if (ancestor === "/") return true;
+		return path === ancestor || path.startsWith(`${ancestor}/`);
+	}
+	/**
+	* Rejections as `"operation <index>: <reason>"` lines, cut to the size that
+	* the envelope reader accepts.
+	*/
+	function summarizeRejections(rejections) {
+		return rejections.slice(0, _copilotkit_shared.GENERATIVE_UI_MAX_SUMMARY_REJECTIONS).map(({ index, reason }) => `operation ${index}: ${reason}`.slice(0, _copilotkit_shared.GENERATIVE_UI_MAX_REJECTION_LENGTH));
+	}
+	/**
+	* 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()`.
+	*/
+	var GenerativeUISurfaceManager = class {
+		constructor(ui, options = {}) {
+			this.ui = ui;
+			this.options = options;
+			this.surfaces = /* @__PURE__ */ new Map();
+			this.bookkeeping = /* @__PURE__ */ new Map();
+			this.listeners = /* @__PURE__ */ new Set();
+			this.targets = /* @__PURE__ */ new Map();
+			this.state = {};
+			this.owned = /* @__PURE__ */ new Map();
+			this.deletedKeys = /* @__PURE__ */ new Set();
+			this.linked = /* @__PURE__ */ new Map();
+			this.version = 0;
+			this.subscribe = (listener) => {
+				this.listeners.add(listener);
+				return () => {
+					this.listeners.delete(listener);
+				};
+			};
+			this.getVersion = () => this.version;
+			this.getState = () => this.state;
+			this.webCoreCatalog = new _a2ui_web_core_v0_9.Catalog(ui.id, [...ui.components.keys()].map((name) => ({
+				name,
+				schema: zod.z.any()
+			})), []);
+		}
+		notify() {
+			this.version++;
+			for (const listener of [...this.listeners]) listener();
+		}
+		setActiveThread(threadId) {
+			if (threadId === this.activeThreadId) return;
+			this.activeThreadId = threadId;
+			this.notify();
+		}
+		getActiveThread() {
+			return this.activeThreadId;
+		}
+		ingest(threadId, agentId, content) {
+			const key = surfaceKey(threadId, content.surfaceId);
+			const operations = content.operations ?? [];
+			let surface = this.surfaces.get(key);
+			let book = this.bookkeeping.get(key);
+			let changed = false;
+			if (surface && book && !this.extendsApplied(book, operations)) {
+				this.disposeSurface(key);
+				surface = void 0;
+				book = void 0;
+			}
+			if (!surface || !book) {
+				surface = this.createSurface(key, threadId, agentId, content);
+				this.restoreOwnedValues(surface);
+				book = {
+					appliedCount: 0,
+					lastFingerprint: void 0
+				};
+				this.surfaces.set(key, surface);
+				this.bookkeeping.set(key, book);
+				changed = true;
+			}
+			const serverRejected = content.rejected ?? [];
+			if (surface.clientRejected.length > 0 && (surface.status !== "streaming" && content.status === "streaming" || serverRejected.length < surface.serverRejected.length)) {
+				surface.clientRejected = [];
+				changed = true;
+			}
+			if (operations.length > 0) {
+				const lastFingerprint = JSON.stringify(operations[operations.length - 1]);
+				const isReplay = operations.some((op) => (0, _copilotkit_shared.getOperationKind)(op) === "deleteSurface");
+				for (let index = book.appliedCount; index < operations.length; index++) {
+					this.applyOperation(surface, operations[index], {
+						index,
+						isReplay
+					});
+					changed = true;
+				}
+				book.appliedCount = operations.length;
+				surface.operations = operations;
+				book.lastFingerprint = lastFingerprint;
+			}
+			if (surface.status !== content.status || surface.target !== content.target || surface.serverRejected.length !== serverRejected.length) {
+				surface.status = content.status;
+				surface.target = content.target;
+				surface.serverRejected = serverRejected;
+				changed = true;
+			}
+			if (changed) this.notify();
+		}
+		/** The surface of a `key` (see `surfaceKey`), unless it is deleted. */
+		getSurfaceByKey(key) {
+			const surface = this.surfaces.get(key);
+			return surface && !surface.deleted ? surface : void 0;
+		}
+		getSurface(threadId, surfaceId) {
+			const surface = this.surfaces.get(surfaceKey(threadId, surfaceId));
+			return surface && !surface.deleted ? surface : void 0;
+		}
+		getSurfaceForTarget(target, threadId = this.activeThreadId) {
+			if (!threadId) return void 0;
+			let latest;
+			for (const surface of this.surfaces.values()) {
+				if (surface.threadId !== threadId || surface.target !== target || surface.deleted) continue;
+				if (!latest || surface.createdAt > latest.createdAt) latest = surface;
+			}
+			return latest;
+		}
+		/**
+		* 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, surfaceId) {
+			const surface = this.surfaces.get(surfaceKey(threadId, surfaceId));
+			return surface?.failed ? surface : void 0;
+		}
+		/**
+		* 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) {
+			const described = {};
+			for (const surface of this.surfaces.values()) {
+				if (surface.threadId !== threadId) continue;
+				const owned = this.owned.get(surface.key);
+				const rejections = [...surface.serverRejected, ...surface.clientRejected];
+				const status = this.deletedKeys.has(surface.key) ? "deleted" : surface.failed ? "failed" : void 0;
+				described[surface.surfaceId] = {
+					target: surface.target,
+					...owned && owned.size > 0 ? { dataModel: Object.fromEntries(owned) } : {},
+					...rejections.length > 0 && status !== "deleted" ? { rejected: summarizeRejections(rejections) } : {},
+					...status ? { status } : {}
+				};
+			}
+			return described;
+		}
+		/** Every surface that is not deleted, oldest first, for the inspector. */
+		debugSurfaces() {
+			return [...this.surfaces.values()].filter((surface) => !surface.deleted).sort((a, b) => a.createdAt - b.createdAt).map((surface) => ({
+				surfaceId: surface.surfaceId,
+				threadId: surface.threadId,
+				agentId: surface.agentId,
+				target: surface.target,
+				status: surface.status,
+				operations: surface.operations,
+				dataModel: surface.model.dataModel.get("/"),
+				userValues: Object.fromEntries(this.owned.get(surface.key) ?? []),
+				rejected: [...surface.serverRejected.map((r) => ({
+					...r,
+					source: "runtime"
+				})), ...surface.clientRejected.map((r) => ({
+					...r,
+					source: "browser"
+				}))]
+			}));
+		}
+		/**
+		* 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, options = {}) {
+			const registration = { ...options };
+			const registrations = this.targets.get(id) ?? /* @__PURE__ */ new Set();
+			registrations.add(registration);
+			this.targets.set(id, registrations);
+			this.notify();
+			let released = false;
+			return () => {
+				if (released) return;
+				released = true;
+				registrations.delete(registration);
+				if (registrations.size === 0) this.targets.delete(id);
+				this.notify();
+			};
+		}
+		/**
+		* The mounted targets. Each has the description and the component list of
+		* its earliest mount that has one.
+		*/
+		getMountedTargets() {
+			const mounted = [];
+			for (const [id, registrations] of this.targets) {
+				const description = [...registrations].find((registration) => registration.description !== void 0)?.description;
+				const components = this.targetComponents(id);
+				mounted.push({
+					id,
+					...description === void 0 ? {} : { description },
+					...components === void 0 ? {} : { components: [...components] }
+				});
+			}
+			return mounted;
+		}
+		/**
+		* The component list of the earliest mount of `id` that has one.
+		* `undefined` when no mount of `id` limits its components.
+		*/
+		targetComponents(id) {
+			return [...this.targets.get(id) ?? /* @__PURE__ */ new Set()].find((registration) => registration.components !== void 0)?.components;
+		}
+		/** The components that `validateOperation` allows on a surface. */
+		allowedComponentsFor(surface) {
+			const components = this.targetComponents(surface.target);
+			return components === void 0 ? void 0 : {
+				target: surface.target,
+				names: new Set(components)
+			};
+		}
+		/** Sets one state key. Notifies only when the value changed. */
+		setState(key, value) {
+			if (Object.hasOwn(this.state, key) && Object.is(this.state[key], value)) return;
+			this.state = {
+				...this.state,
+				[key]: value
+			};
+			this.notify();
+		}
+		/** Removes one state key. Notifies only when the key was set. */
+		removeState(key) {
+			if (!Object.hasOwn(this.state, key)) return;
+			const { [key]: _removed, ...rest } = this.state;
+			this.state = rest;
+			this.notify();
+		}
+		/**
+		* 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, surfaceIds) {
+			const keys = new Set(surfaceIds.map((id) => surfaceKey(threadId, id)));
+			for (const key of keys) if (keys.size > 1) this.linked.set(key, keys);
+			else this.linked.delete(key);
+		}
+		/**
+		* 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, path, value) {
+			const normalized = normalizePath(path);
+			const forbidden = normalized.split("/").find((segment) => FORBIDDEN_SEGMENTS.has(segment));
+			if (forbidden !== void 0) throw new Error(`[generativeUI] path segment "${forbidden}" is not allowed in "${path}".`);
+			for (const target of this.linked.get(key) ?? [key]) this.writeOwnedValue(target, normalized, value);
+		}
+		writeOwnedValue(key, path, value) {
+			const surface = this.surfaces.get(key);
+			if (!surface || surface.deleted) return;
+			surface.model.dataModel.set(path, structuredClone(value));
+			const owned = this.owned.get(key) ?? /* @__PURE__ */ new Map();
+			owned.set(path, structuredClone(value));
+			this.owned.set(key, owned);
+		}
+		/**
+		* Writes the user-owned values into the new, empty data model of a rebuilt
+		* surface. The agent operations are applied after it.
+		*/
+		restoreOwnedValues(surface) {
+			const owned = this.owned.get(surface.key) ?? /* @__PURE__ */ new Map();
+			for (const [path, value] of owned) surface.model.dataModel.set(path, structuredClone(value));
+		}
+		/**
+		* 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.
+		*/
+		mergeOwnedValues(key, path, value) {
+			const merged = { value: structuredClone(value) };
+			const owned = this.owned.get(key);
+			if (!owned) return merged;
+			const ownedPaths = [...owned.keys()];
+			if (ownedPaths.some((ownedPath) => isAtOrBelow(path, ownedPath))) return void 0;
+			const below = ownedPaths.filter((ownedPath) => isAtOrBelow(ownedPath, path));
+			if (below.length === 0) return merged;
+			const scratch = new _a2ui_web_core_v0_9.DataModel({ value: merged.value });
+			const prefix = path === "/" ? "" : path;
+			for (const ownedPath of below) {
+				const relative = ownedPath.slice(prefix.length);
+				scratch.set(`/value${relative}`, structuredClone(owned.get(ownedPath)));
+			}
+			return { value: scratch.get("/value") };
+		}
+		extendsApplied(book, operations) {
+			if (operations.length < book.appliedCount) return false;
+			if (book.appliedCount === 0) return true;
+			return JSON.stringify(operations[book.appliedCount - 1]) === book.lastFingerprint;
+		}
+		createSurface(key, threadId, agentId, content) {
+			return {
+				key,
+				threadId,
+				surfaceId: content.surfaceId,
+				agentId,
+				model: new _a2ui_web_core_v0_9.SurfaceModel(content.surfaceId, this.webCoreCatalog),
+				createdAt: ++creationCounter,
+				target: content.target,
+				status: content.status,
+				deleted: false,
+				failed: false,
+				serverRejected: content.rejected ?? [],
+				clientRejected: [],
+				operations: []
+			};
+		}
+		disposeSurface(key) {
+			this.surfaces.get(key)?.model.dispose();
+			this.surfaces.delete(key);
+			this.bookkeeping.delete(key);
+		}
+		/**
+		* 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.
+		*/
+		closeSurface(surface) {
+			surface.deleted = true;
+			surface.model.dispose();
+			surface.model = new _a2ui_web_core_v0_9.SurfaceModel(surface.surfaceId, this.webCoreCatalog);
+			this.owned.delete(surface.key);
+			this.linked.delete(surface.key);
+		}
+		/** The surfaces of a thread that a part of `surfaceId` reads, for tests. */
+		getLinkedSurfaceIds(threadId, surfaceId) {
+			const keys = this.linked.get(surfaceKey(threadId, surfaceId));
+			if (!keys) return [surfaceId];
+			const prefix = `${threadId}::`;
+			return [...keys].map((key) => key.slice(prefix.length));
+		}
+		/**
+		* 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.
+		*/
+		dropAppSetKeys(op) {
+			const kind = (0, _copilotkit_shared.getOperationKind)(op);
+			if (kind !== "updateComponents" && kind !== "createSurface") return op;
+			const record = op;
+			const payload = record[kind];
+			const nodes = payload?.components;
+			if (!Array.isArray(nodes)) return op;
+			return {
+				...record,
+				[kind]: {
+					...payload,
+					components: nodes.map((node) => this.dropAppSetNodeKeys(node))
+				}
+			};
+		}
+		dropAppSetNodeKeys(node) {
+			if (typeof node !== "object" || node === null || !("component" in node)) return node;
+			const { component } = node;
+			if (typeof component !== "string") return node;
+			const definition = this.ui.components.get(component);
+			if (!definition) return node;
+			return Object.fromEntries(Object.entries(node).filter(([key]) => !Object.hasOwn(definition.selectors, key) && !Object.hasOwn(definition.eventFunctions, key)));
+		}
+		/**
+		* 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.
+		*/
+		surfacesFor(surface, kind, position) {
+			const isFirstCreate = kind === "createSurface" && position.index === 0;
+			const exists = !surface.deleted && !isFirstCreate;
+			const isRecreate = this.deletedKeys.has(surface.key) && !position.isReplay;
+			const isUsedAgain = position.index > 0 || isRecreate;
+			return {
+				knownSurfaces: new Set(exists ? [surface.surfaceId] : []),
+				createdSurfaces: new Set(isUsedAgain ? [surface.surfaceId] : [])
+			};
+		}
+		applyOperation(surface, received, position) {
+			const { index } = position;
+			const kind = (0, _copilotkit_shared.getOperationKind)(received);
+			if (kind === "callRendererFunction") return;
+			const reject = (reason) => {
+				if (kind === "createSurface" && index === 0) {
+					this.closeSurface(surface);
+					surface.failed = true;
+				}
+				surface.clientRejected.push({
+					index,
+					reason
+				});
+				this.options.onOperationRejected?.({
+					surfaceId: surface.surfaceId,
+					index,
+					reason
+				});
+			};
+			const targetId = (0, _copilotkit_shared.getOperationSurfaceId)(received);
+			if (targetId !== void 0 && targetId !== surface.surfaceId) return reject(`operation is for surface "${targetId}", not "${surface.surfaceId}"`);
+			const op = this.dropAppSetKeys(received);
+			const validation = (0, _copilotkit_shared.validateOperation)(op, {
+				manifest: {
+					catalogId: this.ui.id,
+					catalogIds: catalogIdsOf(this.ui),
+					components: this.ui.manifestComponents
+				},
+				...this.surfacesFor(surface, kind, position),
+				allowedComponents: this.allowedComponentsFor(surface)
+			});
+			if (!validation.ok) return reject(validation.reason);
+			const typed = op;
+			if ("createSurface" in typed) {
+				const { dataModel, components = [] } = typed.createSurface;
+				const problem = this.nodesProblem(components);
+				if (problem) return reject(problem);
+				if (dataModel) {
+					const failure = this.writeAgentData(surface, "/", dataModel);
+					if (failure) return reject(failure);
+				}
+				for (const node of components) this.upsertNode(surface.model, node);
+				return;
+			}
+			if ("updateComponents" in typed) {
+				const nodes = typed.updateComponents.components;
+				const problem = this.nodesProblem(nodes);
+				if (problem) return reject(problem);
+				for (const node of nodes) this.upsertNode(surface.model, node);
+				return;
+			}
+			if ("updateDataModel" in typed) {
+				const { path = "/", value } = typed.updateDataModel;
+				const written = value === null ? void 0 : value;
+				const failure = this.writeAgentData(surface, normalizePath(path), written);
+				if (failure) return reject(failure);
+				return;
+			}
+			if ("deleteSurface" in typed) {
+				this.closeSurface(surface);
+				this.deletedKeys.add(surface.key);
+			}
+		}
+		/** The first node with props of the wrong type, as a reason. */
+		nodesProblem(nodes) {
+			for (const node of nodes) {
+				const problem = this.checkNodeProps(node);
+				if (problem) return `component "${node.id}": ${problem}`;
+			}
+		}
+		/**
+		* 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`.
+		*/
+		writeAgentData(surface, path, value) {
+			try {
+				const merged = this.mergeOwnedValues(surface.key, path, value);
+				if (merged) surface.model.dataModel.set(path, merged.value);
+				return;
+			} catch (error) {
+				return error instanceof Error ? error.message : String(error);
+			}
+		}
+		checkNodeProps(node) {
+			const definition = this.ui.components.get(node.component);
+			if (!definition) return `unknown component "${node.component}"`;
+			const { id: _id, component: _component, ...rest } = node;
+			const dataProps = Object.fromEntries(Object.entries(rest).filter(([key]) => !definition.events?.[key] && !definition.slots?.[key] && !_copilotkit_shared.A2UI_COMPONENT_ENVELOPE_KEYS.has(key)));
+			if (!definition.props) return void 0;
+			const unknownNow = new Set(Object.keys(definition.selectors));
+			const literals = {};
+			for (const [key, value] of Object.entries(dataProps)) if (containsDynamicValue(value)) unknownNow.add(key);
+			else literals[key] = value;
+			let result = validateSchemaSync(definition.props, literals);
+			if (!result.success) {
+				const unset = withoutRejectedNulls(literals, result.issues);
+				if (unset) result = validateSchemaSync(definition.props, unset);
+			}
+			if (result.success) return void 0;
+			const issues = result.issues.filter((issue) => {
+				const key = issueKey(issue);
+				return key === void 0 ? isAsyncIssue(issue) : !unknownNow.has(key);
+			});
+			return issues.length > 0 ? formatIssues(issues) : void 0;
+		}
+		upsertNode(model, node) {
+			const { id, component, ...rest } = node;
+			const properties = structuredClone(rest);
+			const existing = model.componentsModel.get(id);
+			if (existing && existing.type === component) {
+				existing.properties = properties;
+				return;
+			}
+			if (existing) model.componentsModel.removeComponent(id);
+			model.componentsModel.addComponent(new _a2ui_web_core_v0_9.ComponentModel(id, component, properties));
+		}
+	};
+
+//#endregion
+//#region src/v2/generative-ui/use-generative-ui-root.ts
+	const isDevelopment = () => process.env.NODE_ENV !== "production";
+	/** At most this many function follow-up runs for each user turn. */
+	const MAX_FUNCTION_FOLLOW_UPS = 5;
+	function ingestMessages(manager, agent, messages) {
+		if (!agent.threadId) return;
+		for (const message of messages) if (message.role === "activity" && message.activityType === _copilotkit_shared.GENERATIVE_UI_ACTIVITY_TYPE) manager.ingest(agent.threadId, agent.agentId, message.content);
+	}
+	/** What the envelope of a run says, from the provider config. */
+	function envelopeOptionsFor(config) {
+		if (config.transport === "markdown") return {
+			transport: "markdown",
+			includeCatalog: config.includeCatalog !== false,
+			contextSent: config.sendContext !== false
+		};
+		return {
+			transport: "tool",
+			includeCatalog: true,
+			contextSent: false
+		};
+	}
+	/**
+	* The components of a surface as one `updateComponents` operation, so that
+	* the label of the component that sent an event can be found.
+	*/
+	function surfaceComponents(surface) {
+		const components = [...surface.model.componentsModel.entries].map(([id, model]) => ({
+			...model.properties,
+			id,
+			component: model.type
+		}));
+		return [{
+			version: _copilotkit_shared.A2UI_VERSION,
+			updateComponents: {
+				surfaceId: surface.surfaceId,
+				components
+			}
+		}];
+	}
+	/** True when `value` names a `functionCallId`. */
+	function hasFunctionCallId(value) {
+		return typeof value === "object" && value !== null && "functionCallId" in value && typeof value.functionCallId === "string" && value.functionCallId !== "";
+	}
+	/** The `functionCallId` that a developer message answers, if any. */
+	function answeredCallId(content) {
+		if (!content.includes("rendererFunctionResponse")) return void 0;
+		try {
+			const parsed = JSON.parse(content);
+			const response = typeof parsed === "object" && parsed !== null && "rendererFunctionResponse" in parsed ? parsed.rendererFunctionResponse : void 0;
+			return hasFunctionCallId(response) ? response.functionCallId : void 0;
+		} catch {
+			return;
+		}
+	}
+	/** The function calls that a developer message in `messages` answers. */
+	function answeredCallIds(messages) {
+		const ids = /* @__PURE__ */ new Set();
+		for (const message of messages) {
+			if (message.role !== "developer") continue;
+			const id = answeredCallId(message.content);
+			if (id !== void 0) ids.add(id);
+		}
+		return ids;
+	}
+	/** The id of the last user message. A user turn starts with it. */
+	function lastUserMessageId(messages) {
+		for (let index = messages.length - 1; index >= 0; index--) {
+			const message = messages[index];
+			if (message?.role === "user") return message.id;
+		}
+	}
+	/** The function calls of the tool transport: its function-call activities. */
+	function activityFunctionCalls(messages) {
+		const requests = [];
+		for (const message of messages) {
+			if (!(message.role === "activity" && message.activityType === _copilotkit_shared.GENERATIVE_UI_FUNCTION_CALL_ACTIVITY_TYPE) || !hasFunctionCallId(message.content)) continue;
+			requests.push({
+				functionCallId: message.content.functionCallId,
+				operation: {
+					version: _copilotkit_shared.A2UI_VERSION,
+					callRendererFunction: message.content
+				}
+			});
+		}
+		return requests;
+	}
+	/** The function calls of the markdown transport: its fence lines. */
+	function markdownFunctionCalls(calls) {
+		const requests = [];
+		for (const { operation } of calls) {
+			const payload = operation.callRendererFunction;
+			if (!hasFunctionCallId(payload)) continue;
+			requests.push({
+				functionCallId: payload.functionCallId,
+				operation
+			});
+		}
+		return requests;
+	}
+	/** The text of a `rendererFunctionResponse` developer message. */
+	function responseContent(response) {
+		return JSON.stringify({
+			version: _copilotkit_shared.A2UI_VERSION,
+			rendererFunctionResponse: response
+		});
+	}
+	function errorAnswer(functionCallId, code, message) {
+		return {
+			content: responseContent({
+				functionCallId,
+				error: {
+					code,
+					message
+				}
+			}),
+			followUp: true
+		};
+	}
+	const overCapAnswer = (functionCallId) => ({
+		content: responseContent({
+			functionCallId,
+			error: {
+				code: "follow_up_limit",
+				message: `The function did not run. A user turn can have at most ${MAX_FUNCTION_FOLLOW_UPS} function follow-up runs. Wait for the next user message.`
+			}
+		}),
+		followUp: false
+	});
+	/**
+	* Runs the functions that the agent calls with `callRendererFunction`, for
+	* both transports, and answers each call.
+	*
+	* - Each `functionCallId` runs once for each thread. A replay, a sync of
+	*   the same messages again, or a call that already has an answer message
+	*   does not run it again.
+	* - The answer is a hidden developer message with a `rendererFunctionResponse`.
+	*   The answers go to the agent only when it is not running. Then one
+	*   follow-up run starts for all of them.
+	* - A user turn has at most {@link MAX_FUNCTION_FOLLOW_UPS} follow-up runs.
+	*   A call after that does not run. It gets a `follow_up_limit` error and
+	*   starts no follow-up run.
+	*/
+	function createFunctionCallRunner(options) {
+		const { copilotkit, dispatcher, manifest } = options;
+		const threads = /* @__PURE__ */ new Map();
+		const threadState = (threadId) => {
+			let state = threads.get(threadId);
+			if (!state) {
+				state = {
+					done: /* @__PURE__ */ new Set(),
+					pending: [],
+					turn: void 0,
+					followUps: 0,
+					flushing: false
+				};
+				threads.set(threadId, state);
+			}
+			return state;
+		};
+		const answer = async (request) => {
+			const { functionCallId } = request;
+			const validation = (0, _copilotkit_shared.validateOperation)(request.operation, {
+				manifest,
+				knownSurfaces: /* @__PURE__ */ new Set()
+			});
+			if (!validation.ok) return errorAnswer(functionCallId, "invalid_arguments", validation.reason);
+			const operation = request.operation;
+			if (!("callRendererFunction" in operation)) return errorAnswer(functionCallId, "invalid_arguments", "the operation is not a callRendererFunction");
+			const { callFunction } = operation.callRendererFunction;
+			const name = callFunction["@call"];
+			const result = await dispatcher.invoke(name, callFunction.args ?? {}, { functionCallId });
+			if (!result.ok) return errorAnswer(functionCallId, result.error.code, result.error.message);
+			try {
+				return {
+					content: responseContent({
+						functionCallId,
+						value: result.result ?? null
+					}),
+					followUp: true
+				};
+			} catch (cause) {
+				return errorAnswer(functionCallId, "handler_failed", `The result of "${name}" is not JSON: ${cause instanceof Error ? cause.message : String(cause)}`);
+			}
+		};
+		/**
+		* Adds the pending answers of a thread to the agent, then starts one
+		* follow-up run. It waits while the agent runs: the next read of the
+		* thread, at the end of the run, flushes again.
+		*/
+		const flush = async (agent, threadId, state) => {
+			if (state.flushing) return;
+			state.flushing = true;
+			try {
+				while (state.pending.length > 0) {
+					const batch = [...state.pending];
+					const answers = await Promise.all(batch);
+					await copilotkit.waitForPendingFrameworkUpdates();
+					if (agent.isRunning || agent.threadId !== threadId) return;
+					if (state.pending.length > batch.length) continue;
+					state.pending = [];
+					for (const { content } of answers) agent.addMessage({
+						id: (0, _copilotkit_shared.randomUUID)(),
+						role: "developer",
+						content
+					});
+					if (!answers.some((item) => item.followUp)) continue;
+					state.followUps++;
+					await copilotkit.runAgent({ agent });
+				}
+			} catch (error) {
+				if (isDevelopment()) console.warn("[generativeUI] function follow-up run failed:", error);
+			} finally {
+				state.flushing = false;
+			}
+		};
+		return { run(agent, requests, messages, running) {
+			const { threadId } = agent;
+			if (!threadId) return;
+			const state = threadState(threadId);
+			const turn = lastUserMessageId(messages);
+			if (turn !== state.turn) {
+				state.turn = turn;
+				state.followUps = 0;
+			}
+			const isNew = (request) => !state.done.has(request.functionCallId);
+			const fresh = requests.filter(isNew);
+			const answered = fresh.length > 0 ? answeredCallIds(messages) : /* @__PURE__ */ new Set();
+			for (const request of fresh) {
+				const { functionCallId } = request;
+				if (state.done.has(functionCallId)) continue;
+				state.done.add(functionCallId);
+				if (answered.has(functionCallId)) continue;
+				const isOverCap = state.followUps >= MAX_FUNCTION_FOLLOW_UPS;
+				state.pending.push(isOverCap ? Promise.resolve(overCapAnswer(functionCallId)) : answer(request));
+			}
+			if (!running) flush(agent, threadId, state);
+		} };
+	}
+	/** Provider-side wiring: manager, dispatcher, agent subscriptions, envelope. */
+	function useGenerativeUIRoot(copilotkit, config) {
+		const configRef = (0, react.useRef)(config);
+		configRef.current = config;
+		const ui = config?.ui;
+		const transport = config?.transport ?? "tool";
+		const theme = useShallowStableRef(config?.theme);
+		const core = (0, react.useMemo)(() => {
+			if (!ui) return null;
+			const reportError = (info) => {
+				try {
+					configRef.current?.errorBoundary?.onError?.(info);
+				} catch (hostError) {
+					if (isDevelopment()) console.error("[generativeUI] errorBoundary.onError threw:", hostError);
+				}
+				if (isDevelopment()) console.warn(`[generativeUI] ${info.kind} error in ${info.surfaceId}${info.componentId ? `/${info.componentId}` : ""}: ${info.error?.message}`);
+			};
+			const manager = new GenerativeUISurfaceManager(ui, { onOperationRejected: ({ surfaceId, index, reason }) => reportError({
+				kind: "operation",
+				surfaceId,
+				error: /* @__PURE__ */ new Error(`operation ${index} rejected: ${reason}`)
+			}) });
+			const dispatcher = createGenerativeUIDispatcher({
+				getDeclared: () => ui.functions,
+				onError: ({ name, origin, error }) => {
+					if ("functionCallId" in origin) {
+						if (isDevelopment()) console.warn(`[generativeUI] function call ${origin.functionCallId} to "${name}" failed: ${error.message}`);
+						return;
+					}
+					reportError({
+						kind: "function",
+						...origin,
+						error
+					});
+				}
+			});
+			const functionCalls = createFunctionCallRunner({
+				copilotkit,
+				dispatcher,
+				manifest: {
+					catalogId: ui.id,
+					catalogIds: catalogIdsOf(ui),
+					components: ui.manifestComponents
+				}
+			});
+			const forwardingAgents = /* @__PURE__ */ new Set();
+			/**
+			* The action of a user event, as an envelope entry scoped to the agent
+			* the user acted on, for the run that the event starts: the structured
+			* form of the user message. It is set before the run starts and dropped
+			* when the run is over, so a suggestion request or a follow-up run
+			* (both read the properties with no run start) does not carry the same
+			* action again, and another agent never gets a click meant for this one.
+			* The entry comes after the shared envelope, so it wins for its agent;
+			* `refreshActions` keeps it last when the shared envelope is set again.
+			*/
+			const actions = /* @__PURE__ */ new Map();
+			const dropAction = (agent) => {
+				const entry = actions.get(agent);
+				if (!entry) return;
+				entry.subscription.unsubscribe();
+				copilotkit.removeScopedProperties(entry.id);
+				actions.delete(agent);
+			};
+			const setAction = (agent, action) => {
+				const previous = actions.get(agent);
+				previous?.subscription.unsubscribe();
+				if (previous) copilotkit.removeScopedProperties(previous.id);
+				actions.delete(agent);
+				const latest = configRef.current;
+				if (!latest) return;
+				const envelope = buildGenerativeUIEnvelope({
+					ui,
+					manager,
+					dispatcher
+				}, agent.threadId, {
+					...envelopeOptionsFor(latest),
+					action
+				});
+				const id = copilotkit.addScopedProperties({
+					properties: { [_copilotkit_shared.COPILOTKIT_FORWARDED_PROPS_KEY]: { ui: envelope } },
+					agentIds: agent.agentId === void 0 ? latest.agentIds : [agent.agentId]
+				});
+				const subscription = agent.subscribe({
+					onRunFinalized: () => dropAction(agent),
+					onRunFailed: () => dropAction(agent)
+				});
+				actions.set(agent, {
+					id,
+					action,
+					subscription
+				});
+			};
+			const refreshActions = () => {
+				for (const [agent, { action }] of [...actions]) setAction(agent, action);
+			};
+			const dropAllActions = () => {
+				for (const agent of [...actions.keys()]) dropAction(agent);
+			};
+			const forwardEvent = async (event, agentId) => {
+				const fail = (message) => {
+					const error = new GenerativeUIError("event_forward_failed", message);
+					reportError({
+						kind: "event",
+						surfaceId: event.surfaceId,
+						componentId: event.componentId,
+						error
+					});
+					return {
+						ok: false,
+						error
+					};
+				};
+				const agent = copilotkit.getAgent(agentId ?? _copilotkit_shared.DEFAULT_AGENT_ID);
+				if (!agent) return fail(`No agent "${agentId}" to receive "${event.name}"`);
+				if (agent.isRunning || forwardingAgents.has(agent)) return {
+					ok: false,
+					error: new GenerativeUIError("agent_busy", `"${event.name}" was not sent: the agent is running`)
+				};
+				forwardingAgents.add(agent);
+				try {
+					const surface = agent.threadId ? manager.getSurface(agent.threadId, event.surfaceId) : void 0;
+					const resolveLabel = surface ? createComponentLabelResolver(surfaceComponents(surface)) : void 0;
+					agent.addMessage({
+						id: (0, _copilotkit_shared.randomUUID)(),
+						role: "user",
+						content: buildActionMessageText(event, resolveLabel)
+					});
+					setAction(agent, (0, _copilotkit_shared.toA2UIActionMessage)(event));
+					await copilotkit.runAgent({ agent });
+					return {
+						ok: true,
+						result: void 0
+					};
+				} catch (cause) {
+					return fail(`Forwarding "${event.name}" failed: ${cause instanceof Error ? cause.message : String(cause)}`);
+				} finally {
+					forwardingAgents.delete(agent);
+					dropAction(agent);
+				}
+			};
+			return {
+				manager,
+				dispatcher,
+				ui,
+				forwardEvent,
+				reportError,
+				functionCalls,
+				refreshActions,
+				dropAllActions
+			};
+		}, [ui, copilotkit]);
+		const runtime = (0, react.useMemo)(() => {
+			if (!core) return null;
+			const { manager, dispatcher, forwardEvent, reportError } = core;
+			return {
+				manager,
+				dispatcher,
+				ui: core.ui,
+				forwardEvent,
+				reportError,
+				transport,
+				theme,
+				get config() {
+					return configRef.current ?? { ui: core.ui };
+				},
+				get errorFallback() {
+					return configRef.current?.errorBoundary?.fallback;
+				}
+			};
+		}, [
+			core,
+			transport,
+			theme
+		]);
+		(0, react.useEffect)(() => {
+			if (!core) return;
+			const watched = /* @__PURE__ */ new WeakSet();
+			const agentSubscriptions = [];
+			let envelopeId;
+			const debug = createGenerativeUIDebugSource(core, () => {
+				const latest = configRef.current ?? { ui: core.ui };
+				return {
+					options: envelopeOptionsFor(latest),
+					agentIds: latest.agentIds
+				};
+			});
+			copilotkit.ɵsetGenerativeUIDebugSource(debug.source);
+			const removeEnvelope = () => {
+				if (envelopeId === void 0) return;
+				copilotkit.removeScopedProperties(envelopeId);
+				envelopeId = void 0;
+			};
+			/**
+			* Sets the shared envelope of the run. The action entries of the agents
+			* with a user event under way (see `forwardEvent`) are set again after
+			* it, so they stay the last entries and win for their agents.
+			*/
+			const setEnvelope = (agent, latest) => {
+				removeEnvelope();
+				const run = describeGenerativeUIRun(core, agent.threadId, envelopeOptionsFor(latest));
+				envelopeId = copilotkit.addScopedProperties({
+					properties: { [_copilotkit_shared.COPILOTKIT_FORWARDED_PROPS_KEY]: { ui: run.envelope } },
+					agentIds: latest.agentIds
+				});
+				core.refreshActions();
+				if (!latest.agentIds || latest.agentIds.includes(agent.agentId ?? "")) debug.recordRun({
+					...run,
+					agentId: agent.agentId,
+					threadId: agent.threadId,
+					startedAt: Date.now()
+				});
+			};
+			/**
+			* The tool transport reads the surface activity messages. The markdown
+			* transport reads the ```a2ui fences of the assistant messages, and
+			* builds the surfaces of the thread from them again on each change.
+			* Both give their function calls to the one runner.
+			*/
+			const readMessages = (agent, messages, running) => {
+				const requests = activityFunctionCalls(messages);
+				const { threadId } = agent;
+				if (configRef.current?.transport !== "markdown") ingestMessages(core.manager, agent, messages);
+				else if (threadId) {
+					core.manager.setActiveThread(threadId);
+					const calls = getMarkdownSurfaceSource(core).sync(threadId, agent.agentId, messages, { running });
+					requests.push(...markdownFunctionCalls(calls));
+				}
+				core.functionCalls.run(agent, requests, messages, running);
+			};
+			const subscription = copilotkit.subscribe({ onAgentRunStarted: ({ agent }) => {
+				core.manager.setActiveThread(agent.threadId);
+				const latest = configRef.current;
+				if (latest) setEnvelope(agent, latest);
+				if (!watched.has(agent)) {
+					watched.add(agent);
+					agentSubscriptions.push(agent.subscribe({
+						onMessagesChanged: ({ messages }) => readMessages(agent, messages, agent.isRunning),
+						onRunFinalized: () => readMessages(agent, agent.messages, false),
+						onRunFailed: () => readMessages(agent, agent.messages, false)
+					}));
+				}
+				readMessages(agent, agent.messages, true);
+			} });
+			return () => {
+				subscription.unsubscribe();
+				for (const s of agentSubscriptions) s.unsubscribe();
+				core.dropAllActions();
+				removeEnvelope();
+				if (copilotkit.ɵgenerativeUIDebugSource === debug.source) copilotkit.ɵsetGenerativeUIDebugSource(void 0);
+			};
+		}, [core, copilotkit]);
+		useGenerativeUIMarkdownContext(copilotkit, core, {
+			enabled: config?.transport === "markdown" && config.sendContext !== false,
+			agentIds: config?.agentIds
+		});
+		return runtime;
+	}
+
+//#endregion
+//#region src/v2/generative-ui/runtime-context.ts
+	const GenerativeUIRuntimeContext = (0, react.createContext)(null);
+	function useGenerativeUIRuntime() {
+		return (0, react.useContext)(GenerativeUIRuntimeContext);
+	}
+	function useRequiredGenerativeUIRuntime() {
+		const runtime = (0, react.useContext)(GenerativeUIRuntimeContext);
+		if (!runtime) throw new Error("Generative UI components must be rendered inside <CopilotKitProvider generativeUI={{ ui }}>.");
+		return runtime;
+	}
+	/**
+	* Reports an error without ever throwing: `reportError` reaches host code
+	* (`onError`), and a throwing host callback must not break rendering or an
+	* event handler.
+	*/
+	function reportErrorSafely(runtime, info) {
+		try {
+			runtime.reportError(info);
+		} catch {}
+	}
+	const GenerativeUINodeContext = (0, react.createContext)(null);
+
+//#endregion
+//#region src/v2/generative-ui/hooks.ts
+	const noopSubscribe$1 = () => () => {};
+	const zero = () => 0;
+	/** Re-renders on any surface-manager change. */
+	function useManagerVersion(runtime) {
+		return (0, react.useSyncExternalStore)(runtime?.manager.subscribe ?? noopSubscribe$1, runtime?.manager.getVersion ?? zero, zero);
+	}
+
+//#endregion
+//#region src/v2/generative-ui/boundaries.tsx
+	function DefaultNodeFallback({ message, componentId, retry }) {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			role: "alert",
+			"data-generative-ui-error": componentId,
+			style: {
+				border: "1px solid #fca5a5",
+				background: "#fef2f2",
+				color: "#991b1b",
+				borderRadius: 8,
+				padding: "8px 12px",
+				fontSize: 13
+			},
+			children: [
+				"Couldn’t display this part: ",
+				message,
+				retry && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("button", {
+					type: "button",
+					onClick: retry,
+					style: {
+						marginLeft: 8,
+						textDecoration: "underline"
+					},
+					children: "Retry"
+				})
+			]
+		});
+	}
+	/**
+	* A child that has not streamed yet renders nothing. The prose keeps
+	* streaming above the surface, and each component appears as soon as it is
+	* complete. A grey block in its place would read as a broken layout.
+	*/
+	function NodePlaceholder(_props) {
+		return null;
+	}
+	/** Per-node boundary. Resets on retry or a new agent revision, not on data ticks. */
+	var NodeBoundary = class extends react.Component {
+		constructor(..._args) {
+			super(..._args);
+			this.state = {
+				error: null,
+				revision: this.props.revision
+			};
+			this.retry = () => this.setState({ error: null });
+		}
+		static getDerivedStateFromError(error) {
+			return { error };
+		}
+		static getDerivedStateFromProps(props, state) {
+			return props.revision !== state.revision ? {
+				error: null,
+				revision: props.revision
+			} : null;
+		}
+		componentDidCatch(error) {
+			const { runtime, surfaceId, componentId } = this.props;
+			reportErrorSafely(runtime, {
+				kind: "render",
+				surfaceId,
+				componentId,
+				error
+			});
+		}
+		render() {
+			const { error } = this.state;
+			if (!error) return this.props.children;
+			const { runtime, surfaceId, componentId } = this.props;
+			const fallback = runtime.errorFallback;
+			return fallback ? fallback({
+				error,
+				retry: this.retry,
+				surfaceId,
+				componentId
+			}) : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+				message: error.message,
+				componentId,
+				retry: this.retry
+			});
+		}
+	};
+	/** Outer boundary: a failure here must not reach the chat or the host page. */
+	var SurfaceBoundary = class extends react.Component {
+		constructor(..._args2) {
+			super(..._args2);
+			this.state = { error: null };
+		}
+		static getDerivedStateFromError(error) {
+			return { error };
+		}
+		componentDidCatch(error) {
+			reportErrorSafely(this.props.runtime, {
+				kind: "render",
+				surfaceId: this.props.surfaceId,
+				error
+			});
+		}
+		render() {
+			if (!this.state.error) return this.props.children;
+			return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+				message: "this generated UI failed to render",
+				componentId: "surface"
+			});
+		}
+	};
+
+//#endregion
+//#region src/v2/generative-ui/accessibility.ts
+	const LIVE = new Set([
+		"off",
+		"polite",
+		"assertive"
+	]);
+	/**
+	* The accessibility of a component from its resolved `accessibility`
+	* value. Fields of the wrong type are left out: a label that is still a
+	* binding, or a list, names nothing.
+	*/
+	function readAccessibility(value) {
+		if (typeof value !== "object" || value === null || Array.isArray(value)) return;
+		const { label, description, live, hidden } = value;
+		const result = {};
+		if (typeof label === "string" && label !== "") result.label = label;
+		if (typeof description === "string" && description !== "") result.description = description;
+		if (typeof live === "string" && LIVE.has(live)) result.live = live;
+		if (typeof hidden === "boolean") result.hidden = hidden;
+		return Object.keys(result).length > 0 ? result : void 0;
+	}
+	/**
+	* The ARIA attributes for an `accessibility`. `live: "off"` is written out:
+	* a region inherits the live setting of its ancestors, and a `status` role
+	* is live on its own, so only the explicit value silences it.
+	*
+	* @example
+	* ```ts
+	* accessibilityAttributes({ label: "Totals", live: "polite" });
+	* // { "aria-label": "Totals", "aria-live": "polite" }
+	* ```
+	*/
+	function accessibilityAttributes(accessibility) {
+		if (!accessibility) return {};
+		const { label, description, live, hidden } = accessibility;
+		return {
+			...label === void 0 ? {} : { "aria-label": label },
+			...description === void 0 ? {} : { "aria-description": description },
+			...live === void 0 ? {} : { "aria-live": live },
+			...hidden ? { "aria-hidden": true } : {}
+		};
+	}
+	/**
+	* The part of the attributes for the wrapper around a control: hidden and
+	* live cover the label and the control together.
+	*/
+	function wrapperAria(aria) {
+		const { "aria-hidden": hidden, "aria-live": live } = aria;
+		return {
+			...hidden === void 0 ? {} : { "aria-hidden": hidden },
+			...live === void 0 ? {} : { "aria-live": live }
+		};
+	}
+
+//#endregion
+//#region src/v2/generative-ui/events.ts
+/**
+	* The context of a running event binding: it reads the surface data model
+	* and resolves relative paths against the template item of the component.
+	* A function that needs a user gesture (openUrl) is not a value here
+	* either; it runs through the dispatcher as the binding's functionCall.
+	*/
+	function eventContext(surface, basePath) {
+		return {
+			data: surface.model.dataModel,
+			basePath
+		};
+	}
+	/**
+	* A value of an event binding with its dynamic values resolved: `{"@path"}`
+	* bindings and function values, at any depth.
+	*/
+	function resolveValue(surface, basePath, value) {
+		return resolveDynamicValue(value, eventContext(surface, basePath)).value;
+	}
+	/**
+	* The entries of an args or context record, each resolved on its own. The
+	* record is not resolved as a whole, because a record with one `event` or
+	* `functionCall` key would look like an action binding and stay as it is.
+	*/
+	function resolveValues(surface, basePath, values) {
+		return Object.fromEntries(Object.entries(values ?? {}).map(([key, value]) => [key, resolveValue(surface, basePath, value)]));
+	}
+	/**
+	* The `userMessage` of an event binding, as text. A `{"@path"}` or a
+	* function value is resolved. `undefined` when there is no message, or
+	* the value is not a string.
+	*/
+	function resolveUserMessage(surface, basePath, userMessage) {
+		const value = resolveValue(surface, basePath, userMessage);
+		return typeof value === "string" ? value : void 0;
+	}
+	/**
+	* Validates the component's args with the event `parameters`, then runs
+	* `send` with them. Never throws: every failure is reported and becomes
+	* `{ ok: false, error }`.
+	*/
+	async function runEvent(call, send) {
+		const { runtime, surface, componentId, name, parameters, args } = call;
+		const origin = {
+			surfaceId: surface.surfaceId,
+			componentId
+		};
+		try {
+			if (!parameters) return await send(args ?? {}, origin);
+			const result = validateSchema(parameters, args ?? {});
+			const parsed = result instanceof Promise ? await result : result;
+			if (!parsed.success) {
+				const error = new GenerativeUIError("invalid_event_args", `${name}: ${formatIssues(parsed.issues, "args")}`);
+				reportErrorSafely(runtime, {
+					kind: "event",
+					...origin,
+					error
+				});
+				return {
+					ok: false,
+					error
+				};
+			}
+			return await send(parsed.data ?? {}, origin);
+		} catch (cause) {
+			const error = new GenerativeUIError("event_forward_failed", `${name}: ${cause instanceof Error ? cause.message : String(cause)}`);
+			reportErrorSafely(runtime, {
+				kind: "event",
+				...origin,
+				error
+			});
+			return {
+				ok: false,
+				error
+			};
+		}
+	}
+	/**
+	* Runs one call of an event that the model bound: validates the component's
+	* args, merges them with the args from the binding (binding literals win),
+	* then calls a declared function or forwards an agent event. Never throws.
+	*/
+	function invokeBoundEvent(params) {
+		const { runtime, surface, binding, basePath } = params;
+		return runEvent(params, (args, origin) => {
+			const componentArgs = args;
+			if ("functionCall" in binding) return runtime.dispatcher.invoke(binding.functionCall["@call"], {
+				...componentArgs,
+				...resolveValues(surface, basePath, binding.functionCall.args)
+			}, origin);
+			const { event } = binding;
+			const forwarded = {
+				name: event.name,
+				...origin,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+				userMessage: resolveUserMessage(surface, basePath, event.userMessage),
+				context: {
+					...componentArgs,
+					...resolveValues(surface, basePath, event.context)
+				}
+			};
+			return runtime.forwardEvent(forwarded, surface.agentId);
+		});
+	}
+	/**
+	* Runs one call of an event that matches a declared function: validates the
+	* component's args with the event `parameters` (if any), then calls the
+	* function, which validates them with its own schema. Never throws.
+	*/
+	function invokeMatchedEvent(params) {
+		const { runtime, functionName } = params;
+		return runEvent(params, (componentArgs, origin) => runtime.dispatcher.invoke(functionName, componentArgs, origin));
+	}
+
+//#endregion
+//#region src/v2/generative-ui/theme.ts
+/**
+	* The built-in dark values. The light values are the fallbacks in the
+	* components, so a surface is light when no variable is set.
+	*/
+	const DARK_THEME = {
+		"--a2ui-color-text-default": "#ececec",
+		"--a2ui-color-text-prose": "#ececec",
+		"--a2ui-color-text-primary": "#ececec",
+		"--a2ui-color-text-emphasis": "#fff",
+		"--a2ui-color-text-secondary": "#b4b4b4",
+		"--a2ui-color-text-tertiary": "#8e8e8e",
+		"--a2ui-color-text-success": "#4fd1a5",
+		"--a2ui-color-text-info": "#6cb6ff",
+		"--a2ui-color-text-warning": "#e3b341",
+		"--a2ui-color-text-caution": "#e3b341",
+		"--a2ui-color-text-danger": "#ff7b72",
+		"--a2ui-color-text-discovery": "#bc9cff",
+		"--a2ui-color-surface": "#1f1f1f",
+		"--a2ui-color-surface-secondary": "#2a2a2a",
+		"--a2ui-color-surface-tertiary": "#3a3a3a",
+		"--a2ui-color-surface-elevated": "#262626",
+		"--a2ui-color-surface-elevated-secondary": "#2f2f2f",
+		"--a2ui-color-surface-inverted": "#f2f2f2",
+		"--a2ui-color-surface-soft": "#232323",
+		"--a2ui-color-info": "rgba(80, 160, 255, 0.14)",
+		"--a2ui-color-warning": "rgba(240, 180, 60, 0.14)",
+		"--a2ui-color-caution": "rgba(240, 180, 60, 0.14)",
+		"--a2ui-color-success": "rgba(60, 200, 150, 0.14)",
+		"--a2ui-color-danger": "rgba(255, 110, 100, 0.14)",
+		"--a2ui-color-discovery": "rgba(170, 130, 255, 0.14)",
+		"--a2ui-color-info-soft": "rgba(80, 160, 255, 0.08)",
+		"--a2ui-color-warning-soft": "rgba(240, 180, 60, 0.08)",
+		"--a2ui-color-caution-soft": "rgba(240, 180, 60, 0.08)",
+		"--a2ui-color-success-soft": "rgba(60, 200, 150, 0.08)",
+		"--a2ui-color-danger-soft": "rgba(255, 110, 100, 0.08)",
+		"--a2ui-color-discovery-soft": "rgba(170, 130, 255, 0.08)",
+		"--a2ui-color-info-solid": "#3b8eea",
+		"--a2ui-color-warning-solid": "#c99a2e",
+		"--a2ui-color-caution-solid": "#c99a2e",
+		"--a2ui-color-success-solid": "#2fae86",
+		"--a2ui-color-danger-solid": "#e5534b",
+		"--a2ui-color-discovery-solid": "#9a6ff0",
+		"--a2ui-color-border-default": "rgba(255, 255, 255, 0.12)",
+		"--a2ui-color-border-subtle": "rgba(255, 255, 255, 0.06)",
+		"--a2ui-color-border-strong": "#4a4a4a",
+		"--a2ui-color-border-info": "#2f5f8f",
+		"--a2ui-color-border-warning": "#6b5420",
+		"--a2ui-color-border-caution": "#6b5420",
+		"--a2ui-color-border-success": "#1f5f4b",
+		"--a2ui-color-border-danger": "#7a2f2b",
+		"--a2ui-color-border-discovery": "#4f3a80",
+		"--a2ui-color-border-control": "rgba(255, 255, 255, 0.2)",
+		"--a2ui-color-accent": "#f2f2f2",
+		"--a2ui-color-on-accent": "#0d0d0d",
+		"--a2ui-color-panel": "#262626",
+		"--a2ui-color-control": "#2f2f2f",
+		"--a2ui-color-focus": "#3b9bff",
+		"--a2ui-color-shimmer": "rgba(255, 255, 255, 0.12)",
+		"--a2ui-color-chart-cursor": "rgba(255, 255, 255, 0.06)",
+		"--a2ui-color-slider-track": "rgba(255, 255, 255, 0.1)",
+		"--a2ui-color-badge-secondary": "rgba(255, 255, 255, 0.08)",
+		"--a2ui-color-highlight-green": "#1d4a37",
+		"--a2ui-color-highlight-orange": "#4d3418",
+		"--a2ui-color-highlight-pink": "#4d2338",
+		"--a2ui-shadow-xs": "0 1px 2px rgba(0, 0, 0, 0.5)",
+		"--a2ui-shadow-sm": "0 1px 3px rgba(0, 0, 0, 0.5)",
+		"--a2ui-shadow-soft": "0 1px 3px rgba(0, 0, 0, 0.3)",
+		"--a2ui-shadow-md": "0 4px 12px rgba(0, 0, 0, 0.4)"
+	};
+	const VARIABLE_NAME = /^--a2ui-[a-z0-9-]+$/;
+	const UNSAFE_VALUE = /[{};<>]/;
+	/** Matches the `dark` class on an ancestor of a surface, or on the surface. */
+	const DARK = ":where(.dark)";
+	/** The default dark values, as a rule that any theme rule beats. */
+	const DARK_THEME_CSS = `:where(.dark .a2ui-surface,.a2ui-surface.dark){${declarations(DARK_THEME)}}`;
+	function declarations(values) {
+		return Object.entries(values ?? {}).filter(([name, value]) => VARIABLE_NAME.test(name) && typeof value === "string" && !UNSAFE_VALUE.test(value)).map(([name, value]) => `${name}:${value}`).join(";");
+	}
+	/** A short, stable id for a stylesheet. */
+	function hashOf(text) {
+		let hash = 5381;
+		for (let index = 0; index < text.length; index++) hash = hash * 33 ^ text.charCodeAt(index);
+		return `t${(hash >>> 0).toString(36)}`;
+	}
+	/**
+	* The stylesheet of a theme: its values on the surfaces that carry its id,
+	* then its dark values in dark mode. `undefined` when the theme sets no
+	* variable. Values that could break out of the rule are left out.
+	*
+	* @example
+	* ```ts
+	* themeStyleSheet({ "--a2ui-color-accent": "red" });
+	* // { id: "t…", css: '.a2ui-surface[data-a2ui-theme="t…"]{--a2ui-color-accent:red}' }
+	* ```
+	*/
+	function themeStyleSheet(theme) {
+		const { dark, ...base } = theme ?? {};
+		const both = declarations(base);
+		const darkOnly = declarations(dark);
+		if (!both && !darkOnly) return void 0;
+		const id = hashOf(`${both}|${darkOnly}`);
+		const self = `.a2ui-surface[data-a2ui-theme="${id}"]`;
+		return {
+			id,
+			css: [both && `${self}{${both}}`, darkOnly && `${DARK} ${self},${self}${DARK}{${darkOnly}}`].filter(Boolean).join("")
+		};
+	}
+
+//#endregion
+//#region src/v2/generative-ui/SurfaceView.tsx
+	const NO_ANCESTORS = [];
+	const ROOT_STYLE = { display: "contents" };
+	const undefinedSnapshot = () => void 0;
+	const noopSubscribe = () => () => {};
+	const zeroSnapshot = () => 0;
+	/** A "multiple" slot value that repeats a component for each list item. */
+	function isTemplateChildren(value) {
+		return typeof value === "object" && value !== null && "componentId" in value && typeof value.componentId === "string" && "path" in value && typeof value.path === "string";
+	}
+	function SurfaceView({ surface }) {
+		const runtime = useRequiredGenerativeUIRuntime();
+		const { theme } = runtime;
+		const sheet = (0, react.useMemo)(() => themeStyleSheet(theme), [theme]);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			className: "a2ui-surface",
+			"data-generative-ui-root": surface.surfaceId,
+			"data-a2ui-theme": sheet?.id,
+			style: ROOT_STYLE,
+			children: [sheet ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("style", { dangerouslySetInnerHTML: { __html: sheet.css } }) : null, /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceBoundary, {
+				surfaceId: surface.surfaceId,
+				runtime,
+				children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+					surface,
+					componentId: _copilotkit_shared.GENERATIVE_UI_ROOT_ID,
+					basePath: void 0,
+					ancestors: NO_ANCESTORS
+				})
+			})]
+		});
+	}
+	/**
+	* Resolves a component by id. Subscribes to the manager rather than web_core's
+	* `onCreated`/`onDeleted`: web_core's EventEmitter awaits each listener in turn,
+	* so with several subscribers (one per slotted child, or one per mount of the
+	* same surface) all but the first are notified a microtask late. That is only
+	* visible inside synchronous flushes such as `act()` / `flushSync`, where the
+	* old tree would still be on screen, but it makes updates order-dependent.
+	* The manager notifies synchronously once an ingest has been fully applied.
+	*/
+	function useComponentModel(manager, model, id) {
+		return (0, react.useSyncExternalStore)(manager.subscribe, () => model.componentsModel.get(id), undefinedSnapshot);
+	}
+	/** Same reasoning as `useComponentModel`: never rely on web_core's emitters. */
+	function useComponentProperties(manager, component) {
+		return (0, react.useSyncExternalStore)(manager.subscribe, () => component?.properties, undefinedSnapshot);
+	}
+	/**
+	* The id of a node in the ancestor list. A template renders the same
+	* component once per item, so the item path is part of the id. A real cycle
+	* repeats both.
+	*/
+	function scopedId(componentId, basePath) {
+		return `${basePath ?? ""}#${componentId}`;
+	}
+	const NodeView = (0, react.memo)(function NodeView({ surface, componentId, basePath, ancestors }) {
+		const runtime = useRequiredGenerativeUIRuntime();
+		const component = useComponentModel(runtime.manager, surface.model, componentId);
+		const properties = useComponentProperties(runtime.manager, component);
+		if (ancestors.includes(scopedId(componentId, basePath))) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+			message: `cyclic reference to ${componentId}`,
+			componentId
+		});
+		if (!component || !properties) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodePlaceholder, { componentId });
+		const definition = runtime.ui.components.get(component.type);
+		if (!definition) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+			message: `unknown component "${component.type}"`,
+			componentId
+		});
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeBoundary, {
+			surfaceId: surface.surfaceId,
+			componentId,
+			revision: properties,
+			runtime,
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ResolvedNode, {
+				surface,
+				componentId,
+				definition,
+				properties,
+				runtime,
+				basePath,
+				ancestors
+			})
+		}, component.type);
+	});
+	/**
+	* Renders the component of a template once for each item of the list at the
+	* template path, keyed by index. Renders nothing when there is no list.
+	*/
+	function TemplateChildren({ surface, template, basePath, ancestors }) {
+		const dataModel = surface.model.dataModel;
+		const listPath = resolvePath(template.path, basePath);
+		const subscribe = (0, react.useCallback)((onChange) => {
+			const subscription = dataModel.subscribe(listPath, onChange);
+			return () => subscription.unsubscribe();
+		}, [dataModel, listPath]);
+		const getCount = () => {
+			const list = dataModel.get(listPath);
+			return Array.isArray(list) ? list.length : 0;
+		};
+		const count = (0, react.useSyncExternalStore)(subscribe, getCount, zeroSnapshot);
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, { children: Array.from({ length: count }, (_, index) => index).map((index) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+			surface,
+			componentId: template.componentId,
+			basePath: joinPath(listPath, String(index)),
+			ancestors
+		}, index)) });
+	}
+	/**
+	* The props the model sets, with their dynamic values resolved from the
+	* surface data model: `{"@path"}` bindings, `{"@call"}` function values and
+	* `{"@call":"@index"}` in a template, at any depth. A literal writable prop
+	* that the component set shows the local value from `overrides`. Bound
+	* props, events and slots are left out, and so are the keys of the A2UI
+	* component envelope; `accessibility` is resolved the same way and given
+	* on its own.
+	*
+	* A prop is resolved again only when its raw value or a data model value it
+	* read has changed, so the result keeps its identity otherwise. A function
+	* value that cannot be computed gives a problem instead of values.
+	*/
+	function useModelDataProps(surface, definition, properties, basePath, overrides) {
+		const dataModel = surface.model.dataModel;
+		const units = (0, react.useMemo)(() => {
+			const list = [];
+			for (const key of Object.keys(properties)) {
+				if (definition.events?.[key] || definition.slots?.[key] || Object.hasOwn(definition.selectors, key) || _copilotkit_shared.A2UI_COMPONENT_ENVELOPE_KEYS.has(key)) continue;
+				list.push({
+					key,
+					raw: properties[key]
+				});
+			}
+			const a11y = properties.accessibility;
+			if (typeof a11y === "object" && a11y !== null && !Array.isArray(a11y)) for (const [field, raw] of Object.entries(a11y)) list.push({
+				key: `accessibility/${field}`,
+				raw,
+				field
+			});
+			return list;
+		}, [properties, definition]);
+		const [, rerender] = (0, react.useReducer)((n) => n + 1, 0);
+		const cache = (0, react.useRef)(/* @__PURE__ */ new Map());
+		const values = {};
+		const a11yValues = {};
+		const paths = /* @__PURE__ */ new Set();
+		let problem;
+		const next = /* @__PURE__ */ new Map();
+		for (const { key, raw, field } of units) {
+			const cached = cache.current.get(key);
+			const isFresh = cached !== void 0 && cached.raw === raw && cached.basePath === basePath && [...cached.reads].every(([path, value]) => Object.is(dataModel.get(path), value));
+			const resolve = () => {
+				const resolved = tryResolveDynamicValue(raw, {
+					data: dataModel,
+					basePath
+				}, { isChecks: key === "checks" });
+				const reads = /* @__PURE__ */ new Map();
+				for (const path of resolved.paths) reads.set(path, dataModel.get(path));
+				return {
+					raw,
+					basePath,
+					reads,
+					outcome: resolved.ok ? {
+						ok: true,
+						value: resolved.value
+					} : {
+						ok: false,
+						message: resolved.error.message
+					}
+				};
+			};
+			const entry = isFresh && cached ? cached : resolve();
+			next.set(key, entry);
+			if (field !== void 0) {
+				if (entry.outcome.ok) a11yValues[field] = entry.outcome.value;
+			} else if (entry.outcome.ok) values[key] = entry.outcome.value;
+			else problem ?? (problem = `${key}: ${entry.outcome.message}`);
+			for (const path of entry.reads.keys()) paths.add(path);
+		}
+		cache.current = next;
+		const accessibility = readAccessibility(a11yValues);
+		for (const [key, value] of Object.entries(overrides)) if (!(0, _copilotkit_shared.isPathBinding)(properties[key])) values[key] = value;
+		const rendered = (0, react.useRef)(next);
+		rendered.current = next;
+		const pathKey = [...paths].sort().join("\n");
+		(0, react.useEffect)(() => {
+			const list = pathKey === "" ? [] : pathKey.split("\n");
+			const onChange = () => {
+				cache.current = /* @__PURE__ */ new Map();
+				rerender();
+			};
+			const subscriptions = list.map((path) => dataModel.subscribe(path, onChange));
+			if ([...rendered.current.values()].some((entry) => [...entry.reads].some(([path, value]) => !Object.is(dataModel.get(path), value)))) rerender();
+			return () => subscriptions.forEach((s) => s.unsubscribe());
+		}, [dataModel, pathKey]);
+		const stable = (0, react.useRef)({
+			ok: true,
+			values: {},
+			accessibility: void 0
+		});
+		const result = problem === void 0 ? {
+			ok: true,
+			values,
+			accessibility
+		} : {
+			ok: false,
+			problem
+		};
+		const last = stable.current;
+		if (!(result.ok && last.ok ? shallowEqual(last.values, result.values) && shallowEqual(last.accessibility ?? {}, result.accessibility ?? {}) : !result.ok && !last.ok && last.problem === result.problem)) stable.current = result;
+		return stable.current;
+	}
+	const NO_SELECTION = {
+		ok: true,
+		values: {}
+	};
+	function isSameSelection(a, b) {
+		if (a.ok && b.ok) return shallowEqual(a.values, b.values);
+		if (!a.ok && !b.ok) return a.problem === b.problem;
+		return false;
+	}
+	/** Runs every selector of a node. A selector that throws gives a problem. */
+	function select(definition, state, modelProps) {
+		const values = {};
+		const selectors = Object.entries(definition.selectors);
+		for (const [key, selector] of selectors) try {
+			values[key] = selector(state, modelProps);
+		} catch (error) {
+			return {
+				ok: false,
+				problem: `${key}: selector threw: ${error instanceof Error ? error.message : String(error)}`
+			};
+		}
+		return {
+			ok: true,
+			values
+		};
+	}
+	/**
+	* The values of the bound props of a node, read from the app state.
+	*
+	* The selectors run again only when the state object or the parsed model
+	* props change. When the new values are shallow-equal to the last ones, the
+	* last snapshot is kept. So the node re-renders only when a selected value
+	* changes. A selector that returns a new array on each call cannot cause a
+	* render loop: with the same inputs, the cached snapshot comes back.
+	*
+	* A node without bound props does not subscribe to the state.
+	*/
+	function useSelection(manager, definition, modelProps) {
+		const hasSelectors = Object.keys(definition.selectors).length > 0;
+		const cache = (0, react.useRef)(void 0);
+		const getSnapshot = () => {
+			if (!hasSelectors || modelProps === void 0) return NO_SELECTION;
+			const state = manager.getState();
+			const cached = cache.current;
+			if (cached !== void 0 && cached.state === state && cached.modelProps === modelProps) return cached.selection;
+			const next = select(definition, state, modelProps);
+			const selection = cached !== void 0 && isSameSelection(cached.selection, next) ? cached.selection : next;
+			cache.current = {
+				state,
+				modelProps,
+				selection
+			};
+			return selection;
+		};
+		return (0, react.useSyncExternalStore)(hasSelectors ? manager.subscribe : noopSubscribe, getSnapshot, getSnapshot);
+	}
+	/**
+	* Checks the model-set props with the props schema before the selectors run.
+	* The bound props are not set yet, so their issues do not count. Neither do
+	* issues with no path (a check over several props), which the full check
+	* after the selectors reports.
+	*/
+	function checkModelProps(definition, modelData) {
+		if (!definition.props) return {
+			ok: true,
+			values: {}
+		};
+		let values = modelData;
+		let result = validateSchemaSync(definition.props, values);
+		if (!result.success) {
+			const unset = withoutRejectedNulls(values, result.issues);
+			if (unset) {
+				values = unset;
+				result = validateSchemaSync(definition.props, values);
+			}
+		}
+		if (!result.success) {
+			const issues = result.issues.filter((issue) => {
+				const key = issueKey(issue);
+				return key === void 0 ? isAsyncIssue(issue) : !Object.hasOwn(definition.selectors, key);
+			});
+			if (issues.length > 0) return {
+				ok: false,
+				problem: formatIssues(issues)
+			};
+		}
+		return {
+			ok: true,
+			values
+		};
+	}
+	/**
+	* The data props of a node, in three steps: check the model-set props with
+	* the props schema, run the selectors with them, then parse all props with
+	* the props schema. Gives the reason when a step fails.
+	*/
+	function useDataProps(runtime, surface, definition, properties, basePath, overrides) {
+		const modelData = useModelDataProps(surface, definition, properties, basePath, overrides);
+		const modelCheck = (0, react.useMemo)(() => modelData.ok ? checkModelProps(definition, modelData.values) : modelData, [definition, modelData]);
+		const selection = useSelection(runtime.manager, definition, modelCheck.ok ? modelCheck.values : void 0);
+		const accessibility = modelData.ok ? modelData.accessibility : void 0;
+		return (0, react.useMemo)(() => {
+			if (!modelCheck.ok) return modelCheck;
+			if (!selection.ok) return selection;
+			if (!definition.props) return {
+				ok: true,
+				props: {},
+				accessibility
+			};
+			const input = {
+				...modelCheck.values,
+				...selection.values
+			};
+			let parsed = validateSchemaSync(definition.props, input);
+			if (!parsed.success) {
+				const unset = withoutRejectedNulls(input, parsed.issues);
+				if (unset) parsed = validateSchemaSync(definition.props, unset);
+			}
+			if (!parsed.success) return {
+				ok: false,
+				problem: formatIssues(parsed.issues)
+			};
+			return {
+				ok: true,
+				props: parsed.data,
+				accessibility
+			};
+		}, [
+			definition,
+			modelCheck,
+			selection,
+			accessibility
+		]);
+	}
+	/**
+	* The event props of a node. A matched event (one that matches a declared
+	* function) is always bound. An unmatched event is bound only when the model
+	* bound it.
+	*/
+	function useEventProps(runtime, surface, componentId, definition, properties, basePath) {
+		const latest = (0, react.useRef)(properties);
+		latest.current = properties;
+		const boundNames = Object.keys(definition.events ?? {}).filter((name) => Object.hasOwn(definition.eventFunctions, name) || (0, _copilotkit_shared.isActionBinding)(properties[name])).join("|");
+		return (0, react.useMemo)(() => {
+			const handlers = {};
+			const names = boundNames ? boundNames.split("|") : [];
+			for (const name of names) {
+				const call = {
+					runtime,
+					surface,
+					componentId,
+					name,
+					parameters: definition.events?.[name]?.parameters
+				};
+				const functionName = Object.hasOwn(definition.eventFunctions, name) ? definition.eventFunctions[name] : void 0;
+				handlers[name] = functionName === void 0 ? (args) => invokeBoundEvent({
+					...call,
+					binding: latest.current[name],
+					basePath,
+					args
+				}) : (args) => invokeMatchedEvent({
+					...call,
+					functionName,
+					args
+				});
+			}
+			return handlers;
+		}, [
+			boundNames,
+			runtime,
+			surface,
+			componentId,
+			definition,
+			basePath
+		]);
+	}
+	/**
+	* The setter props of a node: `setValue` for the writable prop `value`. For
+	* a prop the model bound to `{"@path"}`, the setter writes the data model
+	* and makes the path user-owned. For a literal prop, it sets `overrides`, a
+	* local value of this mounted node. The setters keep their identity.
+	*/
+	function useSetterProps(runtime, surface, componentId, definition, properties, basePath) {
+		const [overrides, setOverrides] = (0, react.useState)({});
+		const latest = (0, react.useRef)(properties);
+		latest.current = properties;
+		return {
+			overrides,
+			setters: (0, react.useMemo)(() => {
+				const result = {};
+				const writable = definition.writable ?? [];
+				for (const key of writable) result[setterNameOf(key)] = (value) => {
+					const binding = latest.current[key];
+					if (!(0, _copilotkit_shared.isPathBinding)(binding)) {
+						setOverrides((current) => ({
+							...current,
+							[key]: value
+						}));
+						return;
+					}
+					try {
+						runtime.manager.setOwnedValue(surface.key, resolvePath(binding["@path"], basePath), value);
+					} catch (cause) {
+						const message = cause instanceof Error ? cause.message : String(cause);
+						reportErrorSafely(runtime, {
+							kind: "props",
+							surfaceId: surface.surfaceId,
+							componentId,
+							error: /* @__PURE__ */ new Error(`${setterNameOf(key)}: ${message}`)
+						});
+					}
+				};
+				return result;
+			}, [
+				runtime,
+				surface,
+				componentId,
+				definition,
+				basePath
+			])
+		};
+	}
+	function useSlotProps(surface, definition, properties, componentId, basePath, ancestors) {
+		return (0, react.useMemo)(() => {
+			const childAncestors = [...ancestors, scopedId(componentId, basePath)];
+			const slots = {};
+			for (const [name, kind] of Object.entries(definition.slots ?? {})) {
+				const value = properties[name];
+				if (kind === "single" && typeof value === "string") slots[name] = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+					surface,
+					componentId: value,
+					basePath,
+					ancestors: childAncestors
+				});
+				else if (kind === "multiple" && isTemplateChildren(value)) slots[name] = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TemplateChildren, {
+					surface,
+					template: value,
+					basePath,
+					ancestors: childAncestors
+				});
+				else if (kind === "multiple" && Array.isArray(value)) slots[name] = [...new Set(value.filter((id) => typeof id === "string"))].map((id) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+					surface,
+					componentId: id,
+					basePath,
+					ancestors: childAncestors
+				}, id));
+			}
+			return slots;
+		}, [
+			surface,
+			definition,
+			properties,
+			componentId,
+			basePath,
+			ancestors
+		]);
+	}
+	/**
+	* The parsed data props with every typed child reference (`child()`,
+	* `childList()`, at any depth) replaced by the rendered component. Without
+	* references, the parsed props come back as they are.
+	*/
+	function useChildRefProps(surface, refs, props, componentId, basePath, ancestors) {
+		return (0, react.useMemo)(() => {
+			if (props === void 0 || refs.length === 0) return props;
+			const childAncestors = [...ancestors, scopedId(componentId, basePath)];
+			const render = (kind, value) => {
+				if (kind === "single") return typeof value === "string" ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+					surface,
+					componentId: value,
+					basePath,
+					ancestors: childAncestors
+				}) : void 0;
+				if (isTemplateChildren(value)) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(TemplateChildren, {
+					surface,
+					template: value,
+					basePath,
+					ancestors: childAncestors
+				});
+				if (!Array.isArray(value)) return void 0;
+				return [...new Set(value.filter((id) => typeof id === "string"))].map((id) => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(NodeView, {
+					surface,
+					componentId: id,
+					basePath,
+					ancestors: childAncestors
+				}, id));
+			};
+			let result = props;
+			for (const ref of refs) result = (0, _copilotkit_shared.mapAtChildRef)(result, ref.path, (found) => render(ref.kind, found));
+			return result;
+		}, [
+			surface,
+			refs,
+			props,
+			componentId,
+			basePath,
+			ancestors
+		]);
+	}
+	function ResolvedNode({ surface, componentId, definition, properties, runtime, basePath, ancestors }) {
+		const { overrides, setters } = useSetterProps(runtime, surface, componentId, definition, properties, basePath);
+		const dataProps = useDataProps(runtime, surface, definition, properties, basePath, overrides);
+		const eventProps = useEventProps(runtime, surface, componentId, definition, properties, basePath);
+		const slotProps = useSlotProps(surface, definition, properties, componentId, basePath, ancestors);
+		const childRefProps = useChildRefProps(surface, definition.childRefs, dataProps.ok ? dataProps.props : void 0, componentId, basePath, ancestors);
+		const accessibility = dataProps.ok ? dataProps.accessibility : void 0;
+		const nodeContext = (0, react.useMemo)(() => ({
+			surfaceKey: surface.key,
+			surfaceId: surface.surfaceId,
+			componentId,
+			accessibility
+		}), [
+			surface.key,
+			surface.surfaceId,
+			componentId,
+			accessibility
+		]);
+		const problem = dataProps.ok ? void 0 : dataProps.problem;
+		(0, react.useEffect)(() => {
+			if (problem) reportErrorSafely(runtime, {
+				kind: "props",
+				surfaceId: surface.surfaceId,
+				componentId,
+				error: /* @__PURE__ */ new Error(`Invalid props: ${problem}`)
+			});
+		}, [
+			problem,
+			runtime,
+			surface.surfaceId,
+			componentId
+		]);
+		if (!dataProps.ok) return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(DefaultNodeFallback, {
+			message: `invalid props (${problem})`,
+			componentId
+		});
+		const Component = definition.component;
+		const rendered = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Component, {
+			...childRefProps,
+			...eventProps,
+			...slotProps,
+			...setters
+		});
+		const hasEnvelope = properties.accessibility !== void 0 && definition.accessibility !== "self";
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(GenerativeUINodeContext.Provider, {
+			value: nodeContext,
+			children: hasEnvelope ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)("span", {
+				"data-a2ui-accessibility": "",
+				style: ROOT_STYLE,
+				...wrapperAria(accessibilityAttributes(accessibility)),
+				children: rendered
+			}) : rendered
+		});
+	}
+
+//#endregion
+//#region src/v2/generative-ui/chat.tsx
+	const GenerativeUIChatSlotContext = (0, react.createContext)(void 0);
+	function DefaultGenerativeUIChatCard({ surfaceId, isStreaming, error, children }) {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsxs)("div", {
+			"data-generative-ui-chat-surface": surfaceId,
+			className: "cpk:my-2 cpk:w-full cpk:rounded-xl cpk:border cpk:border-gray-200 cpk:p-3",
+			children: [children, error && /* @__PURE__ */ (0, react_jsx_runtime.jsx)("div", {
+				role: "alert",
+				className: "cpk:mt-2 cpk:text-xs cpk:text-red-600",
+				children: "Part of this UI couldn't be shown."
+			})]
+		});
+	}
+	const ContentSchema = zod.z.object({
+		surfaceId: zod.z.string(),
+		target: zod.z.string(),
+		catalogId: zod.z.string(),
+		operations: zod.z.array(zod.z.any()),
+		status: zod.z.enum([
+			"streaming",
+			"ready",
+			"error"
+		]),
+		rejected: zod.z.array(zod.z.object({
+			index: zod.z.number(),
+			reason: zod.z.string()
+		})).default([])
+	}).passthrough();
+	function GenerativeUIChatActivity({ content, agent }) {
+		const runtime = useGenerativeUIRuntime();
+		const threadId = useCopilotChatConfiguration()?.threadId ?? agent?.threadId;
+		const Wrapper = (0, react.useContext)(GenerativeUIChatSlotContext) ?? DefaultGenerativeUIChatCard;
+		useManagerVersion(runtime);
+		(0, react.useLayoutEffect)(() => {
+			if (runtime && threadId) runtime.manager.ingest(threadId, agent?.agentId, content);
+		}, [
+			runtime,
+			threadId,
+			agent?.agentId,
+			content
+		]);
+		if (!runtime || !threadId || content.target !== _copilotkit_shared.GENERATIVE_UI_CHAT_TARGET) return null;
+		const surface = runtime.manager.getSurface(threadId, content.surfaceId) ?? runtime.manager.getFailedSurface(threadId, content.surfaceId);
+		if (!surface) return null;
+		const rejected = [...content.rejected ?? [], ...surface.clientRejected];
+		const error = rejected.length ? new Error(`${rejected.length} UI update(s) could not be shown`, { cause: rejected }) : void 0;
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Wrapper, {
+			surfaceId: content.surfaceId,
+			isStreaming: content.status === "streaming",
+			error,
+			rejected,
+			children: surface.failed ? null : /* @__PURE__ */ (0, react_jsx_runtime.jsx)(SurfaceView, { surface })
+		});
+	}
+	function createGenerativeUIActivityRenderer() {
+		return {
+			activityType: _copilotkit_shared.GENERATIVE_UI_ACTIVITY_TYPE,
+			content: ContentSchema,
+			render: GenerativeUIChatActivity
+		};
+	}
+	/**
+	* Shows nothing in the chat for an agent-called function. The root reads the
+	* function-call activities from the messages and runs them. This renderer
+	* only keeps a wildcard ("*") activity renderer from showing them.
+	*/
+	function createGenerativeUIFunctionCallActivityRenderer() {
+		return {
+			activityType: _copilotkit_shared.GENERATIVE_UI_FUNCTION_CALL_ACTIVITY_TYPE,
+			content: zod.z.unknown(),
+			render: () => null
+		};
+	}
+	/** Hides the raw `render_ui` tool call; the surface activity owns the UX. */
+	function GenerativeUIToolCallRenderer() {
+		const { copilotkit } = useCopilotKit();
+		(0, react.useEffect)(() => {
+			const renderer = defineToolCallRenderer({
+				name: _copilotkit_shared.GENERATIVE_UI_RENDER_TOOL,
+				args: zod.z.any(),
+				render: () => /* @__PURE__ */ (0, react_jsx_runtime.jsx)(react_jsx_runtime.Fragment, {})
+			});
+			const existing = copilotkit._renderToolCalls ?? [];
+			copilotkit.setRenderToolCalls([...existing.filter((rc) => rc.name !== _copilotkit_shared.GENERATIVE_UI_RENDER_TOOL), renderer]);
+		}, [copilotkit]);
+		return null;
+	}
+
 //#endregion
 //#region src/v2/providers/CopilotKitProvider.tsx
 	const zodToJsonSchemaAdapter = (schema, options) => {
@@ -2269,7 +6715,7 @@ react_markdown = __toESM(react_markdown);
 		return value;
 	}
 	/** Provide a shared core instance and synchronize runtime, tool, and UI configuration. */
-	const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY_HEADERS, credentials, messageFilter, publicApiKey, publicLicenseKey, licenseToken, properties = EMPTY_PROPERTIES, agents__unsafe_dev_only: agents = EMPTY_AGENTS, selfManagedAgents = EMPTY_AGENTS, renderToolCalls, renderActivityMessages, renderCustomMessages, frontendTools, humanInTheLoop, openGenerativeUI, enableInspector, agentId, showIntelligenceIndicator = true, useSingleEndpoint, onError, a2ui, mcpApps, defaultThrottleMs, debug, learning }) => {
+	const CopilotKitProvider = ({ children, runtimeUrl, headers: headersProp = EMPTY_HEADERS, credentials, messageFilter, publicApiKey, publicLicenseKey, licenseToken, properties = EMPTY_PROPERTIES, agents__unsafe_dev_only: agents = EMPTY_AGENTS, selfManagedAgents = EMPTY_AGENTS, renderToolCalls, renderActivityMessages, renderCustomMessages, frontendTools, humanInTheLoop, openGenerativeUI, enableInspector, agentId, showIntelligenceIndicator = true, useSingleEndpoint, onError, a2ui, generativeUI, mcpApps, defaultThrottleMs, debug, learning }) => {
 		const learningConfig = (0, react.useMemo)(() => toLearningConfig(learning), [learning]);
 		const [shouldRenderInspector, setShouldRenderInspector] = (0, react.useState)(false);
 		const [inspectorVisible, setInspectorVisible] = (0, react.useState)(false);
@@ -2291,6 +6737,7 @@ react_markdown = __toESM(react_markdown);
 		const openGenUIActive = runtimeOpenGenUIEnabled || !!openGenerativeUI;
 		const a2uiCatalogProvided = !!a2ui?.catalog;
 		const a2uiActive = runtimeA2UIEnabled || a2uiCatalogProvided;
+		const generativeUIActive = !!generativeUI?.ui;
 		const [runtimeLicenseStatus, setRuntimeLicenseStatus] = (0, react.useState)(void 0);
 		const [runtimeEntitlements, setRuntimeEntitlements] = (0, react.useState)(void 0);
 		const [runtimeEntitlementRetryPending, setRuntimeEntitlementRetryPending] = (0, react.useState)(false);
@@ -2344,10 +6791,12 @@ react_markdown = __toESM(react_markdown);
 				loadingComponent: a2ui?.loadingComponent,
 				recovery: a2ui?.recovery
 			}));
+			if (generativeUIActive) renderers.push(createGenerativeUIActivityRenderer(), createGenerativeUIFunctionCallActivityRenderer());
 			return renderers;
 		}, [
 			a2uiActive,
 			openGenUIActive,
+			generativeUIActive,
 			a2ui,
 			filteredCatalog,
 			mcpAppsAllowSameOrigin
@@ -2514,6 +6963,7 @@ react_markdown = __toESM(react_markdown);
 			if (defaultThrottleMs !== void 0) copilotkitRef.current.setDefaultThrottleMs(defaultThrottleMs);
 		}
 		const copilotkit = copilotkitRef.current;
+		const generativeUIRuntime = useGenerativeUIRoot(copilotkit, generativeUI);
 		(0, react.useEffect)(() => {
 			if (!rawCatalog) return;
 			if (!(rawCatalog instanceof _copilotkit_a2ui_renderer.Catalog)) return;
@@ -2752,6 +7202,7 @@ react_markdown = __toESM(react_markdown);
 					value: licenseContextValue,
 					children: [
 						a2uiActive && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(A2UIBuiltInToolCallRenderer, {}),
+						generativeUIActive && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(GenerativeUIToolCallRenderer, {}),
 						a2uiActive && /* @__PURE__ */ (0, react_jsx_runtime.jsx)(A2UICatalogContext, {
 							catalog: filteredCatalog,
 							includeSchema: a2ui?.includeSchema
@@ -2760,7 +7211,10 @@ react_markdown = __toESM(react_markdown);
 							value: inspectorContextValue,
 							children: [/* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitAgentIdContext.Provider, {
 								value: agentId,
-								children
+								children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(GenerativeUIRuntimeContext.Provider, {
+									value: generativeUIRuntime,
+									children
+								})
 							}), shouldRenderInspector ? /* @__PURE__ */ (0, react_jsx_runtime.jsx)(CopilotKitInspector, {
 								core: copilotkit,
 								openRequest: inspectorOpenRequest,