@blocknote/xl-ai 0.47.3 → 0.48.1

package/dist/server-JIYg7ELG.js

@@ -0,0 +1,1630 @@
+import { UnreachableCaseError as e, defaultProps as t, getBlock as n, getNodeById as r, getPmSchema as i, insertBlocks as a, isLinkInlineContent as o, isStyledTextInlineContent as s, removeAndInsertBlocks as c, trackPosition as l, updateBlockTr as u } from "@blocknote/core";
+import { applySuggestions as d } from "@handlewithcare/prosemirror-suggest-changes";
+import { Slice as f } from "prosemirror-model";
+import { TextSelection as p } from "prosemirror-state";
+import m from "lodash.merge";
+import { asSchema as h, convertToModelMessages as g, isToolUIPart as _, jsonSchema as v, parsePartialJson as y, streamText as ee, tool as te } from "ai";
+import ne from "lodash.isequal";
+import { getErrorMessage as b } from "@ai-sdk/provider-utils";
+import { Mapping as re, ReplaceAroundStep as ie, ReplaceStep as x, Transform as S } from "prosemirror-transform";
+import { ChangeSet as C, simplifyChanges as ae } from "prosemirror-changeset";
+//#region src/util/emptyBlock.ts
+function w(e) {
+	return (e.type === "paragraph" || !e.type) && !e.content || Array.isArray(e.content) && e.content.length === 0;
+}
+//#endregion
+//#region src/util/trimArray.ts
+function oe(e, t, n = !0, r = !0) {
+	let i = 0, a = e.length;
+	if (n) for (; i < a && t(e[i]);) i++;
+	if (r) for (; a > i && t(e[a - 1]);) a--;
+	return e.slice(i, a);
+}
+//#endregion
+//#region src/api/promptHelpers/trimEmptyBlocks.ts
+function T(e, t) {
+	return oe(e, (e) => w(e) && t?.cursorBlockId !== e.id, t?.trimStart ?? !1, t?.trimEnd ?? !0);
+}
+//#endregion
+//#region src/api/aiRequest/builder.ts
+async function se(e) {
+	let { useSelection: t, deleteEmptyCursorBlock: n, streamToolsProvider: r, documentStateBuilder: i, onStart: a } = {
+		useSelection: e.useSelection ?? !1,
+		deleteEmptyCursorBlock: e.deleteEmptyCursorBlock ?? !0,
+		streamToolsProvider: e.streamToolsProvider ?? $.html.getStreamToolsProvider(),
+		documentStateBuilder: e.documentStateBuilder ?? $.html.defaultDocumentStateBuilder,
+		onStart: e.onStart ?? (() => {})
+	}, o = t ? void 0 : e.editor.getTextCursorPosition().block, s = o && n && w(o) && T(e.editor.document).length > 0 ? o.id : void 0, c = t ? e.editor.getSelectionCutBlocks(!0) : void 0, l = r.getStreamTools(e.editor, c ? {
+		from: c._meta.startPos,
+		to: c._meta.endPos
+	} : void 0, e.onBlockUpdated), u = {
+		editor: e.editor,
+		selectedBlocks: c?.blocks,
+		streamTools: l,
+		emptyCursorBlockToDelete: s,
+		onStart: a
+	};
+	return {
+		...u,
+		documentState: await i(u)
+	};
+}
+//#endregion
+//#region src/streamTool/jsonSchema.ts
+function ce(e) {
+	let { properties: t, required: n, $defs: r, ...i } = e.inputSchema;
+	return {
+		schema: {
+			type: "object",
+			description: e.description,
+			properties: {
+				type: {
+					type: "string",
+					enum: [e.name]
+				},
+				...t
+			},
+			required: ["type", ...n ?? []],
+			additionalProperties: !1,
+			...i
+		},
+		$defs: r
+	};
+}
+function E(e) {
+	let t = e.map((e) => ce(e)), n = {};
+	for (let e of t) for (let t in e.$defs) {
+		if (n[t] && !ne(n[t], e.$defs[t])) throw Error(`Duplicate, but different definition for ${t}`);
+		n[t] = e.$defs[t];
+	}
+	return {
+		type: "object",
+		properties: { operations: {
+			type: "array",
+			items: { anyOf: t.map((e) => e.schema) }
+		} },
+		additionalProperties: !1,
+		required: ["operations"],
+		$defs: Object.keys(n).length > 0 ? n : void 0
+	};
+}
+function le(e) {
+	return { applyDocumentOperations: {
+		inputSchema: v(E(e)),
+		outputSchema: v({ type: "object" })
+	} };
+}
+//#endregion
+//#region src/streamTool/ChunkExecutionError.ts
+var D = class extends Error {
+	aborted;
+	constructor(e, t, n) {
+		super(e, n), this.chunk = t, this.name = "ChunkExecutionError", this.aborted = n?.aborted ?? !1;
+	}
+}, ue = class {
+	stream;
+	constructor(e, t) {
+		this.streamTools = e, this.abortSignal = t, this.stream = this.createStream();
+	}
+	createStream() {
+		let e, t = new TransformStream({
+			transform: async (t, n) => {
+				let r = typeof t == "string" ? await de(t, e?.isPossiblyPartial ?? !1, this.streamTools) : t;
+				r && (e = r, n.enqueue(r));
+			},
+			flush: (t) => {
+				e?.isPossiblyPartial && t.error(/* @__PURE__ */ Error("stream ended with a partial operation"));
+			}
+		}), [n, r] = t.readable.pipeThrough(this.createExecutor()).tee(), i = n.pipeTo(new WritableStream());
+		return {
+			writable: t.writable,
+			readable: r,
+			finishPromise: i
+		};
+	}
+	createExecutor() {
+		let e = this.streamTools.map((e) => e.executor());
+		return new TransformStream({ transform: async (t, n) => {
+			let r = !1;
+			for (let i of e) try {
+				if (await i.execute(t, this.abortSignal)) {
+					n.enqueue({
+						status: "ok",
+						chunk: t
+					}), r = !0;
+					break;
+				}
+			} catch (e) {
+				n.error(new D(`Tool execution failed: ${b(e)}`, t, {
+					cause: e,
+					aborted: this.abortSignal?.aborted ?? !1
+				}));
+				return;
+			}
+			if (!r) {
+				let e = t.operation?.type || "unknown";
+				n.error(/* @__PURE__ */ Error(`No tool could handle operation of type: ${e}`));
+				return;
+			}
+		} });
+	}
+	get writable() {
+		return this.stream.writable;
+	}
+	get readable() {
+		return this.stream.readable;
+	}
+	async finish() {
+		await this.stream.finishPromise;
+	}
+	async executeOperationsArray(e) {
+		let t = this.writable.getWriter();
+		for await (let n of e) {
+			let e = await y(n);
+			if (e.state === "undefined-input" || e.state === "failed-parse" || !e) return;
+			await t.write(n);
+		}
+		await t.close(), await this.finish();
+	}
+	async execute(e) {
+		let t = this.writable.getWriter();
+		for await (let n of e) await t.write(n);
+		await t.close(), await this.finish();
+	}
+	async executeOne(e) {
+		await this.execute((async function* () {
+			yield {
+				operation: e,
+				isUpdateToPreviousOperation: !1,
+				isPossiblyPartial: !1,
+				metadata: {}
+			};
+		})());
+	}
+};
+async function de(e, t, n) {
+	let r = await y(e);
+	if (r.state === "undefined-input" || r.state === "failed-parse" || !r) return;
+	let i = n.find((e) => e.name === r.value?.type), a = i && i.validate(r.value);
+	if (a?.ok) return {
+		operation: a.value,
+		isPossiblyPartial: r.state === "repaired-parse",
+		isUpdateToPreviousOperation: t,
+		metadata: void 0
+	};
+}
+//#endregion
+//#region src/streamTool/vercelAiSdk/util/injectDocumentStateMessages.ts
+function fe(e) {
+	return e.flatMap((e) => {
+		if (e.role === "user" && e.metadata?.documentState) {
+			let t = e.metadata.documentState;
+			return [{
+				role: "assistant",
+				id: "assistant-document-state-" + e.id,
+				parts: [...t.selection ? [
+					{
+						type: "text",
+						text: "This is the latest state of the selection (ignore previous selections, you MUST issue operations against this latest version of the selection):"
+					},
+					{
+						type: "text",
+						text: JSON.stringify(t.selectedBlocks)
+					},
+					{
+						type: "text",
+						text: "This is the latest state of the entire document (INCLUDING the selected text), \nyou can use this to find the selected text to understand the context (but you MUST NOT issue operations against this document, you MUST issue operations against the selection):"
+					},
+					{
+						type: "text",
+						text: JSON.stringify(t.blocks)
+					}
+				] : [{
+					type: "text",
+					text: "There is no active selection. This is the latest state of the document (ignore previous documents, you MUST issue operations against this latest version of the document). \nThe cursor is BETWEEN two blocks as indicated by cursor: true.\n" + (t.isEmptyDocument ? "Because the document is empty, YOU MUST first update the empty block before adding new blocks." : "Prefer updating existing blocks over removing and adding (but this also depends on the user's question).")
+				}, {
+					type: "text",
+					text: JSON.stringify(t.blocks)
+				}]]
+			}, e];
+		}
+		return [e];
+	});
+}
+//#endregion
+//#region src/streamTool/vercelAiSdk/util/toolDefinitions.ts
+async function pe(e) {
+	let t = await Promise.all(Object.entries(e).map(async ([e, t]) => [e, {
+		description: t.description,
+		inputSchema: await h(t.inputSchema).jsonSchema,
+		outputSchema: await h(t.outputSchema).jsonSchema
+	}]));
+	return Object.fromEntries(t);
+}
+function me(e) {
+	return Object.fromEntries(Object.entries(e).map(([e, t]) => [e, te({
+		...t,
+		inputSchema: v(t.inputSchema),
+		outputSchema: v(t.outputSchema)
+	})]));
+}
+//#endregion
+//#region src/streamTool/vercelAiSdk/clientside/ClientSideTransport.ts
+var O = {
+	"mistral.chat": { mode: "auto" },
+	"google.generative-ai": { mode: "auto" },
+	"groq.chat": { providerOptions: { groq: { structuredOutputs: !1 } } }
+};
+function he(e) {
+	return O[e.provider] || {};
+}
+var ge = class {
+	constructor(e) {
+		this.opts = e;
+	}
+	async streamText(e, t) {
+		let { model: n, _additionalOptions: r } = this.opts;
+		return ee({
+			model: n,
+			system: this.opts.systemPrompt,
+			messages: await g(fe(e)),
+			tools: t,
+			toolChoice: "required",
+			...r ?? {}
+		}).toUIMessageStream();
+	}
+	async sendMessages({ messages: e, body: t }) {
+		let n = this.opts.stream ?? !0, r = t.toolDefinitions, i = await me(r);
+		if (n) return await this.streamText(e, i);
+		throw Error("Not implemented (generateText)");
+	}
+	reconnectToStream() {
+		throw Error("Not implemented");
+	}
+};
+//#endregion
+//#region src/streamTool/vercelAiSdk/util/appendableStream.ts
+function _e() {
+	let e, t = Promise.resolve(), n = !1, r, i = new Promise((e, t) => {
+		r = t;
+	});
+	i.catch(() => {});
+	let a = new ReadableStream({
+		start(t) {
+			e = t;
+		},
+		cancel(t) {
+			n = !0, e.error(t), r?.(t);
+		}
+	});
+	async function o(r) {
+		if (n) throw Error("Appendable stream canceled, can't append");
+		let a = r.getReader();
+		return t = t.then(async () => {
+			for (;;) try {
+				let { done: t, value: r } = await Promise.race([a.read(), i]);
+				if (t || n) break;
+				e.enqueue(r);
+			} catch (t) {
+				n = !0, e.error(t);
+				break;
+			}
+		}), t;
+	}
+	async function s() {
+		await t, n || e.close();
+	}
+	return {
+		output: a,
+		append: o,
+		finalize: s
+	};
+}
+//#endregion
+//#region src/util/stream.ts
+function ve(e) {
+	return new ReadableStream({ async start(t) {
+		try {
+			for await (let n of e) t.enqueue(n);
+			t.close();
+		} catch (e) {
+			t.error(e);
+		}
+	} });
+}
+function k(e) {
+	if (e.locked) throw Error("Stream (source) is already locked and cannot be iterated.");
+	let t = e.pipeThrough(new TransformStream());
+	return t[Symbol.asyncIterator] = () => {
+		if (t.locked) throw Error("Stream is already locked and cannot be iterated again.");
+		let e = t.getReader();
+		return { async next() {
+			let { done: t, value: n } = await e.read();
+			return t ? {
+				done: !0,
+				value: void 0
+			} : {
+				done: !1,
+				value: n
+			};
+		} };
+	}, t;
+}
+function ye(e) {
+	return k(ve(e));
+}
+//#endregion
+//#region src/streamTool/filterNewOrUpdatedOperations.ts
+async function* be(e, t) {
+	let n = 0, r = !0, i;
+	for await (let a of e) if (a.operations?.length) {
+		for (let e = n; e < a.operations.length; e++) {
+			let o = a.operations[e];
+			i = o, yield {
+				partialOperation: o,
+				isUpdateToPreviousOperation: e === n && !r,
+				isPossiblyPartial: e === a.operations.length - 1,
+				metadata: t
+			}, r = !1;
+		}
+		n = a.operations.length - 1;
+	}
+	if (!i) throw Error("No operations seen");
+	yield {
+		partialOperation: i,
+		isUpdateToPreviousOperation: !0,
+		isPossiblyPartial: !1,
+		metadata: t
+	};
+}
+//#endregion
+//#region src/streamTool/filterValidOperations.ts
+async function* xe(e, t) {
+	let n = !1;
+	for await (let r of e) {
+		let e = r.operation;
+		e.ok ? (yield {
+			operation: e.value,
+			isUpdateToPreviousOperation: n ? !1 : r.isUpdateToPreviousOperation,
+			isPossiblyPartial: r.isPossiblyPartial,
+			metadata: r.metadata
+		}, n = !1) : (n ||= !r.isUpdateToPreviousOperation, t?.({
+			...r,
+			operation: e
+		}));
+	}
+}
+//#endregion
+//#region src/streamTool/toValidatedOperations.ts
+async function* Se(e, t) {
+	for await (let n of e) {
+		if (!n.partialOperation.type) {
+			yield {
+				operation: {
+					ok: !1,
+					error: "The `type` property of an operation is required."
+				},
+				isUpdateToPreviousOperation: n.isUpdateToPreviousOperation,
+				isPossiblyPartial: n.isPossiblyPartial,
+				metadata: n.metadata
+			};
+			continue;
+		}
+		let e = t.find((e) => e.name === n.partialOperation.type);
+		if (!e) {
+			yield {
+				operation: {
+					ok: !1,
+					error: `No matching function for ${n.partialOperation.type}`
+				},
+				isUpdateToPreviousOperation: n.isUpdateToPreviousOperation,
+				isPossiblyPartial: n.isPossiblyPartial,
+				metadata: n.metadata
+			};
+			continue;
+		}
+		yield {
+			operation: e.validate(n.partialOperation),
+			isUpdateToPreviousOperation: n.isUpdateToPreviousOperation,
+			isPossiblyPartial: n.isPossiblyPartial,
+			metadata: n.metadata
+		};
+	}
+}
+//#endregion
+//#region src/streamTool/preprocess.ts
+async function* Ce(e, t) {
+	yield* xe(Se(e, t), (e) => {
+		if (!e.isPossiblyPartial) throw new D(`Invalid operation. ${b(e.operation.error)}`, e, { cause: e.operation.error });
+	});
+}
+//#endregion
+//#region src/streamTool/vercelAiSdk/util/UIMessageStreamToOperationsResult.ts
+function A(e, t, n) {
+	return ye(Ce(be(k(e), n), t));
+}
+//#endregion
+//#region src/streamTool/vercelAiSdk/util/chatHandlers.ts
+async function j(e, t, n, r) {
+	let i = new ue(e, r), a = _e(), o = a.output.pipeTo(i.writable), s = /* @__PURE__ */ new Map(), c = !0, l = t["~registerMessagesCallback"](() => {
+		we(t, (t) => {
+			if (!s.has(t.toolCallId)) {
+				let r = Te(e, t.toolName, t.toolCallId);
+				a.append(r.operationsStream), s.set(t.toolCallId, r), c && (c = !1, n?.());
+			}
+			return s.get(t.toolCallId);
+		});
+	});
+	await new Promise((e) => {
+		let n = t["~registerStatusCallback"](() => {
+			(t.status === "ready" || t.status === "error") && (l(), n(), t.status !== "error" && r(), e());
+		}), r = t["~registerErrorCallback"](() => {
+			if (t.error) {
+				r();
+				for (let e of s.values()) e.complete || e.writer.abort(t.error);
+			}
+		});
+	}), await a.finalize();
+	let u = await Promise.allSettled([i.finish(), o]), d = u[0];
+	if (u[1].status === "rejected" && (u[0].status !== "rejected" || u[0].reason !== u[1].reason)) throw Error("unexpected, pipeToPromise rejected but executor.finish() doesn't have same error!?");
+	let f;
+	if (d.status === "rejected") {
+		if (d.reason instanceof D) f = d.reason;
+		else if (!t.error) throw Error("Unexpected: no ChunkExecutionError but also no chat.error (network error?)");
+	}
+	let p = !1, m = Array.from(s.values().filter((e) => e.complete));
+	return m.forEach((e, n) => {
+		let r = e.toolCallId === f?.chunk.metadata.toolCallId;
+		r && (p = !0), p ? t.addToolOutput({
+			tool: m[n].toolName,
+			toolCallId: m[n].toolCallId,
+			state: "output-error",
+			errorText: JSON.stringify(r ? {
+				status: "error",
+				error: b(f)
+			} : { status: "not-executed-previous-tool-errored" })
+		}) : t.addToolOutput({
+			state: "output-available",
+			tool: m[n].toolName,
+			toolCallId: m[n].toolCallId,
+			output: { status: "ok" }
+		});
+	}), f ? {
+		ok: !1,
+		error: f
+	} : {
+		ok: !0,
+		value: void 0
+	};
+}
+function we(e, t) {
+	for (let n of e.lastMessage?.parts ?? []) {
+		if (!_(n) || n.type.replace("tool-", "") !== "applyDocumentOperations") continue;
+		let e = n.toolCallId;
+		Ee(n, t({
+			toolName: n.type.replace("tool-", ""),
+			toolCallId: e
+		}));
+	}
+}
+function Te(e, t, n) {
+	let r = new TransformStream(), i = A(r.readable, e, { toolCallId: n });
+	return {
+		writer: r.writable.getWriter(),
+		complete: !1,
+		operationsStream: i,
+		toolName: t,
+		toolCallId: n
+	};
+}
+function Ee(e, t) {
+	if (e.state === "input-streaming") {
+		let n = e.input;
+		n !== void 0 && t.writer.write(n);
+	} else if (e.state === "input-available") {
+		let n = e.input;
+		if (n === void 0) throw Error("input is undefined");
+		t.complete || (t.complete = !0, t.writer.write(n), t.writer.close());
+	}
+}
+//#endregion
+//#region src/api/aiRequest/sendMessageWithAIRequest.ts
+async function De(e, t, n, r, i) {
+	let a = n ?? e.lastMessage;
+	if (!a) throw Error("No message to send");
+	a.metadata = m(a.metadata, { documentState: t.documentState });
+	let o = j(t.streamTools, e, t.onStart, i);
+	return r = m(r, {
+		metadata: { source: "blocknote-ai" },
+		body: { toolDefinitions: await pe(le(t.streamTools)) }
+	}), await e.sendMessage(n, r), await o;
+}
+//#endregion
+//#region src/api/promptHelpers/addCursorPosition.ts
+function M(e, t) {
+	let n = e.getTextCursorPosition(), r = [];
+	for (let e of t) {
+		let t = e.id === n.block.id;
+		r.push({
+			id: e.id,
+			block: e.block
+		}), t && r.push({ cursor: !0 });
+	}
+	return r;
+}
+//#endregion
+//#region src/api/promptHelpers/convertBlocks.ts
+async function N(e, t) {
+	return await Promise.all(e.map(async (e) => ({
+		id: e.id,
+		block: await t(e)
+	})));
+}
+//#endregion
+//#region src/api/promptHelpers/flattenBlocks.ts
+function P(e) {
+	return e.flatMap((e) => [{
+		...e,
+		children: []
+	}, ...P(e.children)]);
+}
+//#endregion
+//#region src/api/promptHelpers/suffixIds.ts
+function F(e) {
+	return e.map((e) => typeof e == "object" && e && "id" in e ? {
+		...e,
+		id: `${e.id}$`
+	} : e);
+}
+//#endregion
+//#region src/api/formats/DocumentStateBuilder.ts
+function I(e) {
+	return async (t) => t.selectedBlocks ? await ke(t.editor, e, { selectedBlocks: t.selectedBlocks }) : await Oe(t.editor, e, { excludeBlockIds: t.emptyCursorBlockToDelete ? [t.emptyCursorBlockToDelete] : void 0 });
+}
+async function Oe(e, t, n) {
+	let r = T(e.document).length === 0, i = e.getTextCursorPosition().block.id;
+	return {
+		selection: !1,
+		blocks: F(M(e, await N(P(T(e.document, { cursorBlockId: i })), async (n) => t(e, n))).filter((e) => "cursor" in e || !(n.excludeBlockIds || []).includes(e.id))),
+		isEmptyDocument: r
+	};
+}
+async function ke(e, t, n) {
+	return {
+		isEmptyDocument: T(e.document).length === 0,
+		selection: !0,
+		selectedBlocks: F(await N(P(n.selectedBlocks), async (n) => t(e, n))),
+		blocks: (await N(P(e.document), async (n) => t(e, n))).map(({ block: e }) => ({ block: e }))
+	};
+}
+//#endregion
+//#region src/prosemirror/fragmentUtil.ts
+function Ae(e) {
+	let t, n = !1;
+	return e.descendants((e, r) => n ? !1 : (e.isText && (n = !0, t = r), !0)), t;
+}
+//#endregion
+//#region src/prosemirror/agent.ts
+function L(e) {
+	let t = i(e), { modification: n } = t.marks, r = [], a = new S(e.before);
+	for (let i = 0; i < e.steps.length; i++) {
+		let o = e.steps[i], s = new re(e.mapping.maps.slice(0, i)).invert();
+		if (o.structure) {
+			if (o instanceof x) {
+				if (o.to !== o.from + 1 || o.slice.openStart !== 0 || o.slice.openEnd !== 1 || o.slice.content.size !== 2) throw Error("Structure change is not in expected format (ReplaceStep)");
+			} else if (o instanceof ie) {
+				if (o.insert !== 1 || o.slice.size !== 2 || o.gapTo !== o.to - 1 || o.gapFrom !== o.from + 1) throw Error("Structure change is not in expected format (ReplaceAroundStep)");
+			} else throw Error("Step is not a ReplaceStep or ReplaceAroundStep");
+			let e = s.map(o.from), t = o.slice.content.firstChild, i = a.doc.resolve(a.mapping.map(e)).nodeAfter, c = t.marks || [];
+			t.type !== i.type && (c = n.create({
+				type: "nodeType",
+				previousValue: i.type.name,
+				newValue: t.type.name
+			}).addToSet(c));
+			let l = new Set([...Object.keys(t.attrs), ...Object.keys(i.attrs)]);
+			for (let e of l) t.attrs[e] !== i.attrs[e] && (c = n.create({
+				type: "attr",
+				attrName: e,
+				previousValue: i.attrs[e],
+				newValue: t.attrs[e]
+			}).addToSet(c));
+			let u = a.steps.length;
+			a.setNodeMarkup(a.mapping.map(e), t.type, t.attrs, c), r.push({
+				prosemirrorSteps: a.steps.slice(u),
+				selection: void 0,
+				type: "replace"
+			});
+			continue;
+		}
+		if (!(o instanceof x)) throw Error("Step is not a ReplaceStep");
+		let c = s.map(o.from), l = s.map(o.to);
+		if (o.slice.openStart > 0 || o.slice.openEnd > 0) throw Error("Slice has openStart or openEnd > 0, but structure=false");
+		r.push({
+			prosemirrorSteps: [],
+			selection: {
+				anchor: a.mapping.map(c),
+				head: a.mapping.map(l)
+			},
+			type: "select"
+		});
+		let u = o.slice.content.textBetween(0, o.slice.size), d = u === a.doc.textBetween(a.mapping.map(c), a.mapping.map(l)), m;
+		if (d) m = o.slice.content.size;
+		else if (u.length === 0) m = o.slice.content.size;
+		else {
+			let e = Ae(o.slice.content);
+			if (e === void 0) throw Error("unexpected: no first character found");
+			m = e + 1;
+		}
+		let h = a.mapping.map(l), g = a.mapping.map(l), _ = !0;
+		for (let e = m; e <= o.slice.content.size; e++) {
+			let n = _ && c !== l, i = a.steps.length;
+			if (n) {
+				let e = a.doc.resolve(a.mapping.map(c));
+				e.nodeAfter?.isBlock && a.addNodeMark(e.pos, t.mark("deletion", {})), a.addMark(e.pos, h, t.mark("deletion", {})), h = a.mapping.map(l);
+			}
+			let s = new f(o.slice.content.cut(0, e), 0, 0);
+			a.replace(g, h, s).addMark(g, g + s.content.size, t.mark("insertion", {})), a.doc.nodesBetween(g, g + s.content.size, (e, n) => n < g || n > g + s.content.size ? !0 : (e.isBlock && a.addNodeMark(n, t.mark("insertion", {})), !1)), h = a.mapping.slice(i).map(h);
+			let u = p.near(a.doc.resolve(g + s.content.size), -1);
+			r.push({
+				prosemirrorSteps: a.steps.slice(i),
+				selection: {
+					anchor: u.from,
+					head: u.from
+				},
+				type: n ? "replace" : "insert"
+			}), _ = !1;
+		}
+	}
+	return r;
+}
+async function R(t) {
+	let n = Math.random() * .3 + .85;
+	if (t.type === "select") await new Promise((e) => setTimeout(e, 100 * n));
+	else if (t.type === "insert") await new Promise((e) => setTimeout(e, 10 * n));
+	else if (t.type === "replace") await new Promise((e) => setTimeout(e, 200 * n));
+	else throw new e(t.type);
+}
+function z(e, t) {
+	e.setMeta("addToHistory", !1), t.selection && e.setMeta("aiAgent", { selection: {
+		anchor: t.selection.anchor,
+		head: t.selection.head
+	} });
+	for (let n of t.prosemirrorSteps) if (e.maybeStep(n).failed) throw Error("failed to apply step");
+	return e;
+}
+//#endregion
+//#region src/prosemirror/changeset.ts
+function je(e, t, n) {
+	let r = new S(t);
+	for (let t of e) {
+		let e = new x(r.mapping.map(t.fromA), r.mapping.map(t.toA), n.slice(t.fromB, t.toB));
+		r.step(e);
+	}
+	let i = r.mapping.invert(), a = r.doc.content.findDiffStart(n.content);
+	for (; a !== null;) {
+		let t = n.resolve(a).nodeAfter, o = r.doc.resolve(a).nodeAfter;
+		if (!t || !o) throw Error("diffNode not found");
+		let s = !t.isLeaf && t.content.eq(o.content), c = s ? 1 : Math.min(t.nodeSize, o.nodeSize), l = a + c, u = i.map(a), d = i.map(l), f = e.length;
+		for (let t = 0; t < e.length; t++) if (e[t].fromA >= d) {
+			f = t;
+			break;
+		}
+		e.splice(f, 0, {
+			fromA: u,
+			toA: d,
+			fromB: a,
+			toB: l,
+			deleted: [],
+			inserted: [],
+			type: s ? "node-type-or-attr-update" : "mark-update"
+		}), r.step(new x(a, l, n.slice(a, l), s));
+		let p = r.doc.content.findDiffStart(n.content);
+		if (p === a) throw Error("diffStart not moving");
+		a = p;
+	}
+	return e;
+}
+var B = (e, t) => {
+	let n = /* @__PURE__ */ new Set(), r = /* @__PURE__ */ new Set();
+	e.descendants((e) => {
+		e.type.name === "tableCell" && n.add(JSON.stringify(e.toJSON()));
+	}), t.descendants((e) => {
+		e.type.name === "tableCell" && r.add(JSON.stringify(e.toJSON()));
+	});
+	let i = new Set([...n].filter((e) => r.has(e)));
+	return {
+		encodeCharacter: (e) => e,
+		encodeNodeStart: (e) => {
+			if (e.type.name === "tableCell") {
+				let t = JSON.stringify(e.toJSON());
+				return i.has(t) ? t : e.type.name;
+			}
+			return e.type.name;
+		},
+		encodeNodeEnd: (e) => {
+			if (e.type.name === "tableCell") {
+				let t = JSON.stringify(e.toJSON());
+				return i.has(t) ? t : -1;
+			}
+			return -1;
+		},
+		compareTokens: (e, t) => e === t
+	};
+};
+function V(e, t, n = !1, i, a) {
+	let o = r(e.id, t), s = new S(t);
+	u(s, o.posBeforeNode, e.block, i, a);
+	let c = s.doc, l = C.create(t, void 0, B(t, c));
+	if (l = l.addSteps(c, s.mapping.maps, 0), n && l.changes.length > 0) {
+		let e = l.changes[l.changes.length - 1], n = e.toA - e.fromA, r = e.toB - e.fromB;
+		if (n > r) {
+			let n = t.slice(e.fromA + r, e.toA);
+			s.step(new x(e.toB, e.toB, n)), c = s.doc, l = C.create(l.startDoc, void 0, B(l.startDoc, c)), l = l.addSteps(c, s.mapping.maps, 0);
+		}
+	}
+	let d = [], f = ae(l.changes, c);
+	for (let e = 0; e < f.length; e++) {
+		let t = f[e], n = c.slice(t.fromB, t.toB);
+		if (n.openEnd === 1 && n.openStart === 0 && (t.type = "node-type-or-attr-update", n.size > 2)) {
+			let n = {
+				fromA: t.fromA,
+				toA: t.fromA + 1,
+				fromB: t.fromB,
+				toB: t.fromB + 1,
+				deleted: [],
+				inserted: [],
+				type: "node-type-or-attr-update"
+			}, r = {
+				fromA: t.fromA + 1,
+				toA: t.toA,
+				fromB: t.fromB + 1,
+				toB: t.toB,
+				deleted: [],
+				inserted: []
+			};
+			f.splice(e, 1, n, r), e++;
+		}
+	}
+	je(f, t, c);
+	for (let e = 0; e < f.length; e++) {
+		let t = f[e], r = c.slice(t.fromB, t.toB);
+		if (r.openEnd > 0 && r.size > 1) throw Error("unexpected, openEnd > 0 and size > 1, this should have been split into two steps");
+		e === f.length - 1 && n && t.type === "mark-update" || d.push(new x(t.fromA, t.toA, r, t.type === "node-type-or-attr-update"));
+	}
+	return d;
+}
+//#endregion
+//#region src/streamTool/streamTool.ts
+function H(e) {
+	return e;
+}
+//#endregion
+//#region src/util/AbortError.ts
+var U = class extends Error {
+	constructor(e, t) {
+		super(e, t), this.name = "AbortError";
+	}
+};
+//#endregion
+//#region src/api/formats/base-tools/util/validateBlockArray.ts
+function Me(e, t) {
+	if (!e || !Array.isArray(e) || e.length === 0) return {
+		ok: !1,
+		error: "blocks is required"
+	};
+	let n = [];
+	for (let r of e) {
+		let e = t(r);
+		if (!e.ok) return {
+			ok: !1,
+			error: `Invalid block: ${e.error}`
+		};
+		n.push(e.value);
+	}
+	return {
+		ok: !0,
+		value: n
+	};
+}
+//#endregion
+//#region src/api/formats/base-tools/createAddBlocksTool.ts
+function W(e) {
+	return (t, n) => {
+		let r = typeof e.schema == "function" ? e.schema(t) : e.schema;
+		return H({
+			name: "add",
+			description: e.description,
+			inputSchema: {
+				type: "object",
+				properties: {
+					referenceId: {
+						type: "string",
+						description: "MUST be an id of a block in the document"
+					},
+					position: {
+						type: "string",
+						enum: ["before", "after"],
+						description: "`after` to add blocks AFTER (below) the block with `referenceId`, `before` to add the block BEFORE (above)"
+					},
+					blocks: {
+						items: r.block,
+						type: "array"
+					}
+				},
+				required: [
+					"referenceId",
+					"position",
+					"blocks"
+				],
+				$defs: r.$defs
+			},
+			validate: (r) => {
+				if (r.type !== "add") return {
+					ok: !1,
+					error: "invalid operation type"
+				};
+				if (r.position !== "before" && r.position !== "after") return {
+					ok: !1,
+					error: "invalid position"
+				};
+				if (!r.referenceId || !r.blocks) return {
+					ok: !1,
+					error: "referenceId and blocks are required"
+				};
+				let i = r.referenceId;
+				if (n.idsSuffixed) {
+					if (!i?.endsWith("$")) return {
+						ok: !1,
+						error: "referenceId must end with $"
+					};
+					i = i.slice(0, -1);
+				}
+				if (!t.getBlock(i)) return {
+					ok: !1,
+					error: "referenceId not found"
+				};
+				let a = Me(r.blocks, (n) => e.validateBlock(n, t));
+				return a.ok ? {
+					ok: !0,
+					value: {
+						type: r.type,
+						referenceId: i,
+						position: r.position,
+						blocks: a.value
+					}
+				} : a;
+			},
+			executor: () => {
+				let r = [], i = {};
+				return { execute: async (o, s) => {
+					if (o.isUpdateToPreviousOperation || (r = []), o.operation.type !== "add") return !1;
+					let c = o.operation, l = await e.toJSONToolCall(t, {
+						...o,
+						operation: c
+					});
+					if (!l || o.isPossiblyPartial && w(l.blocks[l.blocks.length - 1])) return !0;
+					for (let o = 0; o < l.blocks.length; o++) {
+						let u = l.blocks[o], d = t.prosemirrorState.tr, f = [];
+						if (o < r.length) {
+							let n = await e.rebaseTool(r[o], t), i = V({
+								id: r[o],
+								block: u
+							}, n.doc, !1).map((e) => e.map(n.invertMap));
+							for (let e of i) d.step(e.map(d.mapping));
+							f = L(d), f = f.filter((e) => e.type !== "select");
+						} else {
+							let e = c.position === "after" ? i[c.referenceId] : void 0, t = a(d, [u], o > 0 ? r[o - 1] : e || c.referenceId, o > 0 ? "after" : c.position);
+							r.push(...t.map((e) => e.id)), f = L(d);
+						}
+						for (let e of f) {
+							if (s?.aborted) throw new U("Operation was aborted");
+							n.withDelays && await R(e), t.transact((t) => {
+								z(t, e);
+							}), n.onBlockUpdate?.(r[o]);
+						}
+					}
+					return o.isPossiblyPartial || c.position === "after" && (i[c.referenceId] = r[r.length - 1]), !0;
+				} };
+			}
+		});
+	};
+}
+//#endregion
+//#region src/api/formats/base-tools/createUpdateBlockTool.ts
+function G(e) {
+	return (t, n) => {
+		let r = typeof e.schema == "function" ? e.schema(t) : e.schema;
+		return H({
+			name: "update",
+			description: e.description,
+			inputSchema: {
+				type: "object",
+				properties: {
+					id: {
+						type: "string",
+						description: "id of block to update"
+					},
+					block: r.block
+				},
+				required: ["id", "block"],
+				$defs: r.$defs
+			},
+			validate: (r) => {
+				if (r.type !== "update") return {
+					ok: !1,
+					error: "invalid operation type"
+				};
+				if (!r.id) return {
+					ok: !1,
+					error: "id is required"
+				};
+				let i = r.id;
+				if (n.idsSuffixed) {
+					if (!i?.endsWith("$")) return {
+						ok: !1,
+						error: "id must end with $"
+					};
+					i = i.slice(0, -1);
+				}
+				if (!r.block) return {
+					ok: !1,
+					error: "block is required"
+				};
+				let a = t.getBlock(i);
+				if (!a) return {
+					ok: !1,
+					error: Error("Block not found (update)", { cause: { blockId: i } })
+				};
+				let o = e.validateBlock(r.block, t, a.type);
+				return o.ok ? {
+					ok: !0,
+					value: {
+						type: r.type,
+						id: i,
+						block: o.value
+					}
+				} : o;
+			},
+			executor: () => {
+				let r = 50, i = n.updateSelection ? {
+					from: l(t, n.updateSelection.from),
+					to: l(t, n.updateSelection.to)
+				} : void 0;
+				return { execute: async (a, o) => {
+					if (a.operation.type !== "update") return !1;
+					let s = a.operation;
+					if (a.isPossiblyPartial) {
+						let e = JSON.stringify(s.block).length;
+						if (e < r) return !0;
+						r = e + 50;
+					} else r = 50;
+					let c = await e.rebaseTool(s.id, t), l = i ? c.invertMap.invert().map(i.from()) : void 0, u = i ? c.invertMap.invert().map(i.to()) : void 0, d = await e.toJSONToolCall(t, {
+						...a,
+						operation: s
+					});
+					if (!d) return !0;
+					let f = V(d, c.doc, a.isPossiblyPartial, l, u);
+					if (f.length === 1 && a.isPossiblyPartial) return !0;
+					let p = f.map((e) => e.map(c.invertMap)), m = new S(t.prosemirrorState.doc);
+					for (let e of p) m.step(e.map(m.mapping));
+					let h = L(m);
+					for (let e of h) {
+						if (o?.aborted) throw new U("Operation was aborted");
+						n.withDelays && await R(e), t.transact((t) => {
+							z(t, e);
+						}), n.onBlockUpdate?.(s.id);
+					}
+					return !0;
+				} };
+			}
+		});
+	};
+}
+//#endregion
+//#region src/api/formats/base-tools/delete.ts
+var K = (e, t) => H({
+	name: "delete",
+	description: "Delete a block",
+	inputSchema: {
+		type: "object",
+		properties: { id: {
+			type: "string",
+			description: "id of block to delete"
+		} },
+		required: ["id"]
+	},
+	validate: (n) => {
+		if (n.type !== "delete") return {
+			ok: !1,
+			error: "invalid operation type"
+		};
+		if (!n.id) return {
+			ok: !1,
+			error: "id is required"
+		};
+		let r = n.id;
+		if (t.idsSuffixed) {
+			if (!r?.endsWith("$")) return {
+				ok: !1,
+				error: "id must end with $"
+			};
+			r = r.slice(0, -1);
+		}
+		return e.getBlock(r) ? {
+			ok: !0,
+			value: {
+				type: "delete",
+				id: r
+			}
+		} : {
+			ok: !1,
+			error: Error("Block not found (delete)", { cause: { blockId: r } })
+		};
+	},
+	executor: () => ({ execute: async (n) => {
+		if (n.operation.type !== "delete") return !1;
+		let r = n.operation, i = e.prosemirrorState.tr;
+		c(i, [r.id], []);
+		let a = L(i);
+		for (let n of a) t.withDelays && await R(n), e.transact((e) => {
+			z(e, n);
+		}), t.onBlockUpdate?.(r.id);
+		return !0;
+	} })
+});
+//#endregion
+//#region src/api/formats/html-blocks/tools/getPartialHTML.ts
+function Ne(e) {
+	let t = e.lastIndexOf("<"), n = e.lastIndexOf(">"), r = e;
+	if (t > n && (r = e.substring(0, t), !r.trim())) return;
+	let i = r.match(/&[a-zA-Z0-9]*$/);
+	i && (r = r.substring(0, r.length - i[0].length));
+	let a = new DOMParser().parseFromString(`<div>${r}</div>`, "text/html").body.firstChild;
+	return a ? a.innerHTML : "";
+}
+//#endregion
+//#region src/prosemirror/rebaseTool.ts
+function q(e) {
+	let t;
+	if (d(e.prosemirrorState, (e) => {
+		t = e;
+	}), !t) throw Error("applySuggestionsTr is not set");
+	return t;
+}
+function J(e, t) {
+	let n = t.mapping.invert();
+	return {
+		doc: t.doc,
+		tr: () => new S(t.doc),
+		invertMap: n,
+		rebaseTr: (t) => {
+			if (t.steps.length === 0) throw Error("No steps to apply");
+			let r = e.prosemirrorState.tr;
+			for (let e of t.steps) {
+				let t = e.map(n);
+				if (!t) throw Error("Step is not mapped");
+				r = r.step(t);
+			}
+			return r;
+		}
+	};
+}
+//#endregion
+//#region src/api/formats/html-blocks/tools/rebaseTool.ts
+async function Pe(e, t) {
+	let r = q(t), i = n(r.doc, e);
+	if (!i) throw Error("block not found");
+	let a = await t.blocksToHTMLLossy([{
+		...i,
+		children: []
+	}]), o = window.__TEST_OPTIONS?.mockID, s = await t.tryParseHTMLToBlocks(a);
+	if (window.__TEST_OPTIONS && (window.__TEST_OPTIONS.mockID = o), s.length !== 1) throw Error("html diff invalid block count");
+	let c = s[0];
+	if (c.id = e, V({
+		id: e,
+		block: c
+	}, r.doc).length) throw Error("html diff", { cause: {
+		html: a,
+		htmlBlock: c
+	} });
+	return J(t, r);
+}
+//#endregion
+//#region src/api/formats/html-blocks/tools/validate.ts
+function Fe(e) {
+	return typeof e == "string" ? {
+		ok: !0,
+		value: e
+	} : {
+		ok: !1,
+		error: "block must be a string"
+	};
+}
+//#endregion
+//#region src/api/formats/html-blocks/tools/index.ts
+var Y = {
+	add: W({
+		description: "Insert new blocks",
+		schema: { block: {
+			type: "string",
+			description: "html of block (MUST be a single, VALID HTML element)"
+		} },
+		validateBlock: Fe,
+		rebaseTool: Pe,
+		toJSONToolCall: async (e, t) => {
+			let n = window.__TEST_OPTIONS?.mockID, r = (await Promise.all(t.operation.blocks.map(async (n) => {
+				let r = t.isPossiblyPartial ? Ne(n) : n;
+				return r ? (await e.tryParseHTMLToBlocks(r)).map((e) => (delete e.id, e)) : [];
+			}))).flat();
+			if (window.__TEST_OPTIONS && (window.__TEST_OPTIONS.mockID = n), r.length !== 0) return {
+				...t.operation,
+				blocks: r
+			};
+		}
+	}),
+	update: G({
+		description: "Update a block",
+		schema: { block: {
+			type: "string",
+			description: "html of block (MUST be a single HTML element)"
+		} },
+		validateBlock: Fe,
+		rebaseTool: Pe,
+		toJSONToolCall: async (e, t) => {
+			let n = t.isPossiblyPartial ? Ne(t.operation.block) : t.operation.block;
+			if (!n) return;
+			let r = (await e.tryParseHTMLToBlocks(n))[0];
+			return window.__TEST_OPTIONS && (window.__TEST_OPTIONS.mockID = void 0), delete r.id, {
+				...t.operation,
+				block: r
+			};
+		}
+	}),
+	delete: K
+};
+//#endregion
+//#region src/api/formats/html-blocks/htmlBlocks.ts
+function Ie(e, t, n, r, i) {
+	if (typeof r == "boolean") {
+		let t = r ? e.getSelectionCutBlocks(!0) : void 0;
+		r = t ? {
+			from: t._meta.startPos,
+			to: t._meta.endPos
+		} : void 0;
+	}
+	let a = n ?? {
+		add: !0,
+		update: !0,
+		delete: !0
+	};
+	return [
+		...a.update ? [Y.update(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			updateSelection: r,
+			onBlockUpdate: i
+		})] : [],
+		...a.add ? [Y.add(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			onBlockUpdate: i
+		})] : [],
+		...a.delete ? [Y.delete(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			onBlockUpdate: i
+		})] : []
+	];
+}
+var Le = {
+	getStreamToolsProvider: (e = {}) => ({ getStreamTools: (t, n, r) => Ie(t, e.withDelays ?? !0, e.defaultStreamTools, n, r) }),
+	systemPrompt: "You're manipulating a text document using HTML blocks. \nMake sure to follow the json schema provided. When referencing ids they MUST be EXACTLY the same (including the trailing $). \nList items are 1 block with 1 list item each, so block content `<ul><li>item1</li></ul>` is valid, but `<ul><li>item1</li><li>item2</li></ul>` is invalid. We'll merge them automatically.\nFor code blocks, you can use the `data-language` attribute on a <code> block (wrapped with <pre>) to specify the language.\n\nIf the user requests updates to the document, use the \"applyDocumentOperations\" tool to update the document.\n---\nIF there is no selection active in the latest state, first, determine what part of the document the user is talking about. You SHOULD probably take cursor info into account if needed.\n  EXAMPLE: if user says \"below\" (without pointing to a specific part of the document) he / she probably indicates the block(s) after the cursor. \n  EXAMPLE: If you want to insert content AT the cursor position (UNLESS indicated otherwise by the user), then you need `referenceId` to point to the block before the cursor with position `after` (or block below and `before`\n---\n ",
+	tools: Y,
+	defaultDocumentStateBuilder: I(async (e, t) => e.blocksToHTMLLossy([t]))
+};
+//#endregion
+//#region src/api/schema/mergeSchema.ts
+function Re(e) {
+	let t = {}, n = {};
+	return e.forEach((e) => {
+		let { type: r, ...i } = e.properties, a = JSON.stringify(i);
+		t[a] ? t[a].push(r.enum[0]) : (t[a] = [r.enum[0]], n[a] = e);
+	}), Object.keys(t).map((e) => {
+		let r = n[e];
+		return {
+			...r,
+			properties: {
+				...r.properties,
+				type: {
+					type: "string",
+					enum: t[e]
+				}
+			}
+		};
+	});
+}
+//#endregion
+//#region src/api/schema/schemaToJSONSchema.ts
+function ze(e) {
+	return {
+		type: "object",
+		properties: Object.fromEntries(Object.entries(e).map(([e, t]) => [e, { type: t.propSchema }])),
+		additionalProperties: !1
+	};
+}
+function Be() {
+	return {
+		type: "object",
+		properties: {
+			type: {
+				type: "string",
+				enum: ["text"]
+			},
+			text: { type: "string" },
+			styles: { $ref: "#/$defs/styles" }
+		},
+		additionalProperties: !1,
+		required: ["type", "text"]
+	};
+}
+function Ve(e) {
+	return {
+		type: "object",
+		properties: Object.fromEntries(Object.entries(e).filter(([e, t]) => t.default !== void 0).map(([e, t]) => [e, {
+			type: typeof t.default,
+			enum: t.values
+		}])),
+		additionalProperties: !1
+	};
+}
+function He(e) {
+	return {
+		type: "array",
+		items: { anyOf: Object.entries(e).map(([e, t]) => t === "text" ? { $ref: "#/$defs/styledtext" } : t === "link" ? {
+			type: "object",
+			properties: {
+				type: {
+					type: "string",
+					enum: ["link"]
+				},
+				content: {
+					type: "array",
+					items: { $ref: "#/$defs/styledtext" }
+				},
+				href: { type: "string" }
+			},
+			additionalProperties: !1,
+			required: [
+				"type",
+				"href",
+				"content"
+			]
+		} : {
+			type: "object",
+			properties: {
+				type: {
+					type: "string",
+					enum: [t.type]
+				},
+				content: t.content === "styled" ? {
+					type: "array",
+					items: { $ref: "#/$defs/styledtext" }
+				} : void 0,
+				props: Ve(t.propSchema)
+			},
+			additionalProperties: !1,
+			required: ["type", ...t.content === "styled" ? ["content"] : []]
+		}) }
+	};
+}
+function Ue(e) {
+	return { anyOf: Re(Object.entries(e).map(([e, t]) => ({
+		type: "object",
+		properties: {
+			type: {
+				type: "string",
+				enum: [t.type]
+			},
+			content: t.content === "inline" ? { $ref: "#/$defs/inlinecontent" } : t.content === "table" ? {
+				type: "object",
+				properties: {}
+			} : void 0,
+			props: Ve(t.propSchema)
+		},
+		additionalProperties: !1,
+		required: ["type"]
+	}))) };
+}
+function We(e) {
+	let n = JSON.parse(JSON.stringify({
+		blockSchema: e.blockSchema,
+		inlineContentSchema: e.inlineContentSchema,
+		styleSchema: e.styleSchema
+	}));
+	return {
+		removeFileBlocks() {
+			return n.blockSchema = Object.fromEntries(Object.entries(n.blockSchema).filter(([t, n]) => !e.blockSpecs[n.type].implementation.meta?.fileBlockAccept)), this;
+		},
+		removeDefaultProps() {
+			return n.blockSchema = Object.fromEntries(Object.entries(n.blockSchema).map(([e, n]) => [e, {
+				...n,
+				propSchema: Object.fromEntries(Object.entries(n.propSchema).filter((e) => t[e[0]] === void 0))
+			}])), this;
+		},
+		get() {
+			return n;
+		}
+	};
+}
+function X(e) {
+	return e = We(e).removeFileBlocks().removeDefaultProps().get(), { $defs: {
+		styles: ze(e.styleSchema),
+		styledtext: Be(),
+		inlinecontent: He(e.inlineContentSchema),
+		block: Ue(e.blockSchema)
+	} };
+}
+//#endregion
+//#region src/api/formats/json/tools/validate.ts
+function Ge(e, t) {
+	return !t.schema.inlineContentSchema[e.type] || s(e) && !("text" in e) ? !1 : o(e) ? !("content" in e) || !("href" in e) ? !1 : Ge(e.content, t) : !0;
+}
+function Ke(e, t, n) {
+	let r = e.type || n, i = t.schema.blockSchema[r];
+	if (!i) return {
+		ok: !1,
+		error: "block type not found in editor"
+	};
+	if (e.children, i.content === "none") {
+		if (e.content) return {
+			ok: !1,
+			error: "block content not expected for this block type"
+		};
+	} else {
+		if (!e.content) return {
+			ok: !0,
+			value: e
+		};
+		if (!Array.isArray(e.content)) return {
+			ok: !1,
+			error: "block content must be an array"
+		};
+		if (i.content === "table") return {
+			ok: !0,
+			value: e
+		};
+		if (!e.content.every((e) => Ge(e, t))) return {
+			ok: !1,
+			error: "block content must be an array of inline content"
+		};
+	}
+	return {
+		ok: !0,
+		value: e
+	};
+}
+//#endregion
+//#region src/api/formats/json/tools/index.ts
+var Z = {
+	add: W({
+		description: "Insert new blocks",
+		schema: (e) => ({
+			block: { $ref: "#/$defs/block" },
+			...X(e.schema)
+		}),
+		validateBlock: Ke,
+		rebaseTool: async (e, t) => J(t, q(t)),
+		toJSONToolCall: async (e, t) => t.operation
+	}),
+	update: G({
+		description: "Update a block, the new block will replace the existing block.",
+		schema: (e) => ({
+			block: { $ref: "#/$defs/block" },
+			...X(e.schema)
+		}),
+		validateBlock: Ke,
+		rebaseTool: async (e, t) => J(t, q(t)),
+		toJSONToolCall: async (e, n) => {
+			let r = Object.fromEntries(Object.entries(t).map(([e, t]) => [e, t.default]));
+			return {
+				...n.operation,
+				block: {
+					...n.operation.block,
+					props: {
+						...r,
+						...n.operation.block.props
+					}
+				}
+			};
+		}
+	}),
+	delete: K
+};
+//#endregion
+//#region src/api/formats/json/json.ts
+function qe(e, t, n, r, i) {
+	if (typeof r == "boolean") {
+		let t = r ? e.getSelectionCutBlocks(!0) : void 0;
+		r = t ? {
+			from: t._meta.startPos,
+			to: t._meta.endPos
+		} : void 0;
+	}
+	let a = n ?? {
+		add: !0,
+		update: !0,
+		delete: !0
+	};
+	return [
+		...a.update ? [Z.update(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			updateSelection: r,
+			onBlockUpdate: i
+		})] : [],
+		...a.add ? [Z.add(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			onBlockUpdate: i
+		})] : [],
+		...a.delete ? [Z.delete(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			onBlockUpdate: i
+		})] : []
+	];
+}
+var Je = {
+	getStreamToolsProvider: (e = {}) => ({ getStreamTools: (t, n, r) => qe(t, e.withDelays ?? !0, e.defaultStreamTools, n, r) }),
+	tools: Z,
+	systemPrompt: "You're manipulating a text document using JSON blocks. \nMake sure to follow the json schema provided. When referencing ids they MUST be EXACTLY the same (including the trailing $). \n\nIf the user requests updates to the document, use the \"applyDocumentOperations\" tool to update the document.\n---\nIF there is no selection active in the latest state, first, determine what part of the document the user is talking about. You SHOULD probably take cursor info into account if needed.\n  EXAMPLE: if user says \"below\" (without pointing to a specific part of the document) he / she probably indicates the block(s) after the cursor. \n  EXAMPLE: If you want to insert content AT the cursor position (UNLESS indicated otherwise by the user), then you need `referenceId` to point to the block before the cursor with position `after` (or block below and `before`\n---\n ",
+	defaultDocumentStateBuilder: I(async (e, t) => ({
+		...t,
+		id: void 0,
+		children: void 0
+	}))
+};
+//#endregion
+//#region src/api/formats/markdown-blocks/tools/rebaseTool.ts
+async function Ye(e, t) {
+	let r = q(t), i = await t.blocksToMarkdownLossy([n(r.doc, e)]), a = V({
+		id: e,
+		block: (await t.tryParseMarkdownToBlocks(i))[0]
+	}, r.doc), o = new re();
+	for (let e of a) {
+		let t = e.map(o);
+		if (!t) throw Error("Failed to map step");
+		r.step(t), o.appendMap(t.getMap());
+	}
+	return J(t, r);
+}
+//#endregion
+//#region src/api/formats/markdown-blocks/tools/validate.ts
+function Xe(e) {
+	return typeof e == "string" ? {
+		ok: !0,
+		value: e
+	} : {
+		ok: !1,
+		error: "block must be a string"
+	};
+}
+//#endregion
+//#region src/api/formats/markdown-blocks/tools/index.ts
+var Q = {
+	add: W({
+		description: "Insert new blocks",
+		schema: {
+			block: { $ref: "#/$defs/block" },
+			$defs: { block: {
+				type: "string",
+				description: "markdown of block"
+			} }
+		},
+		validateBlock: Xe,
+		rebaseTool: Ye,
+		toJSONToolCall: async (e, t) => {
+			let n = await Promise.all(t.operation.blocks.map(async (t) => {
+				let n = (await e.tryParseMarkdownToBlocks(t.trim()))[0];
+				return delete n.id, n;
+			}));
+			return window.__TEST_OPTIONS && (window.__TEST_OPTIONS.mockID = void 0), {
+				...t.operation,
+				blocks: n
+			};
+		}
+	}),
+	update: G({
+		description: "Update a block, the new block will replace the existing block.",
+		schema: {
+			block: { $ref: "#/$defs/block" },
+			$defs: { block: {
+				type: "string",
+				description: "markdown of block"
+			} }
+		},
+		validateBlock: Xe,
+		rebaseTool: Ye,
+		toJSONToolCall: async (e, t) => {
+			let n = (await e.tryParseMarkdownToBlocks(t.operation.block.trim()))[0];
+			return delete n.id, window.__TEST_OPTIONS && (window.__TEST_OPTIONS.mockID = void 0), {
+				...t.operation,
+				block: n
+			};
+		}
+	}),
+	delete: K
+};
+//#endregion
+//#region src/api/formats/markdown-blocks/markdownBlocks.ts
+function Ze(e, t, n, r, i) {
+	if (typeof r == "boolean") {
+		let t = r ? e.getSelectionCutBlocks(!0) : void 0;
+		r = t ? {
+			from: t._meta.startPos,
+			to: t._meta.endPos
+		} : void 0;
+	}
+	let a = n ?? {
+		add: !0,
+		update: !0,
+		delete: !0
+	};
+	return [
+		...a.update ? [Q.update(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			updateSelection: r,
+			onBlockUpdate: i
+		})] : [],
+		...a.add ? [Q.add(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			onBlockUpdate: i
+		})] : [],
+		...a.delete ? [Q.delete(e, {
+			idsSuffixed: !0,
+			withDelays: t,
+			onBlockUpdate: i
+		})] : []
+	];
+}
+//#endregion
+//#region src/api/formats/formats.ts
+var $ = {
+	_experimental_json: Je,
+	_experimental_markdown: {
+		getStreamToolsProvider: (e = {}) => ({ getStreamTools: (t, n, r) => Ze(t, e.withDelays ?? !0, e.defaultStreamTools, n, r) }),
+		systemPrompt: "You're manipulating a text document using Markdown blocks. \nMake sure to follow the json schema provided. When referencing ids they MUST be EXACTLY the same (including the trailing $). \nList items are 1 block with 1 list item each, so block content `- item1` is valid, but `- item1\n- item2` is invalid. We'll merge them automatically.\n\nIf the user requests updates to the document, use the \"applyDocumentOperations\" tool to update the document.\n---\nIF there is no selection active in the latest state, first, determine what part of the document the user is talking about. You SHOULD probably take cursor info into account if needed.\n  EXAMPLE: if user says \"below\" (without pointing to a specific part of the document) he / she probably indicates the block(s) after the cursor. \n  EXAMPLE: If you want to insert content AT the cursor position (UNLESS indicated otherwise by the user), then you need `referenceId` to point to the block before the cursor with position `after` (or block below and `before`\n---\n ",
+		tools: Q,
+		defaultDocumentStateBuilder: I(async (e, t) => e.blocksToMarkdownLossy([t]))
+	},
+	html: Le
+}, Qe = {
+	addCursorPosition: M,
+	flattenBlocks: P,
+	suffixIDs: F,
+	trimEmptyBlocks: T,
+	convertBlocks: N
+};
+//#endregion
+//#region src/i18n/dictionary.ts
+function $e(e) {
+	if (!e.dictionary.ai) throw Error("AI dictionary not found");
+	return e.dictionary.ai;
+}
+//#endregion
+//#region src/blocknoteAIClient/client.ts
+var et = (e) => async (t, n) => {
+	let r = new Request(t, n), i = e(r.url), a = new Request(i, {
+		headers: r.headers,
+		body: n?.body || r.body,
+		method: r.method,
+		duplex: "half"
+	});
+	return await fetch(a);
+};
+//#endregion
+export { E as _, q as a, j as c, O as d, he as f, ue as g, fe as h, $ as i, A as l, pe as m, $e as n, I as o, me as p, Qe as r, De as s, et as t, ge as u, le as v, se as y };
+
+//# sourceMappingURL=server-JIYg7ELG.js.map