@skaile/forge-editor 6.2.1 → 6.4.0

package/dist/server/handlers/ai.js

@@ -6,8 +6,8 @@ import { AI_ID_PATTERN, aiBlockSchema } from "../../features/ai/protocol/schemas
 import { generateBodySchema, generateProblem, runGenerate } from "../../features/ai/protocol/generate.js";
 import { AGENT_OP_OUTCOMES, AGENT_OP_TYPES } from "../../core/agent-op-types.js";
 import { readBlockLines } from "../../features/ai/protocol/block-lines.js";
-import { AGENT_LIMITS, AGENT_TOOL, agentOpTarget, agentRetryMessage, agentUnreadableProblem, checkAgentOps } from "../../features/ai/protocol/agent-ops.js";
-import { CHAT_LIMITS, documentChatMessages } from "../../features/ai/protocol/chat.js";
+import { AGENT_LIMITS, AGENT_TOOL, agentOpTarget, agentRetryMessage, agentShownMessage, agentUnreadableProblem, checkAgentOps } from "../../features/ai/protocol/agent-ops.js";
+import { CHAT_LIMITS, documentChatMessages, documentChatSystem } from "../../features/ai/protocol/chat.js";
 import { TranscriptCleanupUnreadableError, runTranscriptCleanup, transcriptCleanupRequestSchema } from "../../integrations/transcript-ai/protocol.js";
 import { blockExcerptText } from "../../core/block-snippet.js";
 import { AGENT_OP_ID } from "../../core/change-set.js";
@@ -16,9 +16,10 @@ import { aiBlockTypesOf } from "../../features/composites/block-types.js";
 import { ASSET_DOCUMENT_ID, ASSET_NAME } from "../../features/media/assets.js";
 import { loadCurrentContent } from "../stored-content.js";
 import { HttpError } from "../errors.js";
+import { documentEditTool } from "../chat-agent.js";
 import { mayEditDocument } from "../readable-documents.js";
-import { toolRegistry } from "../tools.js";
 import { blockExcerptOf, blockLinesOfContent } from "../document-blocks.js";
+import { toolRegistry } from "../tools.js";
 import { authenticated, enforceRateLimit, eventStream, json, port, readBody } from "./context.js";
 import { DOI_PATTERN } from "../crossref.js";
 import { MAX_TRANSCRIBE_BYTES, RasterError, bibliographyText, describeImage, extractBibliography, isScanned, joinPages, ocrPages, pdfPagesText, transcribe } from "../extract.js";
@@ -141,57 +142,108 @@ const chatBodySchema = z.object({
 	structure: z.enum(STRUCTURE_MODES)
 });
 /**
-* The tools of one chat turn: `edit_document` (deliberately loose, so malformed calls reach `checkAgentOps` and get a precise
-* retry message) and, with `reads`, the registry's read-only tools. With `workspace` (the host keeps change sets and a mutator)
-* the operations of `edit_document` may name another Document by `documentId`.
+* The tools of one chat turn: `edit_document` (`documentEditTool`, deliberately loose, so malformed calls reach `checkAgentOps`
+* and get a precise retry message) and, with `reads`, the registry's read-only tools. With `workspace` (the host keeps change
+* sets and a mutator) the operations of `edit_document` may name another Document by `documentId`.
 */
 function agentTools(registry, { workspace, reads }) {
+	const edit = documentEditTool({ workspace });
 	return {
 		[AGENT_TOOL]: tool({
-			description: workspace ? "Schlägt Änderungen vor. Operationen am geöffneten Dokument zeigt die Nutzerin bzw. der Nutzer im Dokument zur Prüfung an; Operationen mit documentId (anderes Dokument des Arbeitsbereichs) landen in einem Änderungssatz, den die Nutzerin bzw. der Nutzer je Dokument prüft und übernimmt oder ablehnt." : "Schlägt Änderungen am Dokument vor. Jede Operation wird der Nutzerin bzw. dem Nutzer im Dokument zur Prüfung angezeigt.",
-			inputSchema: jsonSchema({
-				type: "object",
-				properties: { ops: {
-					type: "array",
-					description: "Die Operationen in Dokumentreihenfolge.",
-					items: {
-						type: "object",
-						properties: {
-							type: {
-								type: "string",
-								enum: [...AGENT_OP_TYPES],
-								description: "update: Blockinhalt ersetzen; delete: Block löschen; add: Blöcke einfügen; convert: Blocktyp ändern."
-							},
-							...workspace && { documentId: {
-								type: "string",
-								description: "Nur für Blöcke eines anderen Dokuments: dessen ID (zusammen mit den Block-IDs aus find_blocks oder read_block). Es muss ein Dokument sein, das die Nutzerin bzw. der Nutzer bearbeiten darf. Ohne Angabe gilt das geöffnete Dokument."
-							} },
-							id: {
-								type: "string",
-								description: "update/delete/convert: ID des Blocks aus dem Dokument."
-							},
-							afterId: {
-								type: ["string", "null"],
-								description: "add (Pflicht): ID des Blocks, nach dem eingefügt wird; für den Dokumentanfang ausdrücklich null."
-							},
-							markdown: {
-								type: "string",
-								description: "update/add: der neue Inhalt als Markdown, ohne Block-ID."
-							},
-							to: {
-								type: "string",
-								description: "convert: der neue Blocktyp, einer der im Systemprompt erlaubten Werte (z. B. paragraph, heading2, composite:task)."
-							}
-						},
-						required: ["type"]
-					}
-				} },
-				required: ["ops"]
-			})
+			description: edit.description,
+			inputSchema: jsonSchema(edit.inputSchema)
 		}),
 		...reads && registry.tools
 	};
 }
