@jigs.design/server 0.2.0 → 0.3.1

package/dist/model-server.js

@@ -0,0 +1,155 @@
+import { INTERNAL_MESSAGE, JigsError, isJigsError } from "./errors.js";
+import { createHandler, issuesText, parseBounded } from "./handler.js";
+import { MAX_CONTENT, runSession } from "./session.js";
+import { createReplyParser, repairBlock, streamChat } from "./chat.js";
+import { z } from "zod";
+//#region src/model-server.ts
+/**
+* What `jigs.chat` reads from the route besides the request. `blocks` and
+* `prompt` come from the browser, so they are checked like a session's
+* messages.
+*/
+const chatInputSchema = z.object({
+	blocks: z.array(z.object({
+		name: z.string().max(200),
+		source: z.string().max(MAX_CONTENT)
+	})).max(200).optional(),
+	prompt: z.string().max(MAX_CONTENT).optional()
+});
+/** The core with a model: `session`, `chat`, and a handler that runs turns. */
+function createModelServer(internals, core, options) {
+	const system = core.prompt("document");
+	const chatSystem = core.prompt("chat");
+	const maxRepairs = options.maxRepairs ?? 1;
+	const programIntervalMs = options.programIntervalMs ?? 250;
+	const designRepair = new Set(options.designRepair ?? []);
+	/** A session request checked, its options parsed, and a named document resolved for `ctx`. */
+	const prepareSession = async (body, call) => {
+		let turnOptions;
+		if (options.options === void 0) turnOptions = void 0;
+		else {
+			const parsed = options.options.safeParse(body.options ?? {});
+			if (!parsed.success) return { error: {
+				code: "BAD_INPUT",
+				message: `options: ${issuesText(parsed.error)}`
+			} };
+			turnOptions = parsed.data;
+		}
+		const turn = await internals.prepareSession(body, call);
+		return "error" in turn ? turn : {
+			options: turnOptions,
+			turn
+		};
+	};
+	const sessionDeps = {
+		checker: internals.checker,
+		designRepair,
+		host: internals.host,
+		kind: "session",
+		maxRepairs,
+		model: options.model,
+		onError: internals.onError,
+		onTurn: options.onTurn,
+		programIntervalMs,
+		system,
+		systemPrefix: core.promptPrefix("document")
+	};
+	const chat = async (request, chatOptions) => {
+		const refused = internals.handlerDeps.http.refusal(request);
+		if (refused !== null) throw new JigsError(refused.code, refused.message);
+		let ctx;
+		try {
+			ctx = await internals.context(request);
+		} catch (error) {
+			if (isJigsError(error)) throw error;
+			internals.onError(error, { type: "chat" });
+			throw new JigsError("INTERNAL", INTERNAL_MESSAGE);
+		}
+		const input = parseBounded(() => chatInputSchema.safeParse({
+			blocks: chatOptions?.blocks,
+			prompt: chatOptions?.prompt
+		}));
+		if (!input.success) throw new JigsError("BAD_INPUT", input.message);
+		let turnOptions;
+		if (options.options === void 0) turnOptions = void 0;
+		else {
+			const schema = options.options;
+			const parsed = parseBounded(() => schema.safeParse(chatOptions?.options ?? {}));
+			if (!parsed.success) throw new JigsError("BAD_INPUT", `options: ${parsed.message}`);
+			turnOptions = parsed.data;
+		}
+		const turnCall = {
+			ctx,
+			signal: chatOptions?.signal ?? new AbortController().signal
+		};
+		const repairRounds = Math.max(0, maxRepairs - 1);
+		const parser = createReplyParser({
+			catalogVersion: internals.host.components.version,
+			compile: (body) => internals.checker.compile(body),
+			designRepair,
+			now: () => performance.now(),
+			programIntervalMs,
+			repairs: maxRepairs > 0,
+			tags: internals.checker.tags
+		}, input.data.blocks ?? []);
+		const turnDeps = {
+			call: turnCall,
+			options: turnOptions,
+			parser,
+			prompt: input.data.prompt,
+			session: {
+				...sessionDeps,
+				kind: "chat-repair",
+				maxRepairs: repairRounds
+			}
+		};
+		const repair = (block) => repairBlock(turnDeps, block);
+		return {
+			end: parser.end,
+			push: parser.push,
+			repair,
+			results: parser.results,
+			stream: (reply) => streamChat({
+				end: parser.end,
+				push: parser.push,
+				repair
+			}, reply, chatOptions?.signal),
+			system: chatSystem,
+			systemPrefix: core.promptPrefix("chat")
+		};
+	};
+	return {
+		call: core.call,
+		chat,
+		compile: core.compile,
+		data: core.data,
+		events: core.events,
+		frame: core.frame,
+		handler: createHandler({
+			...internals.handlerDeps,
+			session: async (body, call) => {
+				const prepared = await prepareSession(body, call);
+				if ("error" in prepared) return prepared;
+				return { turn: (turnCall) => runSession(sessionDeps, prepared.turn, prepared.options, turnCall) };
+			}
+		}),
+		maxBodyBytes: core.maxBodyBytes,
+		page: core.page,
+		prompt: core.prompt,
+		promptPrefix: core.promptPrefix,
+		async *session(body, context) {
+			const prepared = await prepareSession(body, context);
+			if ("error" in prepared) {
+				yield {
+					error: prepared.error,
+					type: "error"
+				};
+				return;
+			}
+			yield* runSession(sessionDeps, prepared.turn, prepared.options, context);
+		},
+		version: core.version
+	};
+}
+//#endregion
+export { createModelServer };

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 };