@openuidev/a2ui 0.3.0

package/dist/index.mjs

@@ -0,0 +1,767 @@
+import { i as toJsonObject, n as dataModelToOpenUIState, r as mergeOpenUIStateIntoDataModel, t as applyDataModelUpdate } from "./json-pointer-DCdSrMT3.mjs";
+import { createParser } from "@openuidev/lang-core";
+import { z } from "zod/v4";
+//#region src/protocol-schema.ts
+const jsonValueSchema = z.json();
+const jsonObjectSchema = z.record(z.string(), jsonValueSchema);
+const versionSchema = z.literal("v1.0");
+const surfaceIdSchema = z.string();
+const extensionKeySchema = z.string().regex(/^[\p{XID_Start}_][\p{XID_Continue}]*$/u);
+const extensionsSchema = z.record(extensionKeySchema, jsonValueSchema);
+const messageMetadataSchema = z.strictObject({ extensions: extensionsSchema.optional() });
+const langComponentsSchema = z.array(z.string().min(1)).min(1).describe("Complete OpenUI Lang statements or statement blocks, merged by statement ID in array order.");
+const a2uiFunctionCallSchema = z.strictObject({
+	call: z.string(),
+	catalogId: z.string().optional(),
+	args: jsonObjectSchema.optional()
+});
+const a2uiFunctionResponseSchema = z.union([z.strictObject({
+	functionCallId: z.string(),
+	value: jsonValueSchema
+}), z.strictObject({
+	functionCallId: z.string(),
+	error: z.strictObject({
+		code: z.string(),
+		message: z.string()
+	})
+})]);
+const createSurfaceMessageSchema = z.strictObject({
+	version: versionSchema,
+	createSurface: z.strictObject({
+		surfaceId: surfaceIdSchema,
+		catalogId: z.string().optional(),
+		sendDataModel: z.boolean().optional().meta({ default: false }),
+		components: langComponentsSchema.optional().describe("Optional initial OpenUI Lang statements for single-message surface creation."),
+		dataModel: jsonObjectSchema.optional(),
+		metadata: messageMetadataSchema.optional()
+	})
+});
+const updateComponentsMessageSchema = z.strictObject({
+	version: versionSchema,
+	updateComponents: z.strictObject({
+		surfaceId: surfaceIdSchema,
+		components: langComponentsSchema
+	})
+});
+const updateDataModelMessageSchema = z.strictObject({
+	version: versionSchema,
+	updateDataModel: z.strictObject({
+		surfaceId: surfaceIdSchema,
+		path: z.string().optional(),
+		value: jsonValueSchema
+	})
+});
+const deleteSurfaceMessageSchema = z.strictObject({
+	version: versionSchema,
+	deleteSurface: z.strictObject({ surfaceId: surfaceIdSchema })
+});
+const callRendererFunctionMessageSchema = z.strictObject({
+	version: versionSchema,
+	callRendererFunction: z.strictObject({
+		functionCallId: z.string(),
+		callFunction: a2uiFunctionCallSchema.extend({ catalogId: z.string() })
+	})
+});
+const agentFunctionResponseMessageSchema = z.strictObject({
+	version: versionSchema,
+	agentFunctionResponse: a2uiFunctionResponseSchema
+});
+const agentToRendererMessageSchema = z.union([
+	createSurfaceMessageSchema,
+	updateComponentsMessageSchema,
+	updateDataModelMessageSchema,
+	deleteSurfaceMessageSchema,
+	callRendererFunctionMessageSchema,
+	agentFunctionResponseMessageSchema
+]);
+const actionMessageSchema = z.strictObject({
+	version: versionSchema,
+	action: z.strictObject({
+		name: z.string(),
+		userMessage: z.string().optional(),
+		surfaceId: surfaceIdSchema,
+		sourceComponentId: z.string(),
+		timestamp: z.iso.datetime({ offset: true }),
+		context: jsonObjectSchema,
+		metadata: messageMetadataSchema.optional()
+	})
+});
+const callAgentFunctionMessageSchema = z.strictObject({
+	version: versionSchema,
+	callAgentFunction: z.strictObject({
+		surfaceId: surfaceIdSchema,
+		functionCallId: z.string(),
+		callFunction: a2uiFunctionCallSchema
+	})
+});
+const rendererFunctionResponseMessageSchema = z.strictObject({
+	version: versionSchema,
+	rendererFunctionResponse: a2uiFunctionResponseSchema
+});
+const validationErrorCodeSchema = z.enum([
+	"VALIDATION_FAILED",
+	"UNALLOWED_PARENT",
+	"UNALLOWED_CHILD"
+]);
+const validationFailedErrorMessageSchema = z.strictObject({
+	version: versionSchema,
+	error: z.strictObject({
+		code: validationErrorCodeSchema,
+		surfaceId: surfaceIdSchema,
+		path: z.string(),
+		message: z.string()
+	})
+});
+const genericErrorCodeSchema = z.string().refine((code) => !validationErrorCodeSchema.options.includes(code));
+const genericErrorMessageSchema = z.union([z.strictObject({
+	version: versionSchema,
+	error: z.strictObject({
+		code: genericErrorCodeSchema,
+		message: z.string(),
+		surfaceId: surfaceIdSchema
+	})
+}), z.strictObject({
+	version: versionSchema,
+	error: z.strictObject({
+		code: genericErrorCodeSchema,
+		message: z.string(),
+		functionCallId: z.string()
+	})
+})]);
+const rendererToAgentMessageSchema = z.union([
+	actionMessageSchema,
+	callAgentFunctionMessageSchema,
+	rendererFunctionResponseMessageSchema,
+	validationFailedErrorMessageSchema,
+	genericErrorMessageSchema
+]);
+const rendererCapabilitiesSchema = z.strictObject({ "v1.0": z.strictObject({
+	supportedCatalogIds: z.array(z.string()),
+	inlineCatalogs: z.array(jsonObjectSchema).optional()
+}) });
+const agentCapabilitiesSchema = z.strictObject({ "v1.0": z.strictObject({
+	supportedCatalogIds: z.array(z.string()).optional(),
+	acceptsInlineCatalogs: z.boolean().optional().meta({ default: false })
+}) });
+const rendererDataModelSchema = z.strictObject({
+	version: versionSchema,
+	surfaces: z.record(z.string(), jsonObjectSchema)
+});
+//#endregion
+//#region src/runtime-schema.ts
+function escapePointerToken(token) {
+	return String(token).replace(/~/g, "~0").replace(/\//g, "~1");
+}
+function issuePath(path) {
+	return path.length === 0 ? "/" : `/${path.map(escapePointerToken).join("/")}`;
+}
+function validateAgentToRendererMessage(input) {
+	const object = input != null && typeof input === "object" && !Array.isArray(input) ? input : void 0;
+	const presentKeys = object ? [
+		"createSurface",
+		"updateComponents",
+		"updateDataModel",
+		"deleteSurface",
+		"callRendererFunction",
+		"agentFunctionResponse"
+	].filter((key) => Object.prototype.hasOwnProperty.call(object, key)) : [];
+	const result = (presentKeys.length === 1 ? {
+		createSurface: createSurfaceMessageSchema,
+		updateComponents: updateComponentsMessageSchema,
+		updateDataModel: updateDataModelMessageSchema,
+		deleteSurface: deleteSurfaceMessageSchema,
+		callRendererFunction: callRendererFunctionMessageSchema,
+		agentFunctionResponse: agentFunctionResponseMessageSchema
+	}[presentKeys[0]] : agentToRendererMessageSchema).safeParse(input);
+	if (result.success) return {
+		success: true,
+		message: result.data
+	};
+	return {
+		success: false,
+		issues: result.error.issues.map((issue) => ({
+			path: issuePath(issue.path),
+			message: issue.message
+		}))
+	};
+}
+//#endregion
+//#region src/statement-patch.ts
+const STATEMENT_PATTERN = /^(\$?[A-Za-z_][A-Za-z0-9_]*)\s*=\s*([\s\S]*)$/u;
+function stripFences(source) {
+	const trimmed = source.trim();
+	if (!trimmed.startsWith("```")) return trimmed;
+	const firstLineEnd = trimmed.indexOf("\n");
+	const lastFence = trimmed.lastIndexOf("```");
+	if (firstLineEnd === -1 || lastFence <= firstLineEnd) return trimmed;
+	return trimmed.slice(firstLineEnd + 1, lastFence).trim();
+}
+function splitStatements(source) {
+	const statements = [];
+	let depth = 0;
+	let ternaryDepth = 0;
+	let quote = false;
+	let escaped = false;
+	let start = 0;
+	for (let index = 0; index < source.length; index += 1) {
+		const character = source[index];
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (character === "\\" && quote) {
+			escaped = true;
+			continue;
+		}
+		if (quote) {
+			if (character === quote) quote = false;
+			continue;
+		}
+		if (character === "\"" || character === "'") {
+			quote = character;
+			continue;
+		}
+		if (character === "(" || character === "[" || character === "{") depth += 1;
+		else if (character === ")" || character === "]" || character === "}") depth = Math.max(0, depth - 1);
+		else if (character === "?" && depth === 0) ternaryDepth += 1;
+		else if (character === ":" && depth === 0 && ternaryDepth > 0) ternaryDepth -= 1;
+		else if (character === "\n" && depth === 0 && ternaryDepth === 0) {
+			let next = index + 1;
+			while (next < source.length && /\s/u.test(source[next])) next += 1;
+			if (source[next] === "?") continue;
+			const statement = source.slice(start, index).trim();
+			if (statement) statements.push(statement);
+			start = index + 1;
+		}
+	}
+	const finalStatement = source.slice(start).trim();
+	if (finalStatement) statements.push(finalStatement);
+	return statements;
+}
+function parseStatements(source) {
+	return splitStatements(stripFences(source)).map((raw) => {
+		const match = STATEMENT_PATTERN.exec(raw);
+		if (!match) throw new Error(`Invalid OpenUI Lang statement: ${raw}`);
+		return {
+			id: match[1],
+			expression: match[2].trim(),
+			raw
+		};
+	});
+}
+/**
+* Applies statement-level A2UI component patches without removing temporarily
+* unreachable statements. A later update may attach those statements to root.
+*/
+function mergeComponentStatements(existing, components) {
+	const statements = /* @__PURE__ */ new Map();
+	const order = [];
+	const upsert = (source, allowDeletion) => {
+		for (const statement of parseStatements(source)) {
+			if (allowDeletion && statement.expression === "null") {
+				statements.delete(statement.id);
+				const index = order.indexOf(statement.id);
+				if (index !== -1) order.splice(index, 1);
+				continue;
+			}
+			if (!statements.has(statement.id)) order.push(statement.id);
+			statements.set(statement.id, statement.raw);
+		}
+	};
+	if (existing.trim()) upsert(existing, false);
+	for (const component of components) upsert(component, true);
+	return order.map((id) => statements.get(id)).join("\n");
+}
+//#endregion
+//#region src/client.ts
+var A2UIFunctionError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.name = "A2UIFunctionError";
+		this.code = code;
+	}
+};
+function defaultId() {
+	return globalThis.crypto?.randomUUID?.() ?? `a2ui-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+function parseError(error) {
+	return {
+		source: "parser",
+		code: error.code,
+		message: error.message,
+		statementId: error.statementId,
+		component: error.component,
+		path: error.path
+	};
+}
+function isCreateSurface(message) {
+	return "createSurface" in message;
+}
+function isUpdateComponents(message) {
+	return "updateComponents" in message;
+}
+function isUpdateDataModel(message) {
+	return "updateDataModel" in message;
+}
+function isDeleteSurface(message) {
+	return "deleteSurface" in message;
+}
+function isCallRendererFunction(message) {
+	return "callRendererFunction" in message;
+}
+function record(value) {
+	return value != null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function validationTarget(input) {
+	const message = record(input);
+	if (!message) return {};
+	for (const key of [
+		"createSurface",
+		"updateComponents",
+		"updateDataModel",
+		"deleteSurface"
+	]) {
+		const payload = record(message[key]);
+		if (typeof payload?.surfaceId === "string") return { surfaceId: payload.surfaceId };
+	}
+	for (const key of ["callRendererFunction", "agentFunctionResponse"]) {
+		const payload = record(message[key]);
+		if (typeof payload?.functionCallId === "string") return { functionCallId: payload.functionCallId };
+	}
+	return {};
+}
+var A2UIClient = class {
+	#parser;
+	#functions;
+	#onMessage;
+	#rendererCapabilities;
+	#now;
+	#createId;
+	#surfaces = /* @__PURE__ */ new Map();
+	#surfaceListeners = /* @__PURE__ */ new Set();
+	#messageListeners = /* @__PURE__ */ new Set();
+	#pendingAgentFunctions = /* @__PURE__ */ new Map();
+	#revision = 0;
+	constructor(options) {
+		this.#parser = createParser(options.schema, options.rootName);
+		this.#functions = options.functions;
+		this.#onMessage = options.onMessage;
+		this.#rendererCapabilities = options.rendererCapabilities;
+		this.#now = options.now ?? (() => /* @__PURE__ */ new Date());
+		this.#createId = options.createId ?? defaultId;
+	}
+	subscribe(listener) {
+		this.#surfaceListeners.add(listener);
+		return () => this.#surfaceListeners.delete(listener);
+	}
+	subscribeMessages(listener) {
+		this.#messageListeners.add(listener);
+		return () => this.#messageListeners.delete(listener);
+	}
+	getSurface(surfaceId) {
+		return this.#surfaces.get(surfaceId);
+	}
+	getSurfaces() {
+		return [...this.#surfaces.values()];
+	}
+	getRendererDataModel() {
+		const surfaces = Object.fromEntries([...this.#surfaces].filter(([, surface]) => surface.sendDataModel).map(([surfaceId, surface]) => [surfaceId, structuredClone(surface.dataModel)]));
+		if (Object.keys(surfaces).length === 0) return void 0;
+		return {
+			version: "v1.0",
+			surfaces
+		};
+	}
+	getRendererMetadata() {
+		const dataModel = this.getRendererDataModel();
+		return {
+			...this.#rendererCapabilities ? { a2uiRendererCapabilities: structuredClone(this.#rendererCapabilities) } : {},
+			...dataModel ? { a2uiRendererDataModel: dataModel } : {}
+		};
+	}
+	async process(input) {
+		const outbound = [];
+		const capture = (next) => outbound.push(next);
+		this.#messageListeners.add(capture);
+		try {
+			const validated = validateAgentToRendererMessage(input);
+			if (!validated.success) return this.#invalidMessage(input, validated.issues, outbound);
+			const message = validated.message;
+			if (isCreateSurface(message)) return this.#createSurface(message, outbound);
+			if (isUpdateComponents(message)) return this.#updateComponents(message, outbound);
+			if (isUpdateDataModel(message)) return this.#updateDataModel(message, outbound);
+			if (isDeleteSurface(message)) return this.#deleteSurface(message, outbound);
+			if (isCallRendererFunction(message)) return await this.#callRendererFunction(message, outbound);
+			return this.#agentFunctionResponse(message, outbound);
+		} finally {
+			this.#messageListeners.delete(capture);
+		}
+	}
+	updateSurfaceFromOpenUIState(surfaceId, state) {
+		const surface = this.#surfaces.get(surfaceId);
+		if (!surface) return false;
+		const dataModel = mergeOpenUIStateIntoDataModel(surface.dataModel, state);
+		if (JSON.stringify(dataModel) === JSON.stringify(surface.dataModel)) return false;
+		this.#replaceSurface({
+			...surface,
+			dataModel
+		});
+		return true;
+	}
+	dispatchOpenUIAction(surfaceId, event, options = {}) {
+		const eventSourceComponentId = event.sourceComponentId;
+		const context = {
+			...toJsonObject(event.params),
+			...event.formState ? { formState: toJsonObject(event.formState) } : {},
+			...options.context
+		};
+		this.dispatchAction({
+			surfaceId,
+			sourceComponentId: options.sourceComponentId ?? (typeof eventSourceComponentId === "string" ? eventSourceComponentId : "root"),
+			name: options.name ?? event.type,
+			userMessage: (options.userMessage ?? event.humanFriendlyMessage) || void 0,
+			context,
+			metadata: options.metadata
+		});
+	}
+	dispatchAction(input) {
+		if (!this.#surfaces.has(input.surfaceId)) {
+			this.#emitGenericError("SURFACE_NOT_FOUND", `Unknown surface: ${input.surfaceId}`, input.surfaceId);
+			return;
+		}
+		const message = {
+			version: "v1.0",
+			action: {
+				name: input.name,
+				...input.userMessage ? { userMessage: input.userMessage } : {},
+				surfaceId: input.surfaceId,
+				sourceComponentId: input.sourceComponentId,
+				timestamp: this.#now().toISOString(),
+				context: input.context ?? {},
+				...input.metadata ? { metadata: input.metadata } : {}
+			}
+		};
+		this.#emit(message);
+	}
+	callAgentFunction(input) {
+		if (!this.#surfaces.has(input.surfaceId)) {
+			const message = `Unknown surface: ${input.surfaceId}`;
+			this.#emitGenericError("SURFACE_NOT_FOUND", message, input.surfaceId);
+			return Promise.reject(new A2UIFunctionError("SURFACE_NOT_FOUND", message));
+		}
+		const functionCallId = this.#createId();
+		return new Promise((resolve, reject) => {
+			this.#pendingAgentFunctions.set(functionCallId, {
+				surfaceId: input.surfaceId,
+				resolve,
+				reject
+			});
+			this.#emit({
+				version: "v1.0",
+				callAgentFunction: {
+					surfaceId: input.surfaceId,
+					functionCallId,
+					callFunction: {
+						call: input.call,
+						...input.catalogId ? { catalogId: input.catalogId } : {},
+						...input.args ? { args: input.args } : {}
+					}
+				}
+			});
+		});
+	}
+	dispose() {
+		for (const pending of this.#pendingAgentFunctions.values()) pending.reject(new A2UIFunctionError("CLIENT_DISPOSED", "A2UI client was disposed"));
+		this.#pendingAgentFunctions.clear();
+		this.#surfaces.clear();
+		this.#surfaceListeners.clear();
+		this.#messageListeners.clear();
+	}
+	#createSurface(message, outbound) {
+		const input = message.createSurface;
+		if (this.#surfaces.has(input.surfaceId)) {
+			this.#emitGenericError("SURFACE_ALREADY_EXISTS", `Surface already exists: ${input.surfaceId}`, input.surfaceId);
+			return {
+				ok: false,
+				outbound
+			};
+		}
+		const supportedCatalogIds = this.#rendererCapabilities?.["v1.0"].supportedCatalogIds ?? [];
+		if (input.catalogId && supportedCatalogIds.length > 0 && !supportedCatalogIds.includes(input.catalogId)) {
+			this.#emitGenericError("UNSUPPORTED_CATALOG", `Renderer does not support catalog: ${input.catalogId}`, input.surfaceId);
+			return {
+				ok: false,
+				outbound
+			};
+		}
+		let source = "";
+		let parseResult = null;
+		let errors = [];
+		if (input.components) try {
+			({source, parseResult, errors} = this.#mergeComponents("", input.components));
+		} catch (error) {
+			this.#emitValidationError(input.surfaceId, "/createSurface/components", error instanceof Error ? error.message : String(error));
+			return {
+				ok: false,
+				outbound
+			};
+		}
+		this.#replaceSurface({
+			surfaceId: input.surfaceId,
+			catalogId: input.catalogId,
+			metadata: input.metadata,
+			sendDataModel: input.sendDataModel ?? false,
+			source,
+			dataModel: structuredClone(input.dataModel ?? {}),
+			parseResult,
+			errors,
+			revision: 0
+		});
+		for (const error of errors) this.#emitValidationError(input.surfaceId, "/createSurface/components", error.statementId ? `${error.statementId}: ${error.message}` : error.message);
+		return {
+			ok: errors.length === 0,
+			outbound
+		};
+	}
+	#updateComponents(message, outbound) {
+		const input = message.updateComponents;
+		const surface = this.#requireSurface(input.surfaceId);
+		if (!surface) return {
+			ok: false,
+			outbound
+		};
+		try {
+			const { source, parseResult, errors } = this.#mergeComponents(surface.source, input.components);
+			this.#replaceSurface({
+				...surface,
+				source,
+				parseResult,
+				errors
+			});
+			for (const error of errors) this.#emitValidationError(input.surfaceId, "/updateComponents/components", error.statementId ? `${error.statementId}: ${error.message}` : error.message);
+			return {
+				ok: errors.length === 0,
+				outbound
+			};
+		} catch (error) {
+			this.#emitValidationError(input.surfaceId, "/updateComponents/components", error instanceof Error ? error.message : String(error));
+			return {
+				ok: false,
+				outbound
+			};
+		}
+	}
+	#updateDataModel(message, outbound) {
+		const input = message.updateDataModel;
+		const surface = this.#requireSurface(input.surfaceId);
+		if (!surface) return {
+			ok: false,
+			outbound
+		};
+		try {
+			const dataModel = applyDataModelUpdate(surface.dataModel, input.path, input.value);
+			this.#replaceSurface({
+				...surface,
+				dataModel
+			});
+			return {
+				ok: true,
+				outbound
+			};
+		} catch (error) {
+			this.#emitValidationError(input.surfaceId, "/updateDataModel/path", error instanceof Error ? error.message : String(error));
+			return {
+				ok: false,
+				outbound
+			};
+		}
+	}
+	#deleteSurface(message, outbound) {
+		const surfaceId = message.deleteSurface.surfaceId;
+		if (!this.#requireSurface(surfaceId)) return {
+			ok: false,
+			outbound
+		};
+		this.#surfaces.delete(surfaceId);
+		for (const [functionCallId, pending] of this.#pendingAgentFunctions) if (pending.surfaceId === surfaceId) {
+			pending.reject(new A2UIFunctionError("SURFACE_DELETED", `Surface was deleted: ${surfaceId}`));
+			this.#pendingAgentFunctions.delete(functionCallId);
+		}
+		this.#notify();
+		return {
+			ok: true,
+			outbound
+		};
+	}
+	async #callRendererFunction(message, outbound) {
+		const { functionCallId, callFunction } = message.callRendererFunction;
+		const { call, catalogId, args = {} } = callFunction;
+		const registration = this.#functions?.[call];
+		if (!registration) {
+			this.#emitGenericError("INVALID_FUNCTION_CALL", `Renderer function is not registered: ${call}`, void 0, functionCallId);
+			return {
+				ok: false,
+				outbound
+			};
+		}
+		const fn = typeof registration === "function" ? registration : registration.handler;
+		if (typeof registration === "function" || (registration.allowedCallers ?? "rendererOnly") === "rendererOnly" || registration.catalogId !== catalogId) {
+			this.#emitGenericError("INVALID_FUNCTION_CALL", `Renderer function is not callable from catalog ${catalogId}: ${call}`, void 0, functionCallId);
+			return {
+				ok: false,
+				outbound
+			};
+		}
+		try {
+			const value = await fn(args);
+			this.#emit({
+				version: "v1.0",
+				rendererFunctionResponse: {
+					functionCallId,
+					value
+				}
+			});
+			return {
+				ok: true,
+				outbound
+			};
+		} catch (error) {
+			this.#emit({
+				version: "v1.0",
+				rendererFunctionResponse: {
+					functionCallId,
+					error: {
+						code: "EXECUTION_FAILED",
+						message: error instanceof Error ? error.message : String(error)
+					}
+				}
+			});
+			return {
+				ok: false,
+				outbound
+			};
+		}
+	}
+	#agentFunctionResponse(message, outbound) {
+		const response = message.agentFunctionResponse;
+		const pending = this.#pendingAgentFunctions.get(response.functionCallId);
+		if (!pending) return {
+			ok: false,
+			outbound,
+			issues: [{
+				path: "/agentFunctionResponse/functionCallId",
+				message: `Unknown functionCallId: ${response.functionCallId}`
+			}]
+		};
+		this.#pendingAgentFunctions.delete(response.functionCallId);
+		if ("error" in response) {
+			pending.reject(new A2UIFunctionError(response.error.code, response.error.message));
+			return {
+				ok: true,
+				outbound
+			};
+		}
+		pending.resolve(response.value);
+		return {
+			ok: true,
+			outbound
+		};
+	}
+	#replaceSurface(surface) {
+		this.#revision += 1;
+		this.#surfaces.set(surface.surfaceId, {
+			...surface,
+			revision: this.#revision
+		});
+		this.#notify();
+	}
+	#mergeComponents(existing, components) {
+		const source = mergeComponentStatements(existing, components);
+		const parseResult = this.#parser.parse(source);
+		return {
+			source,
+			parseResult,
+			errors: parseResult.meta.errors.map(parseError)
+		};
+	}
+	#invalidMessage(input, issues, outbound) {
+		const target = validationTarget(input);
+		const issue = issues[0] ?? {
+			path: "/",
+			message: "Invalid A2UI message"
+		};
+		if (target.surfaceId !== void 0) {
+			this.#emitValidationError(target.surfaceId, issue.path, issue.message);
+			return {
+				ok: false,
+				outbound,
+				issues
+			};
+		}
+		if (target.functionCallId !== void 0) {
+			this.#emitGenericError("INVALID_MESSAGE", `${issue.path}: ${issue.message}`, void 0, target.functionCallId);
+			return {
+				ok: false,
+				outbound,
+				issues
+			};
+		}
+		return {
+			ok: false,
+			outbound,
+			issues
+		};
+	}
+	#requireSurface(surfaceId) {
+		const surface = this.#surfaces.get(surfaceId);
+		if (!surface) this.#emitGenericError("SURFACE_NOT_FOUND", `Unknown surface: ${surfaceId}`, surfaceId);
+		return surface;
+	}
+	#emitValidationError(surfaceId, path, message) {
+		const error = {
+			version: "v1.0",
+			error: {
+				code: "VALIDATION_FAILED",
+				surfaceId,
+				path,
+				message
+			}
+		};
+		this.#emit(error);
+	}
+	#emitGenericError(code, message, surfaceId, functionCallId) {
+		if (surfaceId === void 0 && functionCallId === void 0) return;
+		const error = surfaceId !== void 0 ? {
+			version: "v1.0",
+			error: {
+				code,
+				message,
+				surfaceId
+			}
+		} : {
+			version: "v1.0",
+			error: {
+				code,
+				message,
+				functionCallId
+			}
+		};
+		this.#emit(error);
+	}
+	#emit(message) {
+		const metadata = this.getRendererMetadata();
+		this.#onMessage?.(message, metadata);
+		for (const listener of this.#messageListeners) listener(message, metadata);
+	}
+	#notify() {
+		for (const listener of this.#surfaceListeners) listener();
+	}
+};
+function createA2UIClient(options) {
+	return new A2UIClient(options);
+}
+//#endregion
+export { A2UIClient, A2UIFunctionError, a2uiFunctionCallSchema, a2uiFunctionResponseSchema, actionMessageSchema, agentCapabilitiesSchema, agentFunctionResponseMessageSchema, agentToRendererMessageSchema, applyDataModelUpdate, callAgentFunctionMessageSchema, callRendererFunctionMessageSchema, createA2UIClient, createSurfaceMessageSchema, dataModelToOpenUIState, deleteSurfaceMessageSchema, genericErrorMessageSchema, jsonObjectSchema, jsonValueSchema, mergeOpenUIStateIntoDataModel, messageMetadataSchema, rendererCapabilitiesSchema, rendererDataModelSchema, rendererFunctionResponseMessageSchema, rendererToAgentMessageSchema, updateComponentsMessageSchema, updateDataModelMessageSchema, validateAgentToRendererMessage, validationFailedErrorMessageSchema };
+
+//# sourceMappingURL=index.mjs.map