+/** Checks a chat request beyond its schema (400 for an empty message or a selection without blocks of the document) and answers where its operations may point (`checkAgentOps`). */
+function opContextOf({ messages, document, scope, targets }) {
+	if (!messages.at(-1).content.trim()) throw new HttpError(400, "Nachricht fehlt");
+	const lines = readBlockLines(document);
+	const allowed = scope ? new Set(scope.filter((id) => lines.ids.has(id))) : null;
+	if (allowed && !allowed.size) throw new HttpError(400, "Die Auswahl enthält keine Blöcke des Dokuments");
+	return {
+		lines,
+		allowed,
+		targets: new Set(targets)
+	};
+}
+/** Loads the Documents operations name, once per request (the model's read and its edit see the same content); `null` for one the user may not edit or that does not exist. */
+function namedDocumentLoader(ctx, user, toolContext) {
+	const loaded = /* @__PURE__ */ new Map();
+	return (id) => {
+		let entry = loaded.get(id);
+		if (!entry) {
+			entry = (async () => {
+				if (!await mayEditDocument(ctx.ports, user, id)) return null;
+				const content = toolContext.liveContent(id) ?? await loadCurrentContent(ctx.ports.documents, id);
+				return content && {
+					content,
+					lines: blockLinesOfContent(content)
+				};
+			})();
+			loaded.set(id, entry);
+		}
+		return entry;
+	};
+}
+/** The lines of the other Documents `raw` names, as far as the user may edit them; empty without `documentOf` (no change sets: such an operation is a `document` problem). */
+async function namedDocumentLines(raw, openDocumentId, documentOf) {
+	const documents = /* @__PURE__ */ new Map();
+	if (!documentOf) return documents;
+	const named = new Set(raw.flatMap((op) => typeof op === "object" && op !== null && "documentId" in op && typeof op.documentId === "string" ? [op.documentId.trim()] : []));
+	named.delete(openDocumentId ?? "");
+	for (const id of [...named].slice(0, AGENT_LIMITS.ops)) {
+		const entry = id ? await documentOf(id) : null;
+		if (entry) documents.set(id, entry.lines);
+	}
+	return documents;
+}
+/**
+* Streams the operations of a turn, numbered from `op<nextOp>`: the open Document's as `ops` (the editor's in-document review),
+* the others' as one stored `change-set`. Without an answer text and without a valid operation the user reads that none was possible.
+*/
+async function emitProposal(emit, proposal) {
+	const { all, dropped, retries, answered, user, changeSets, documentOf } = proposal;
+	const ops = all.filter((op) => op.documentId === void 0);
+	const foreign = all.filter((op) => op.documentId !== void 0);
+	if (!answered && !all.length) emit("delta", JSON.stringify({ text: "Ich konnte keine gültigen Änderungen vorschlagen." }));
+	if (foreign.length) {
+		const hunks = await Promise.all(foreign.map(async (op) => {
+			const documentId = op.documentId;
+			const target = agentOpTarget(op);
+			const entry = await documentOf(documentId);
+			const excerpt = target === null || !entry ? null : blockExcerptOf(entry.content, target);
+			return {
+				op: {
+					...op,
+					documentId
+				},
+				status: "pending",
+				target: excerpt && {
+					type: excerpt.type,
+					text: blockExcerptText(excerpt.text)
+				}
+			};
+		}));
+		emit("change-set", JSON.stringify(await changeSets.create({
+			by: changeSetOwner(user),
+			hunks
+		})));
+	}
+	emit("ops", JSON.stringify({
+		ops,
+		dropped,
+		retries
+	}));
+}
+/** `final` and the problems of earlier attempts whose block no operation of `all` targets: an operation a corrected list leaves out counts as dropped too. */
+function droppedOf(all, final, earlier) {
+	const targets = new Set(all.map((op) => agentOpTarget(op)));
+	const dropped = [...final];
+	for (const problem of earlier) if (problem.id !== null && !targets.has(problem.id) && !dropped.some((d) => d.id === problem.id && d.type === problem.type)) dropped.push(problem);
+	return dropped;
+}
 /**
 * Document chat: answers the last message of `messages` about `document`, or proposes edit operations through the
 * `edit_document` tool. Operations pointing to IDs that are unknown or outside `scope`, an `add` without `afterId`, an
@@ -203,24 +255,33 @@ function agentTools(registry, { workspace, reads }) {
 * Operations of the open Document (`documentId` absent or the body's) are `ops`; operations naming another Document the
 * user may edit (`mayEditDocument`) become one `ChangeSet` (`ChangeSetStore`) for the user to review per Document, when the
 * host has the `changeSets` port and a mutator; else such an operation is a `document` problem the model retries. All
-* operations share one numbering (`op<n>`).
+* operations share one numbering (`op<n>`). With a host agent (`AiHandlerContext.chatAgent` answers one for the user) the
+* agent answers the turn in place of the model loop (`agentChat`), with the same checks and events.
 */
 async function chatPost(ctx, request) {
 	const user = await enforceRateLimit(ctx, request);
-	const { messages, document, documentId: openDocumentId, scope, nextOp, model, blockTypes: clientBlockTypes, blocks, targets, structure } = await readBody(request, chatBodySchema);
-	const blockTypes = ctx.blockTypes ? aiBlockTypesOf(ctx.blockTypes) : clientBlockTypes;
-	const languageModel = await ctx.ai.resolveModel(model, user);
-	if (!messages.at(-1).content.trim()) throw new HttpError(400, "Nachricht fehlt");
-	const lines = readBlockLines(document);
-	const allowed = scope ? new Set(scope.filter((id) => lines.ids.has(id))) : null;
-	if (allowed && !allowed.size) throw new HttpError(400, "Die Auswahl enthält keine Blöcke des Dokuments");
-	const context = {
-		lines,
-		allowed,
-		targets: new Set(targets)
+	const body = await readBody(request, chatBodySchema);
+	const { messages, document, documentId: openDocumentId, nextOp, model, blockTypes: clientBlockTypes, blocks, targets, structure } = body;
+	const blockModel = {
+		blockTypes: ctx.blockTypes ? aiBlockTypesOf(ctx.blockTypes) : clientBlockTypes,
+		blocks,
+		targets,
+		structure
 	};
 	const registry = ctx.tools ?? NO_TOOLS;
 	const changeSets = ctx.mutator ? ctx.ports.changeSets : void 0;
+	const agent = await ctx.chatAgent?.(user) ?? null;
+	if (agent) return agentChat(ctx, request, agent, {
+		user,
+		body,
+		blockModel,
+		context: opContextOf(body),
+		registry,
+		changeSets
+	});
+	const languageModel = await ctx.ai.resolveModel(model, user);
+	const context = opContextOf(body);
+	const { allowed } = context;
 	const workspace = changeSets !== void 0;
 	const editTools = agentTools(registry, {
 		workspace,
@@ -232,12 +293,7 @@ async function chatPost(ctx, request) {
 	});
 	return eventStream(request, async (emit, signal) => {
 		try {
-			let conversation = documentChatMessages(messages, document, allowed && [...allowed], {
-				blockTypes,
-				blocks,
-				targets,
-				structure
-			}, registry.infos);
+			let conversation = documentChatMessages(messages, document, allowed && [...allowed], blockModel, registry.infos);
 			let answered = false;
 			let result = null;
 			const retried = [];
@@ -250,22 +306,7 @@ async function chatPost(ctx, request) {
 				liveContent: (id) => ctx.collab?.liveContent(id) ?? null,
 				...openDocumentId && { documentId: openDocumentId }
 			};
-			const loaded = /* @__PURE__ */ new Map();
-			const documentOf = (id) => {
-				let entry = loaded.get(id);
-				if (!entry) {
-					entry = (async () => {
-						if (!await mayEditDocument(ctx.ports, user, id)) return null;
-						const content = toolContext.liveContent(id) ?? await loadCurrentContent(ctx.ports.documents, id);
-						return content && {
-							content,
-							lines: blockLinesOfContent(content)
-						};
-					})();
-					loaded.set(id, entry);
-				}
-				return entry;
-			};
+			const documentOf = namedDocumentLoader(ctx, user, toolContext);
 			for (;;) {
 				const calls = [];
 				const reads = [];
@@ -346,15 +387,7 @@ async function chatPost(ctx, request) {
 				if (!calls.length) break;
 				const unreadable = calls.some((call) => call.invalid || !Array.isArray(call.input?.ops));
 				const raw = calls.flatMap((call) => call.input?.ops).filter((op) => op !== void 0);
-				const documents = /* @__PURE__ */ new Map();
-				if (changeSets) {
-					const named = new Set(raw.flatMap((op) => typeof op?.documentId === "string" ? [op.documentId.trim()] : []));
-					named.delete(openDocumentId ?? "");
-					for (const id of [...named].slice(0, AGENT_LIMITS.ops)) {
-						const entry = id ? await documentOf(id) : null;
-						if (entry) documents.set(id, entry.lines);
-					}
-				}
+				const documents = await namedDocumentLines(raw, openDocumentId, changeSets ? documentOf : null);
 				const checked = checkAgentOps(raw, {
 					...context,
 					...openDocumentId && { documentId: openDocumentId },
@@ -399,40 +432,118 @@ async function chatPost(ctx, request) {
 					...op,
 					op: `op${nextOp + i}`
 				}));
-				const ops = all.filter((op) => op.documentId === void 0);
-				const foreign = all.filter((op) => op.documentId !== void 0);
-				const targets = new Set(all.map((op) => agentOpTarget(op)));
-				const dropped = [...result.problems];
-				for (const problem of retried) if (problem.id !== null && !targets.has(problem.id) && !dropped.some((d) => d.id === problem.id && d.type === problem.type)) dropped.push(problem);
-				if (!answered && !all.length) emit("delta", JSON.stringify({ text: "Ich konnte keine gültigen Änderungen vorschlagen." }));
-				if (foreign.length) {
-					const hunks = await Promise.all(foreign.map(async (op) => {
-						const documentId = op.documentId;
-						const target = agentOpTarget(op);
-						const entry = await documentOf(documentId);
-						const excerpt = target === null || !entry ? null : blockExcerptOf(entry.content, target);
-						return {
-							op: {
-								...op,
-								documentId
-							},
-							status: "pending",
-							target: excerpt && {
-								type: excerpt.type,
-								text: blockExcerptText(excerpt.text)
-							}
-						};
-					}));
-					emit("change-set", JSON.stringify(await changeSets.create({
-						by: changeSetOwner(user),
-						hunks
-					})));
-				}
-				emit("ops", JSON.stringify({
+				await emitProposal(emit, {
+					all,
+					dropped: droppedOf(all, result.problems, retried),
+					retries,
+					answered,
+					user,
+					changeSets,
+					documentOf
+				});
+			}
+			emit("done", "{}");
+		} catch (error) {
+			if (!signal.aborted) {
+				const { statusMessage, message } = error;
+				emit("error", JSON.stringify({ message: statusMessage ?? message ?? "Unbekannter Fehler" }));
+			}
+		}
+	});
+}
+/**
+* The chat turn of a host's `ChatAgent`: the agent gets the request as `ChatAgentTurn` (snapshot, scope, block model, the
+* read-only tools with their context, the built-in system prompt and `edit_document`) and streams text, the tool calls it ran
+* and the operations `checkEdit` accepted. They become the built-in loop's events: `delta`, `tool`, then once the proposal of
+* all edits (`change-set` for other Documents, `ops` numbered from `nextOp`), `done`; a thrown error is `error`. `checkEdit`
+* checks each `edit_document` call against the operations of the earlier calls of the turn too (the limit, a block edited twice,
+* an operation inside a block an earlier one replaces), and numbers on from them.
+*/
+function agentChat(ctx, request, agent, chat) {
+	const { user, body: { messages, document, documentId: openDocumentId, nextOp }, blockModel, context, registry, changeSets } = chat;
+	return eventStream(request, async (emit, signal) => {
+		try {
+			const toolContext = {
+				ports: ctx.ports,
+				user,
+				signal,
+				liveContent: (id) => ctx.collab?.liveContent(id) ?? null,
+				...openDocumentId && { documentId: openDocumentId }
+			};
+			const documentOf = namedDocumentLoader(ctx, user, toolContext);
+			const shown = [];
+			const checkEdit = async (input) => {
+				const value = typeof input === "object" && input !== null && "ops" in input ? input.ops : void 0;
+				const raw = [...shown, ...Array.isArray(value) ? value.filter((op) => op !== void 0) : []];
+				const documents = await namedDocumentLines(raw, openDocumentId, changeSets ? documentOf : null);
+				const checked = checkAgentOps(raw, {
+					...context,
+					...openDocumentId && { documentId: openDocumentId },
+					documents
+				});
+				const covered = checked.problems.filter((problem) => problem.index <= shown.length).length;
+				const fresh = checked.valid.slice(shown.length - covered);
+				const problems = checked.problems.filter((problem) => problem.index > shown.length).map((problem) => ({
+					...problem,
+					index: problem.index - shown.length
+				}));
+				if (!Array.isArray(value)) problems.unshift(agentUnreadableProblem());
+				const ops = fresh.map((op, i) => ({
+					...op,
+					op: `op${nextOp + shown.length + i}`
+				}));
+				shown.push(...fresh);
+				const message = agentShownMessage(ops, 0);
+				return {
 					ops,
-					dropped,
-					retries
+					problems,
+					feedback: problems.length ? `${message}\n${agentRetryMessage(problems, !!context.allowed, { partial: true })}` : message
+				};
+			};
+			const proposed = [];
+			const attempts = [];
+			let answered = false;
+			for await (const part of agent.turn({
+				user,
+				...openDocumentId && { documentId: openDocumentId },
+				messages,
+				document,
+				scope: context.allowed && [...context.allowed],
+				blockModel,
+				tools: registry,
+				toolContext,
+				system: documentChatSystem(blockModel, registry.infos),
+				editTool: documentEditTool({ workspace: changeSets !== void 0 }),
+				checkEdit,
+				signal
+			})) if (part.type === "text") {
+				if (!part.text) continue;
+				answered = true;
+				emit("delta", JSON.stringify({ text: part.text }));
+			} else if (part.type === "tool") emit("tool", JSON.stringify({
+				name: part.call.name,
+				input: toolInput(part.call.input),
+				output: part.call.output.slice(0, CHAT_LIMITS.toolOutput)
+			}));
+			else {
+				proposed.push(...part.ops);
+				attempts.push(part.dropped);
+			}
+			if (attempts.length) {
+				const all = proposed.map((op, i) => ({
+					...op,
+					op: `op${nextOp + i}`
 				}));
+				const retries = attempts.slice(1).filter((_, i) => attempts[i].length > 0).length;
+				await emitProposal(emit, {
+					all,
+					dropped: droppedOf(all, attempts.at(-1), attempts.slice(0, -1).flat()),
+					retries,
+					answered,
+					user,
+					changeSets,
+					documentOf
+				});
 			}
 			emit("done", "{}");
 		} catch (error) {