experimental-a2 0.0.0

package/dist/ai.js

@@ -0,0 +1,922 @@
+import { t as assertSyncSchema } from "./validate-XKT4FSNn.js";
+import { t as contract } from "./contract-B0kAXoaL.js";
+//#region src/ai-projector.ts
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const cloneMessage = (messageId, base) => structuredClone(base ?? {
+	id: messageId,
+	role: "assistant",
+	parts: []
+});
+const currentStepParts = (parts) => {
+	let start = parts.length - 1;
+	while (start >= 0 && parts[start]?.["type"] !== "step-start") start -= 1;
+	return parts.slice(start + 1);
+};
+const isToolPart = (part) => typeof part["toolCallId"] === "string" && (part["type"] === "dynamic-tool" || typeof part["type"] === "string" && part["type"].startsWith("tool-"));
+const findToolPart = (parts, toolCallId) => {
+	const current = currentStepParts(parts).find((part) => isToolPart(part) && part["toolCallId"] === toolCallId);
+	if (current) return current;
+	return parts.findLast((part) => isToolPart(part) && part["toolCallId"] === toolCallId);
+};
+const findApprovalPart = (parts, approvalId) => parts.find((part) => {
+	const approval = part["approval"];
+	return isToolPart(part) && isRecord$1(approval) && approval["id"] === approvalId;
+});
+const setOptional = (target, key, value) => {
+	if (value !== void 0) target[key] = value;
+};
+const setToolPart = (options) => {
+	let part = findToolPart(options.parts, options.toolCallId);
+	if (!part) {
+		part = {
+			type: options.dynamic ? "dynamic-tool" : `tool-${options.toolName}`,
+			...options.dynamic ? { toolName: options.toolName } : {},
+			toolCallId: options.toolCallId
+		};
+		options.parts.push(part);
+	}
+	part["state"] = options.state;
+	part["input"] = options.input;
+	delete part["output"];
+	delete part["rawInput"];
+	delete part["errorText"];
+	delete part["preliminary"];
+	setOptional(part, "rawInput", options.rawInput);
+	setOptional(part, "output", options.output);
+	setOptional(part, "errorText", options.errorText);
+	setOptional(part, "preliminary", options.preliminary);
+	setOptional(part, "providerExecuted", options.providerExecuted);
+	setOptional(part, "title", options.title);
+	setOptional(part, "toolMetadata", options.toolMetadata);
+	if (options.dynamic) part["toolName"] = options.toolName;
+	if (options.providerMetadata !== void 0) part[options.state === "output-available" || options.state === "output-error" ? "resultProviderMetadata" : "callProviderMetadata"] = options.providerMetadata;
+	return part;
+};
+const mergeMetadata = (current, update) => {
+	if (update === void 0 || update === null) return current;
+	return isRecord$1(current) && isRecord$1(update) ? {
+		...current,
+		...update
+	} : update;
+};
+const parseCompleteJSON = (value) => {
+	try {
+		return JSON.parse(value);
+	} catch {
+		return;
+	}
+};
+/** Internal synchronous counterpart of the AI SDK UI message stream fold. */
+function projectUIMessage(options) {
+	const message = cloneMessage(options.messageId, options.base);
+	const record = message;
+	const parts = message.parts;
+	const activeText = /* @__PURE__ */ new Map();
+	const activeReasoning = /* @__PURE__ */ new Map();
+	const partialTools = /* @__PURE__ */ new Map();
+	for (const chunk of options.chunks) switch (chunk.type) {
+		case "text-start": {
+			const part = {
+				type: "text",
+				text: "",
+				state: "streaming",
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			};
+			activeText.set(chunk.id, part);
+			parts.push(part);
+			break;
+		}
+		case "text-delta": {
+			let part = activeText.get(chunk.id);
+			if (!part) {
+				part = {
+					type: "text",
+					text: "",
+					state: "streaming"
+				};
+				activeText.set(chunk.id, part);
+				parts.push(part);
+			}
+			part["text"] = `${typeof part["text"] === "string" ? part["text"] : ""}${chunk.delta}`;
+			setOptional(part, "providerMetadata", chunk.providerMetadata);
+			break;
+		}
+		case "text-end": {
+			const part = activeText.get(chunk.id);
+			if (part) {
+				part["state"] = "done";
+				setOptional(part, "providerMetadata", chunk.providerMetadata);
+				activeText.delete(chunk.id);
+			}
+			break;
+		}
+		case "reasoning-start": {
+			const part = {
+				type: "reasoning",
+				text: "",
+				state: "streaming",
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			};
+			activeReasoning.set(chunk.id, part);
+			parts.push(part);
+			break;
+		}
+		case "reasoning-delta": {
+			let part = activeReasoning.get(chunk.id);
+			if (!part) {
+				part = {
+					type: "reasoning",
+					text: "",
+					state: "streaming"
+				};
+				activeReasoning.set(chunk.id, part);
+				parts.push(part);
+			}
+			part["text"] = `${typeof part["text"] === "string" ? part["text"] : ""}${chunk.delta}`;
+			setOptional(part, "providerMetadata", chunk.providerMetadata);
+			break;
+		}
+		case "reasoning-end": {
+			const part = activeReasoning.get(chunk.id);
+			if (part) {
+				part["state"] = "done";
+				setOptional(part, "providerMetadata", chunk.providerMetadata);
+				activeReasoning.delete(chunk.id);
+			}
+			break;
+		}
+		case "custom":
+			parts.push({
+				type: "custom",
+				kind: chunk.kind,
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "file":
+		case "reasoning-file":
+			parts.push({
+				type: chunk.type,
+				mediaType: chunk.mediaType,
+				url: chunk.url,
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "source-url":
+			parts.push({
+				type: chunk.type,
+				sourceId: chunk.sourceId,
+				url: chunk.url,
+				...chunk.title === void 0 ? {} : { title: chunk.title },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "source-document":
+			parts.push({
+				type: chunk.type,
+				sourceId: chunk.sourceId,
+				mediaType: chunk.mediaType,
+				title: chunk.title,
+				...chunk.filename === void 0 ? {} : { filename: chunk.filename },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata }
+			});
+			break;
+		case "tool-input-start":
+			partialTools.set(chunk.toolCallId, {
+				text: "",
+				toolName: chunk.toolName,
+				dynamic: chunk.dynamic === true,
+				...chunk.providerExecuted === void 0 ? {} : { providerExecuted: chunk.providerExecuted },
+				...chunk.providerMetadata === void 0 ? {} : { providerMetadata: chunk.providerMetadata },
+				...chunk.toolMetadata === void 0 ? {} : { toolMetadata: chunk.toolMetadata },
+				...chunk.title === void 0 ? {} : { title: chunk.title }
+			});
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				dynamic: chunk.dynamic === true,
+				state: "input-streaming",
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata,
+				title: chunk.title
+			});
+			break;
+		case "tool-input-delta": {
+			const partial = partialTools.get(chunk.toolCallId);
+			if (!partial) break;
+			partial.text += chunk.inputTextDelta;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: partial.toolName,
+				dynamic: partial.dynamic,
+				state: "input-streaming",
+				input: parseCompleteJSON(partial.text),
+				providerExecuted: partial.providerExecuted,
+				providerMetadata: partial.providerMetadata,
+				toolMetadata: partial.toolMetadata,
+				title: partial.title
+			});
+			break;
+		}
+		case "tool-input-available":
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				dynamic: chunk.dynamic === true,
+				state: "input-available",
+				input: chunk.input,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata,
+				title: chunk.title
+			});
+			partialTools.delete(chunk.toolCallId);
+			break;
+		case "tool-input-error": {
+			const dynamic = findToolPart(parts, chunk.toolCallId)?.["type"] === "dynamic-tool" || chunk.dynamic;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: chunk.toolName,
+				dynamic: dynamic === true,
+				state: "output-error",
+				input: dynamic ? chunk.input : void 0,
+				rawInput: dynamic ? void 0 : chunk.input,
+				errorText: chunk.errorText,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata,
+				title: chunk.title
+			});
+			partialTools.delete(chunk.toolCallId);
+			break;
+		}
+		case "tool-approval-request": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (!part) break;
+			part["state"] = "approval-requested";
+			part["approval"] = {
+				id: chunk.approvalId,
+				...chunk.isAutomatic === true ? { isAutomatic: true } : {},
+				...chunk.signature === void 0 ? {} : { signature: chunk.signature }
+			};
+			break;
+		}
+		case "tool-approval-response": {
+			const part = findApprovalPart(parts, chunk.approvalId);
+			if (!part) break;
+			const approval = isRecord$1(part["approval"]) ? part["approval"] : {};
+			part["state"] = "approval-responded";
+			part["approval"] = {
+				id: chunk.approvalId,
+				approved: chunk.approved,
+				...chunk.reason === void 0 ? {} : { reason: chunk.reason },
+				...approval["isAutomatic"] === true ? { isAutomatic: true } : {},
+				...typeof approval["signature"] === "string" ? { signature: approval["signature"] } : {}
+			};
+			setOptional(part, "providerExecuted", chunk.providerExecuted);
+			setOptional(part, "callProviderMetadata", chunk.providerMetadata);
+			break;
+		}
+		case "tool-output-available": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (!part) break;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: part["type"] === "dynamic-tool" && typeof part["toolName"] === "string" ? part["toolName"] : String(part["type"]).slice(5),
+				dynamic: part["type"] === "dynamic-tool",
+				state: "output-available",
+				input: part["input"],
+				output: chunk.output,
+				preliminary: chunk.preliminary,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata ?? part["toolMetadata"],
+				title: typeof part["title"] === "string" ? part["title"] : void 0
+			});
+			break;
+		}
+		case "tool-output-error": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (!part) break;
+			setToolPart({
+				parts,
+				toolCallId: chunk.toolCallId,
+				toolName: part["type"] === "dynamic-tool" && typeof part["toolName"] === "string" ? part["toolName"] : String(part["type"]).slice(5),
+				dynamic: part["type"] === "dynamic-tool",
+				state: "output-error",
+				input: part["input"],
+				rawInput: part["rawInput"],
+				errorText: chunk.errorText,
+				providerExecuted: chunk.providerExecuted,
+				providerMetadata: chunk.providerMetadata,
+				toolMetadata: chunk.toolMetadata ?? part["toolMetadata"],
+				title: typeof part["title"] === "string" ? part["title"] : void 0
+			});
+			break;
+		}
+		case "tool-output-denied": {
+			const part = findToolPart(parts, chunk.toolCallId);
+			if (part) part["state"] = "output-denied";
+			break;
+		}
+		case "start-step":
+			parts.push({ type: "step-start" });
+			break;
+		case "finish-step":
+			activeText.clear();
+			activeReasoning.clear();
+			break;
+		case "start":
+			if (chunk.messageId !== void 0) record["id"] = chunk.messageId;
+			if (chunk.messageMetadata !== void 0 && chunk.messageMetadata !== null) record["metadata"] = mergeMetadata(record["metadata"], chunk.messageMetadata);
+			break;
+		case "finish":
+			if (chunk.messageMetadata !== void 0 && chunk.messageMetadata !== null) record["metadata"] = mergeMetadata(record["metadata"], chunk.messageMetadata);
+			break;
+		case "message-metadata":
+			if (chunk.messageMetadata !== void 0 && chunk.messageMetadata !== null) record["metadata"] = mergeMetadata(record["metadata"], chunk.messageMetadata);
+			break;
+		case "abort":
+		case "error": break;
+		default: {
+			if (!chunk.type.startsWith("data-") || chunk.transient) break;
+			const existing = chunk.id === void 0 ? void 0 : parts.find((part) => part["type"] === chunk.type && part["id"] === chunk.id);
+			if (existing) existing["data"] = chunk.data;
+			else parts.push({
+				type: chunk.type,
+				...chunk.id === void 0 ? {} : { id: chunk.id },
+				data: chunk.data
+			});
+		}
+	}
+	return message;
+}
+function interruptUIMessage(message, toolError = "Tool execution was interrupted.") {
+	const next = structuredClone(message);
+	for (const value of next.parts) {
+		if (value["type"] === "text" || value["type"] === "reasoning") {
+			if (value["state"] === "streaming") value["state"] = "done";
+			continue;
+		}
+		if (!isToolPart(value)) continue;
+		const state = value["state"];
+		if (state === "approval-responded") {
+			const approval = value["approval"];
+			if (isRecord$1(approval) && approval["approved"] === false) {
+				value["state"] = "output-denied";
+				continue;
+			}
+		}
+		if (state === "output-available" && value["preliminary"] === true) {
+			delete value["output"];
+			delete value["preliminary"];
+			value["state"] = "output-error";
+			value["errorText"] = toolError;
+			continue;
+		}
+		if (state === "input-streaming" || state === "input-available" || state === "approval-requested" || state === "approval-responded") {
+			if (state === "approval-requested") delete value["approval"];
+			value["state"] = "output-error";
+			value["errorText"] = toolError;
+		}
+	}
+	return next;
+}
+//#endregion
+//#region src/ai.ts
+const issue = (message) => ({ issues: [{ message }] });
+const schema = (label, parse) => ({ "~standard": {
+	version: 1,
+	vendor: "a2",
+	validate(value) {
+		try {
+			return parse(value);
+		} catch (error) {
+			return issue(`${label}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+	}
+} });
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isJSONCompatible = (value, seen = /* @__PURE__ */ new Set()) => {
+	if (value === null || typeof value === "string" || typeof value === "boolean") return true;
+	if (typeof value === "number") return Number.isFinite(value);
+	if (typeof value === "undefined") return true;
+	if (typeof value !== "object") return false;
+	if (seen.has(value)) return false;
+	seen.add(value);
+	const valid = Array.isArray(value) ? value.every((item) => isJSONCompatible(item, seen)) : Object.getPrototypeOf(value) === Object.prototype && Object.values(value).every((item) => isJSONCompatible(item, seen));
+	seen.delete(value);
+	return valid;
+};
+const jsonObject = (label, check) => schema(label, (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !check(value)) return issue(`invalid ${label}`);
+	return { value };
+});
+const stringField = (value, key) => typeof value[key] === "string" && value[key].length > 0;
+const optionalStringField = (value, key) => value[key] === void 0 || typeof value[key] === "string";
+const messageValue = (value) => isRecord(value) && typeof value["id"] === "string" && (value["role"] === "user" || value["role"] === "assistant" || value["role"] === "system") && Array.isArray(value["parts"]) && value["parts"].every((part) => isRecord(part) && typeof part["type"] === "string") && isJSONCompatible(value);
+const validateMessage = (value, messageSchema) => {
+	if (!messageValue(value)) return issue("invalid AI SDK UIMessage");
+	if (!messageSchema) return { value };
+	const result = messageSchema["~standard"].validate(value);
+	if (result instanceof Promise) throw new TypeError("the AI message schema must validate synchronously");
+	return result;
+};
+const messagePayloadSchema = (messageSchema) => schema("ai.message.created", (value) => {
+	if (!isRecord(value)) return issue("invalid ai.message.created payload");
+	const message = validateMessage(value["message"], messageSchema);
+	if (message.issues) return { issues: message.issues };
+	return { value: { message: message.value } };
+});
+const progressPayloadSchema = schema("ai.generation.progress", (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "requestId") || !stringField(value, "messageId") || !stringField(value, "generationId") || !stringField(value, "responseMessageId") || typeof value["sequence"] !== "number" || !Number.isInteger(value["sequence"]) || value["sequence"] < 0 || !Array.isArray(value["chunks"]) || !value["chunks"].every((chunk) => isRecord(chunk) && typeof chunk["type"] === "string")) return issue("invalid ai.generation.progress payload");
+	return { value };
+});
+const completedPayloadSchema = schema("ai.generation.completed", (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "requestId") || !stringField(value, "messageId") || !stringField(value, "generationId") || !stringField(value, "responseMessageId") || !optionalStringField(value, "finishReason")) return issue("invalid ai.generation.completed payload");
+	return { value };
+});
+const compactionPayloadSchema = (messageSchema) => schema("ai.compaction.completed", (value) => {
+	if (!isRecord(value) || !isJSONCompatible(value) || !stringField(value, "generationId") || !stringField(value, "throughMessageId") || !Array.isArray(value["messages"])) return issue("invalid ai.compaction.completed payload");
+	const messages = [];
+	for (const candidate of value["messages"]) {
+		const result = validateMessage(candidate, messageSchema);
+		if (result.issues) return { issues: result.issues };
+		messages.push(result.value);
+	}
+	return { value: {
+		generationId: value["generationId"],
+		throughMessageId: value["throughMessageId"],
+		messages
+	} };
+});
+function createEvents(options) {
+	const messageSchema = options?.messageSchema;
+	if (messageSchema) assertSyncSchema(messageSchema, "the AI message schema");
+	return {
+		"ai.session.created": jsonObject("ai.session.created", () => true),
+		"ai.session.closed": jsonObject("ai.session.closed", (value) => optionalStringField(value, "reason")),
+		"ai.message.created": messagePayloadSchema(messageSchema),
+		"ai.message.completed": jsonObject("ai.message.completed", (value) => stringField(value, "messageId")),
+		"ai.message.interrupted": jsonObject("ai.message.interrupted", (value) => stringField(value, "messageId") && optionalStringField(value, "generationId") && optionalStringField(value, "reason") && (value["lastSeenIndex"] === void 0 || typeof value["lastSeenIndex"] === "number" && Number.isInteger(value["lastSeenIndex"]) && value["lastSeenIndex"] >= 0)),
+		"ai.generation.requested": jsonObject("ai.generation.requested", (value) => stringField(value, "messageId") && optionalStringField(value, "responseMessageId") && (value["reason"] === "message" || value["reason"] === "approval" || value["reason"] === "input" || value["reason"] === "retry")),
+		"ai.generation.started": jsonObject("ai.generation.started", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "responseMessageId") && typeof value["attempt"] === "number" && Number.isInteger(value["attempt"]) && value["attempt"] > 0 && stringField(value, "model")),
+		"ai.generation.progress": progressPayloadSchema,
+		"ai.generation.completed": completedPayloadSchema,
+		"ai.generation.failed": jsonObject("ai.generation.failed", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "responseMessageId") && stringField(value, "error") && (value["superseded"] === void 0 || typeof value["superseded"] === "boolean")),
+		"ai.tool.called": jsonObject("ai.tool.called", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "toolCallId") && stringField(value, "toolName") && (value["dynamic"] === void 0 || typeof value["dynamic"] === "boolean") && (value["providerExecuted"] === void 0 || typeof value["providerExecuted"] === "boolean") && optionalStringField(value, "title")),
+		"ai.tool.result": jsonObject("ai.tool.result", (value) => stringField(value, "requestId") && stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "toolCallId") && optionalStringField(value, "toolName") && optionalStringField(value, "error") && (value["denied"] === void 0 || typeof value["denied"] === "boolean") && (value["preliminary"] === void 0 || typeof value["preliminary"] === "boolean") && (value["phase"] === void 0 || value["phase"] === "input" || value["phase"] === "execution") && (value["dynamic"] === void 0 || typeof value["dynamic"] === "boolean") && (value["providerExecuted"] === void 0 || typeof value["providerExecuted"] === "boolean")),
+		"ai.approval.requested": jsonObject("ai.approval.requested", (value) => stringField(value, "messageId") && stringField(value, "generationId") && stringField(value, "approvalId") && stringField(value, "toolCallId") && (value["isAutomatic"] === void 0 || typeof value["isAutomatic"] === "boolean") && optionalStringField(value, "signature")),
+		"ai.approval.responded": jsonObject("ai.approval.responded", (value) => stringField(value, "messageId") && stringField(value, "approvalId") && typeof value["approved"] === "boolean" && optionalStringField(value, "reason")),
+		"ai.input.requested": jsonObject("ai.input.requested", (value) => stringField(value, "messageId") && optionalStringField(value, "generationId") && stringField(value, "inputId") && stringField(value, "name")),
+		"ai.input.responded": jsonObject("ai.input.responded", (value) => stringField(value, "messageId") && stringField(value, "inputId") && stringField(value, "name")),
+		"ai.compaction.requested": jsonObject("ai.compaction.requested", (value) => stringField(value, "generationId") && stringField(value, "throughMessageId")),
+		"ai.compaction.completed": compactionPayloadSchema(messageSchema)
+	};
+}
+const events = createEvents();
+const initialState = () => ({
+	session: { created: false },
+	messages: [],
+	status: "idle",
+	activeGeneration: null,
+	activeProjection: null,
+	pendingApprovals: [],
+	pendingInputs: [],
+	tools: [],
+	compaction: null,
+	usage: [],
+	error: null
+});
+const upsertMessage = (messages, message) => {
+	const index = messages.findIndex((candidate) => candidate.id === message.id);
+	if (index === -1) return [...messages, message];
+	const next = [...messages];
+	next[index] = message;
+	return next;
+};
+const answerApproval = (messages, response) => messages.map((message) => {
+	if (message.id !== response.messageId) return message;
+	let changed = false;
+	const parts = message.parts.map((part) => {
+		const candidate = part;
+		if (!isRecord(candidate) || candidate["state"] !== "approval-requested" || !isRecord(candidate["approval"]) || candidate["approval"]["id"] !== response.approvalId) return part;
+		changed = true;
+		return {
+			...part,
+			state: "approval-responded",
+			approval: {
+				...candidate["approval"],
+				approved: response.approved,
+				...response.reason === void 0 ? {} : { reason: response.reason }
+			}
+		};
+	});
+	return changed ? {
+		...message,
+		parts
+	} : message;
+});
+const waitingStatus = (state) => state.pendingApprovals.length > 0 || state.pendingInputs.length > 0 ? "waiting" : "idle";
+const projectedMessage = (projection) => projectUIMessage({
+	messageId: projection.responseMessageId,
+	...projection.baseMessage === void 0 ? {} : { base: projection.baseMessage },
+	chunks: projection.batches.flatMap((batch) => batch.chunks)
+});
+const reduceToolActivity = (tools, event) => {
+	if (event.type === "ai.tool.called") {
+		const payload = event.payload;
+		const { providerMetadata, ...called } = payload;
+		const tool = {
+			...called,
+			...providerMetadata === void 0 ? {} : { callProviderMetadata: providerMetadata },
+			status: "running"
+		};
+		return [...tools.filter((candidate) => candidate.toolCallId !== payload.toolCallId), tool];
+	}
+	const payload = event.payload;
+	const existing = tools.find((candidate) => candidate.toolCallId === payload.toolCallId);
+	const toolName = payload.toolName ?? existing?.toolName;
+	const input = payload.input === void 0 ? existing?.input : payload.input;
+	const dynamic = payload.dynamic ?? existing?.dynamic;
+	const providerExecuted = payload.providerExecuted ?? existing?.providerExecuted;
+	const toolMetadata = payload.toolMetadata ?? existing?.toolMetadata;
+	const resultProviderMetadata = payload.providerMetadata ?? existing?.resultProviderMetadata;
+	const tool = {
+		requestId: payload.requestId,
+		messageId: payload.messageId,
+		generationId: payload.generationId,
+		toolCallId: payload.toolCallId,
+		...toolName === void 0 ? {} : { toolName },
+		...input === void 0 ? {} : { input },
+		...payload.rawInput === void 0 ? {} : { rawInput: payload.rawInput },
+		...payload.output === void 0 ? {} : { output: payload.output },
+		...payload.error === void 0 ? {} : { error: payload.error },
+		...payload.preliminary === void 0 ? {} : { preliminary: payload.preliminary },
+		...payload.phase === void 0 ? {} : { phase: payload.phase },
+		...dynamic === void 0 ? {} : { dynamic },
+		...providerExecuted === void 0 ? {} : { providerExecuted },
+		...existing?.callProviderMetadata === void 0 ? {} : { callProviderMetadata: existing.callProviderMetadata },
+		...resultProviderMetadata === void 0 ? {} : { resultProviderMetadata },
+		...toolMetadata === void 0 ? {} : { toolMetadata },
+		...existing?.title === void 0 ? {} : { title: existing.title },
+		status: payload.denied ? "denied" : payload.error ? "failed" : payload.preliminary ? "running" : "completed"
+	};
+	return [...tools.filter((candidate) => candidate.toolCallId !== payload.toolCallId), tool];
+};
+const projectedTools = (projection) => projection.toolEvents.reduce((tools, event) => reduceToolActivity(tools, event), projection.baseTools);
+const stopGenerationTools = (tools, generationId, responseMessageId, error) => tools.map((tool) => (tool.generationId === generationId || tool.messageId === responseMessageId) && tool.status === "running" ? {
+	...tool,
+	status: "failed",
+	error,
+	preliminary: false
+} : tool);
+/** Pure projection of the built-in AI protocol. Unknown extension events are ignored. */
+function reduceAIState(state, event) {
+	if (state.status === "closed") return state;
+	switch (event.type) {
+		case "ai.session.created": {
+			const payload = event.payload;
+			return {
+				...state,
+				session: {
+					created: true,
+					...payload.metadata === void 0 ? state.session.metadata === void 0 ? {} : { metadata: state.session.metadata } : { metadata: payload.metadata }
+				}
+			};
+		}
+		case "ai.session.closed": return {
+			...state,
+			status: "closed",
+			activeGeneration: null,
+			activeProjection: null
+		};
+		case "ai.message.created": {
+			const { message } = event.payload;
+			return {
+				...state,
+				messages: upsertMessage(state.messages, message)
+			};
+		}
+		case "ai.generation.requested": {
+			const payload = event.payload;
+			return {
+				...state,
+				messages: payload.reason === "retry" && payload.responseMessageId !== void 0 ? state.messages.filter((message) => message.id !== payload.responseMessageId) : state.messages,
+				status: "generating",
+				error: null
+			};
+		}
+		case "ai.generation.started": {
+			const payload = event.payload;
+			const baseMessage = state.messages.find((message) => message.id === payload.responseMessageId);
+			return {
+				...state,
+				status: "generating",
+				activeGeneration: payload,
+				activeProjection: {
+					generationId: payload.generationId,
+					responseMessageId: payload.responseMessageId,
+					...baseMessage === void 0 ? {} : { baseMessage },
+					batches: [],
+					baseTools: state.tools,
+					toolEvents: []
+				},
+				error: null
+			};
+		}
+		case "ai.generation.progress": {
+			const payload = event.payload;
+			const activeProjection = state.activeProjection;
+			if (state.activeGeneration?.generationId !== payload.generationId || activeProjection?.generationId !== payload.generationId) return state;
+			const projection = {
+				...activeProjection,
+				batches: [...activeProjection.batches.filter((batch) => batch.index !== event.index), {
+					index: event.index,
+					chunks: payload.chunks
+				}].toSorted((left, right) => left.index - right.index)
+			};
+			return {
+				...state,
+				messages: upsertMessage(state.messages, projectedMessage(projection)),
+				activeProjection: projection,
+				status: "generating"
+			};
+		}
+		case "ai.generation.completed": {
+			const payload = event.payload;
+			if (state.activeGeneration?.generationId !== payload.generationId) return state;
+			const usage = payload.usage ? [...state.usage.filter((entry) => entry.generationId !== payload.generationId), {
+				generationId: payload.generationId,
+				usage: payload.usage
+			}] : state.usage;
+			const next = {
+				...state,
+				activeGeneration: null,
+				activeProjection: null,
+				usage
+			};
+			return {
+				...next,
+				status: waitingStatus(next)
+			};
+		}
+		case "ai.generation.failed": {
+			const payload = event.payload;
+			if (state.activeGeneration?.generationId !== payload.generationId) return state;
+			if (payload.superseded === true) return {
+				...state,
+				messages: state.messages.filter((message) => message.id !== payload.responseMessageId),
+				tools: state.tools.filter((tool) => tool.generationId !== payload.generationId),
+				activeGeneration: null,
+				activeProjection: null
+			};
+			const projection = state.activeProjection;
+			const shouldProject = projection?.generationId === payload.generationId && (projection.baseMessage !== void 0 || projection.batches.length > 0);
+			return {
+				...state,
+				messages: shouldProject ? upsertMessage(state.messages, interruptUIMessage(projectedMessage(projection), `Generation failed before tool completion: ${payload.error}`)) : state.messages,
+				status: "failed",
+				activeGeneration: null,
+				activeProjection: null,
+				pendingApprovals: state.pendingApprovals.filter((approval) => approval.generationId !== payload.generationId),
+				tools: stopGenerationTools(state.tools, payload.generationId, payload.responseMessageId, payload.error),
+				error: payload.error
+			};
+		}
+		case "ai.message.interrupted": {
+			const payload = event.payload;
+			const active = state.activeGeneration;
+			if (active === null || (payload.generationId === void 0 ? payload.messageId !== active.responseMessageId : payload.generationId !== active.generationId)) return state;
+			const projection = state.activeProjection;
+			const cutoff = payload.lastSeenIndex ?? Number.POSITIVE_INFINITY;
+			const retained = projection?.generationId === active.generationId ? {
+				...projection,
+				batches: projection.batches.filter((batch) => batch.index <= cutoff),
+				toolEvents: projection.toolEvents.filter((toolEvent) => toolEvent.index <= cutoff)
+			} : null;
+			const shouldProject = retained !== null && (retained.baseMessage !== void 0 || retained.batches.length > 0);
+			const next = {
+				...state,
+				messages: shouldProject ? upsertMessage(state.messages, interruptUIMessage(projectedMessage(retained))) : state.messages,
+				activeGeneration: null,
+				activeProjection: null,
+				pendingApprovals: state.pendingApprovals.filter((approval) => approval.generationId !== active.generationId),
+				tools: stopGenerationTools(retained === null ? state.tools : projectedTools(retained), active.generationId, active.responseMessageId, "Tool execution was interrupted.")
+			};
+			return {
+				...next,
+				status: waitingStatus(next)
+			};
+		}
+		case "ai.tool.called": {
+			const payload = event.payload;
+			const projection = state.activeProjection;
+			if (projection?.generationId !== payload.generationId) return state;
+			const activeProjection = {
+				...projection,
+				toolEvents: [...projection.toolEvents, {
+					index: event.index,
+					type: "ai.tool.called",
+					payload
+				}]
+			};
+			return {
+				...state,
+				activeProjection,
+				tools: projectedTools(activeProjection)
+			};
+		}
+		case "ai.tool.result": {
+			const payload = event.payload;
+			const projection = state.activeProjection;
+			if (projection?.generationId !== payload.generationId) return state;
+			const activeProjection = {
+				...projection,
+				toolEvents: [...projection.toolEvents, {
+					index: event.index,
+					type: "ai.tool.result",
+					payload
+				}]
+			};
+			return {
+				...state,
+				activeProjection,
+				tools: projectedTools(activeProjection)
+			};
+		}
+		case "ai.approval.requested": {
+			const payload = event.payload;
+			return {
+				...state,
+				pendingApprovals: [...state.pendingApprovals.filter((approval) => approval.approvalId !== payload.approvalId), payload]
+			};
+		}
+		case "ai.approval.responded": {
+			const payload = event.payload;
+			const next = {
+				...state,
+				messages: answerApproval(state.messages, payload),
+				pendingApprovals: state.pendingApprovals.filter((approval) => approval.approvalId !== payload.approvalId)
+			};
+			return {
+				...next,
+				status: waitingStatus(next)
+			};
+		}
+		case "ai.input.requested": {
+			const payload = event.payload;
+			return {
+				...state,
+				pendingInputs: [...state.pendingInputs.filter((input) => input.inputId !== payload.inputId), payload],
+				status: "waiting"
+			};
+		}
+		case "ai.input.responded": {
+			const payload = event.payload;
+			const next = {
+				...state,
+				pendingInputs: state.pendingInputs.filter((input) => input.inputId !== payload.inputId)
+			};
+			return {
+				...next,
+				status: waitingStatus(next)
+			};
+		}
+		case "ai.compaction.requested": {
+			const payload = event.payload;
+			return {
+				...state,
+				compaction: {
+					status: "running",
+					...payload
+				}
+			};
+		}
+		case "ai.compaction.completed": {
+			const payload = event.payload;
+			return {
+				...state,
+				compaction: {
+					status: "completed",
+					...payload
+				}
+			};
+		}
+		default: return state;
+	}
+}
+/** Derive AI SDK UI messages directly from an A2 event history. */
+function deriveUIMessages(history) {
+	let state = initialState();
+	for (const event of history) state = reduceAIState(state, event);
+	return state.messages;
+}
+/** Build the standard AI state projection for any contract containing the protocol. */
+function createReducer(options) {
+	return options.contract.reducer({
+		name: options.name ?? "a2.ai.state.v2",
+		initialState: initialState()
+	}).fold((state, event) => reduceAIState(state, event));
+}
+const generationRequest = (options) => ({
+	type: "ai.generation.requested",
+	id: options.id,
+	payload: {
+		messageId: options.messageId,
+		reason: options.reason,
+		...options.responseMessageId === void 0 ? {} : { responseMessageId: options.responseMessageId }
+	}
+});
+const seedMessage = (message) => [{
+	type: "ai.message.created",
+	id: `ai.message:${message.id}`,
+	payload: { message }
+}];
+/** Pure append inputs for the built-in AI protocol. */
+const inputs = {
+	message(message) {
+		const messageInputs = seedMessage(message);
+		if (message.role !== "user") return messageInputs;
+		return [...messageInputs, generationRequest({
+			id: `ai.generate:message:${message.id}`,
+			messageId: message.id,
+			reason: "message"
+		})];
+	},
+	seed: seedMessage,
+	approval(response) {
+		return [{
+			type: "ai.approval.responded",
+			id: `ai.approval:${response.approvalId}:response`,
+			payload: response
+		}, generationRequest({
+			id: `ai.generate:approval:${response.approvalId}`,
+			messageId: response.messageId,
+			reason: "approval"
+		})];
+	},
+	input(response) {
+		return [{
+			type: "ai.input.responded",
+			id: `ai.input:${response.inputId}:response`,
+			payload: response
+		}, generationRequest({
+			id: `ai.generate:input:${response.inputId}`,
+			messageId: response.messageId,
+			reason: "input"
+		})];
+	},
+	requestInput(request) {
+		return [{
+			type: "ai.input.requested",
+			id: `ai.input:${request.inputId}:request`,
+			payload: request
+		}];
+	},
+	retry(retryOptions) {
+		return [generationRequest({
+			id: `ai.generate:retry:${retryOptions.retryId}`,
+			messageId: retryOptions.messageId,
+			responseMessageId: retryOptions.responseMessageId,
+			reason: "retry"
+		})];
+	},
+	interrupt(interruption) {
+		return [{
+			type: "ai.message.interrupted",
+			id: `ai.interrupt:${interruption.generationId ?? interruption.messageId}`,
+			payload: interruption
+		}];
+	}
+};
+/**
+* Define an agent: built-in AI protocol + application events and one state
+* reducer. The result is isomorphic.
+*/
+function agent(options) {
+	const builtIns = createEvents(options.messageSchema === void 0 ? void 0 : { messageSchema: options.messageSchema });
+	const extensions = options.events ?? {};
+	for (const key of Object.keys(extensions)) if (Object.hasOwn(builtIns, key)) throw new TypeError(`agent event '${key}' conflicts with a built-in event`);
+	const agentContract = contract({
+		name: options.name,
+		events: {
+			...builtIns,
+			...extensions
+		}
+	});
+	return {
+		contract: agentContract,
+		reducer: agentContract.reducer({
+			name: options.reducerName ?? "a2.ai.state.v2",
+			initialState: initialState()
+		}).fold((state, event) => reduceAIState(state, event))
+	};
+}
+//#endregion
+export { agent, createEvents, createReducer, deriveUIMessages, events, inputs, reduceAIState };