@jigs.design/server 0.2.0 → 0.3.0

package/dist/session.d.ts

@@ -3,5 +3,4 @@ import "./compile.js";
 import "./types.js";
 import "@jigs.design/compiler";
 import { Host } from "@jigs.design/host";
-import { Diagnostic, Message, SessionEvent } from "@jigs.design/protocol";
-import { z } from "zod";
+import { Diagnostic, JigsErrorData, Message, SessionEvent } from "@jigs.design/protocol";

package/dist/session.js

@@ -1,15 +1,60 @@
 import { errorData, isJigsError } from "./errors.js";
 import { belowPrefix, pragmaLine, splitPragma, versionDiagnostics, withPragma } from "./pragma.js";
 import { reorderDeclarations } from "./rewrite.js";
+import { issuesText } from "./handler.js";
 import { addUsage } from "./usage.js";
 import { applyEdits, editBreakage, isEditReply, parseEdits } from "@jigs.design/compiler";
-import { editRepairText, fullDocumentText, needsRepair, repairText } from "@jigs.design/prompt";
+import { editRepairText, fullDocumentText, needsRepair, repairText, withDocument } from "@jigs.design/prompt";
 import { z } from "zod";
 const MAX_CONTENT = 2e5;
-const messagesSchema = z.array(z.object({
-	content: z.string().max(MAX_CONTENT),
-	role: z.enum(["user", "assistant"])
-})).min(1).max(200);
+const documentSchema = z.union([z.strictObject({ source: z.string().min(1).max(MAX_CONTENT) }), z.strictObject({
+	name: z.string().min(1).max(200),
+	props: z.record(z.string(), z.union([
+		z.boolean(),
+		z.number(),
+		z.string()
+	])).exactOptional()
+})]);
+const sessionSchema = z.object({
+	document: documentSchema.optional(),
+	messages: z.array(z.object({
+		content: z.string().max(MAX_CONTENT),
+		role: z.enum(["user", "assistant"])
+	})).max(200)
+});
+/** Whether a turn calls the model: its conversation ends with an ask. */
+const asksModel = (messages) => messages.at(-1)?.role === "user";
+/**
+* Checks a session request's `document` and `messages`: their shape and
+* limits, then that the turn has something to do. A reply with no document
+* is history the model could not act on, so it is refused.
+*/
+function parseSessionInput(body) {
+	const parsed = sessionSchema.safeParse({
+		document: body.document,
+		messages: body.messages
+	});
+	if (!parsed.success) return { error: {
+		code: "BAD_INPUT",
+		message: issuesText(parsed.error)
+	} };
+	const document = parsed.data.document ?? null;
+	const messages = parsed.data.messages;
+	if (document === null) {
+		if (messages.length === 0) return { error: {
+			code: "BAD_INPUT",
+			message: "Send a document, a message, or both."
+		} };
+		if (messages.some((message) => message.role === "assistant")) return { error: {
+			code: "BAD_INPUT",
+			message: "messages holds a reply, so send the document it produced as `document`."
+		} };
+	}
+	return {
+		document,
+		messages
+	};
+}
 const modelResult = z.object({ usage: z.object({
 	cacheReadTokens: z.number().nonnegative().exactOptional(),
 	cacheWriteTokens: z.number().nonnegative().exactOptional(),
@@ -58,20 +103,41 @@ function applyChecked(base, edits, compile) {
 		reason: "broken"
 	};
 }
-const lastAssistantBody = (messages) => {
-	for (let index = messages.length - 1; index >= 0; index--) {
-		const message = messages[index];
-		if (message?.role === "assistant") return splitPragma(message.content).body;
-	}
-	return "";
-};
 /**
-* One turn. A conversation that ends with an assistant message calls no
-* model: its source is checked and compiled again. Otherwise the model's
-* reply is compiled at each committed line, edits are applied to the last
-* checked source, and errors get up to `maxRepairs` repair rounds.
+* A turn that starts from a document and asks nothing: its source is
+* checked and compiled again, with no model call.
 */
-async function* runSession(deps, messages, options, call) {
+function* restoreTurn(checker, catalogVersion, content, fresh) {
+	const restored = splitPragma(content);
+	const compiled = checker.compile(restored.body);
+	const diagnostics = [...versionDiagnostics(restored.versions, catalogVersion), ...belowPrefix(compiled.diagnostics, restored.versions === null ? pragmaLine(catalogVersion) : content.slice(0, content.length - restored.body.length))];
+	yield {
+		diagnostics,
+		fresh,
+		program: compiled.program,
+		revision: 1,
+		type: "program"
+	};
+	yield {
+		diagnostics,
+		revision: 1,
+		source: restored.versions === null ? withPragma(restored.body, catalogVersion) : content,
+		type: "done"
+	};
+}
+/**
+* One turn. A document with a conversation that does not end with an ask
+* calls no model: its source is checked and compiled again. Otherwise the
+* model's reply is compiled at each committed line, edits are applied to
+* the document (or to an empty one, for a new UI), and errors get up to
+* `maxRepairs` repair rounds.
+*
+* In a session turn, every model call sees the current UI in its last user
+* message (`withDocument`), and each round's reply goes into the
+* conversation as written. A chat repair shows no document: its assistant
+* turns hold the checked source its repair texts are numbered by.
+*/
+async function* runSession(deps, turn, options, call) {
 	const catalogVersion = deps.host.components.version;
 	/**
 	* Diagnostics as the browser sees them: spans in the sent source, which
@@ -89,41 +155,31 @@ async function* runSession(deps, messages, options, call) {
 	const placement = deps.kind === "session" ? "document" : "chat";
 	/** Whether a round already asked for the design changes `designRepair` names. */
 	let designRepaired = false;
-	const last = messages.at(-1);
-	if (last?.role === "assistant") {
-		const restored = splitPragma(last.content);
-		const compiled = compile(restored.body);
-		const diagnostics = [...versionDiagnostics(restored.versions, catalogVersion), ...restored.versions === null ? belowPragma(compiled.diagnostics) : belowPrefix(compiled.diagnostics, last.content.slice(0, last.content.length - restored.body.length))];
-		yield {
-			diagnostics,
-			fresh: deps.kind === "session",
-			program: compiled.program,
-			revision: 1,
-			type: "program"
-		};
-		yield {
-			diagnostics,
-			revision: 1,
-			source: restored.versions === null ? withPragma(restored.body, catalogVersion) : last.content,
-			type: "done"
-		};
-		return;
-	}
-	if (deps.model === void 0) {
-		yield {
-			error: {
-				code: "INTERNAL",
-				message: "This server has no model."
-			},
-			type: "error"
-		};
+	const { messages } = turn;
+	if (turn.document !== null && !asksModel(messages)) {
+		yield* restoreTurn(deps.checker, catalogVersion, turn.document, true);
 		return;
 	}
 	const conversation = messages.map((message) => message.role === "assistant" ? {
 		content: splitPragma(message.content).body,
 		role: "assistant"
 	} : message);
-	let current = lastAssistantBody(messages);
+	/** The UI the turn edits; empty for a new one. */
+	let current = turn.document === null ? "" : splitPragma(turn.document).body;
+	/** Whether model calls show `current`: from the start with a document, after the first round without. */
+	let showsDocument = deps.kind === "session" && turn.document !== null;
+	/**
+	* The conversation as `model` gets it, a copy the turn does not grow:
+	* the last user message framed with `current` when the call shows it.
+	*/
+	const request = () => {
+		const ask = conversation.at(-1);
+		if (!showsDocument || ask?.role !== "user") return [...conversation];
+		return [...conversation.slice(0, -1), {
+			content: withDocument(ask.content, current),
+			role: "user"
+		}];
+	};
 	let revision = 0;
 	/**
 	* Whether the next program starts a new UI: the first one of a session
@@ -166,7 +222,7 @@ async function* runSession(deps, messages, options, call) {
 			const iterator = deps.model({
 				ctx: call.ctx,
 				kind: kindOf(round),
-				messages: conversation,
+				messages: request(),
 				options,
 				signal: call.signal,
 				system: deps.system,
@@ -219,6 +275,8 @@ async function* runSession(deps, messages, options, call) {
 				iterator.return?.();
 			}
 			if (call.signal.aborted) return;
+			/** The reply as the model wrote it, without a fence around it. */
+			const written = cleanReply(text);
 			let source;
 			let edits;
 			if (isEditReply(text) === true) {
@@ -237,7 +295,7 @@ async function* runSession(deps, messages, options, call) {
 					if (round < deps.maxRepairs) {
 						editFailures++;
 						conversation.push({
-							content: text,
+							content: written,
 							role: "assistant"
 						}, {
 							content: editFailures === 1 ? editRepairText(applied, current) : fullDocumentText(applied, current),
@@ -256,7 +314,7 @@ async function* runSession(deps, messages, options, call) {
 					return;
 				}
 				source = applied.text;
-			} else source = cleanReply(text);
+			} else source = written;
 			let compiled = compile(source);
 			const reordered = reorderDeclarations(source, compiled, compile);
 			if (reordered !== null) {
@@ -289,14 +347,18 @@ async function* runSession(deps, messages, options, call) {
 			const chosen = designRepaired ? [] : advice.filter((entry) => deps.designRepair.has(entry.code));
 			if ((needsRepair(compiled.diagnostics) || chosen.length > 0) && round < deps.maxRepairs) {
 				designRepaired ||= chosen.length > 0;
-				conversation.push({
+				conversation.push(deps.kind === "session" ? {
+					content: written,
+					role: "assistant"
+				} : {
 					content: source,
 					role: "assistant"
 				}, {
-					content: repairText(compiled.diagnostics, chosen),
+					content: repairText(compiled.diagnostics, chosen, deps.kind === "session" ? "shown" : "answer"),
 					role: "user"
 				});
 				current = source;
+				showsDocument = deps.kind === "session";
 				repairs++;
 				continue;
 			}
@@ -306,6 +368,7 @@ async function* runSession(deps, messages, options, call) {
 			shown("done");
 			yield {
 				diagnostics: finalDiagnostics,
+				reply: round === 0 && reordered === null ? written : source,
 				revision,
 				source: finalSource,
 				type: "done"
@@ -334,6 +397,7 @@ async function* runSession(deps, messages, options, call) {
 				completed: finalSource !== null,
 				ctx: call.ctx,
 				diagnostics: finalDiagnostics,
+				document: turn.document,
 				firstProgramMs,
 				kind: deps.kind,
 				messages,
@@ -349,4 +413,4 @@ async function* runSession(deps, messages, options, call) {
 	}
 }
 //#endregion
-export { MAX_CONTENT, applyChecked, editResult, messagesSchema, runSession };
+export { MAX_CONTENT, applyChecked, asksModel, editResult, parseSessionInput, restoreTurn, runSession };