@aistrike-dev/ui-shell-dev 1.1.0 → 2.0.1

package/platform/assistant/mock.js

@@ -1,3 +1,217 @@
+import { createHash, randomUUID } from "node:crypto";
+//#region src/mock/conversations.ts
+/** `cnv_` and a UUID's 32 hex digits (agent conversations API 3, ids). */
+var newConversationId = () => `cnv_${randomUUID().replace(/-/g, "")}`;
+/** The mock's conversations, by id, in memory: at most `limit` (default 100). */
+function createConversations(limit = 100, newId = newConversationId) {
+	const byId = /* @__PURE__ */ new Map();
+	return {
+		get: (id) => byId.get(id),
+		create(scope) {
+			const now = (/* @__PURE__ */ new Date()).toISOString();
+			const conversation = {
+				id: newId(),
+				scope,
+				createdAt: now,
+				updatedAt: now,
+				busy: false,
+				user: null,
+				context: null,
+				pending: null
+			};
+			byId.set(conversation.id, conversation);
+			while (byId.size > limit) {
+				const oldest = byId.keys().next().value;
+				if (oldest === void 0) break;
+				byId.delete(oldest);
+			}
+			return conversation;
+		}
+	};
+}
+//#endregion
+//#region ../../packages/sdk/dist/assistant/refs.js
+/** The name the model sees: `<domain>__<name>`. */
+function qualifyTool(domain, name) {
+	return `${domain}__${name}`;
+}
+/** The domain and tool a qualified name points at, or `null`. */
+function splitToolName(qualified) {
+	const at = qualified.indexOf("__");
+	if (at <= 0 || at + 2 >= qualified.length) return null;
+	return {
+		domain: qualified.slice(0, at),
+		name: qualified.slice(at + 2)
+	};
+}
+//#endregion
+//#region ../../packages/sdk/dist/context/markup.js
+var isEscapable = (char) => char === "\\" || char === "[" || char === "]";
+var WHITESPACE = /\s/;
+/**
+* Reads a label up to its closing `]` from `start` (just after `[`). Returns the label and the index after the `]`, or
+* `null` for an unescaped `[`, a bad escape or no closing bracket.
+*/
+function readLabel(text, start) {
+	let label = "";
+	for (let i = start; i < text.length; i += 1) {
+		const char = text[i];
+		if (char === "]") return {
+			label,
+			next: i + 1
+		};
+		if (char === "[") return null;
+		if (char === "\\") {
+			if (!isEscapable(text[i + 1] ?? "")) return null;
+			i += 1;
+			label += text[i];
+		} else label += char;
+	}
+	return null;
+}
+/** Reads `(ref)` from `start`: a ref with no whitespace. Returns it and the index after the `)`, or `null`. */
+function readRef(text, start) {
+	if (text[start] !== "(") return null;
+	const close = text.indexOf(")", start + 1);
+	if (close < 0) return null;
+	const ref = text.slice(start + 1, close);
+	return ref === "" || WHITESPACE.test(ref) ? null : {
+		ref,
+		next: close + 1
+	};
+}
+/** Reads `[label](ref)` from `start`, which is at the `[`. */
+function readLink(text, start) {
+	const label = readLabel(text, start + 1);
+	if (label === null || label.label === "") return null;
+	const ref = readRef(text, label.next);
+	return ref === null ? null : {
+		segment: {
+			kind: "ref",
+			label: label.label,
+			ref: ref.ref
+		},
+		next: ref.next
+	};
+}
+/** Reads the token at `start`: an escaped character, a link or a plain character; `null` where it is malformed. */
+function readToken(text, start) {
+	const char = text[start];
+	if (char === "[") return readLink(text, start);
+	if (char === "]") return null;
+	if (char !== "\\") return {
+		segment: {
+			kind: "text",
+			text: char
+		},
+		next: start + 1
+	};
+	const escaped = text[start + 1] ?? "";
+	return isEscapable(escaped) ? {
+		segment: {
+			kind: "text",
+			text: escaped
+		},
+		next: start + 2
+	} : null;
+}
+/**
+* Splits text with `[label](ref)` markup into text and ref segments. `\` escapes the next `\`, `[` or `]`; any other
+* use of a bracket or backslash is malformed, and so is an empty label or ref. `null` for malformed markup.
+*/
+function tokenizeMarkup(text) {
+	const segments = [];
+	let i = 0;
+	while (i < text.length) {
+		const token = readToken(text, i);
+		if (token === null) return null;
+		const last = segments.at(-1);
+		if (token.segment.kind === "text" && last?.kind === "text") last.text += token.segment.text;
+		else segments.push(token.segment);
+		i = token.next;
+	}
+	return segments;
+}
+/** The text with each link replaced by its label and escapes removed. Malformed text is returned as is. */
+function stripMarkup(text) {
+	const segments = tokenizeMarkup(text);
+	if (segments === null) return text;
+	return segments.map((segment) => segment.kind === "text" ? segment.text : segment.label).join("");
+}
+//#endregion
+//#region src/chat/modes.ts
+/**
+* The mode a round acts in. A chosen mode is final. In Auto the model's report stands, except that more than one
+* change always gets a plan, and a change the model called a question gets one too.
+*/
+function actingFor(chosen, reported, changes) {
+	if (chosen !== "auto") return chosen;
+	if (changes === 0) return reported ?? "ask";
+	return reported === "agent" && changes === 1 ? "agent" : "plan";
+}
+//#endregion
+//#region src/mock/seed.ts
+var idOf = (input) => typeof input.id === "string" ? input.id : "";
+var SEED_TOOLS = [
+	{
+		domainId: "lab",
+		name: "get_alert",
+		description: "Look up one alert by its id",
+		effect: "read",
+		run(input, refs) {
+			const id = idOf(input);
+			const ref = refs.find((candidate) => candidate.domain === "lab" && candidate.type === "alert" && candidate.id === id);
+			return {
+				id,
+				title: ref?.label ?? `Alert ${id}`,
+				summary: ref?.summary ?? "No details in the mock"
+			};
+		}
+	},
+	{
+		domainId: "lab",
+		name: "search_alerts",
+		description: "Find alerts whose title or entity matches a query",
+		effect: "read",
+		run(input) {
+			return {
+				query: typeof input.query === "string" ? input.query : "",
+				entities: []
+			};
+		}
+	},
+	{
+		domainId: "lab",
+		name: "suppress_alert",
+		description: "Suppress one alert so it stops raising notifications",
+		effect: "write",
+		run(input) {
+			return {
+				id: idOf(input),
+				suppressed: true
+			};
+		}
+	}
+];
+var SEED_PROMPTS = [{
+	domainId: "lab",
+	id: "find-credential",
+	text: "Find alerts about credential dumping",
+	expects: [{
+		tool: "search_alerts",
+		input: { query: "credential dumping" }
+	}]
+}];
+var SEED_SKILLS = [{
+	id: "triage-alert",
+	title: "Triage an alert",
+	description: "Weigh an alert's evidence and say what to do with it"
+}, {
+	id: "summarise-investigation",
+	title: "Summarise an investigation",
+	description: "What is known, what is open, and what is next"
+}];
+//#endregion
 //#region src/mock/responder.ts
 var counter = 0;
 var nextId = () => {
@@ -6,40 +220,55 @@ var nextId = () => {
 };
 var words = (text) => text.split(/(\s+)/).filter((word) => word !== "");
 /** Text as a handful of deltas, the way a model streams it. */
-function say(text) {
+function speak(text) {
 	const parts = words(text);
 	const out = [];
 	for (let i = 0; i < parts.length; i += 6) out.push({
 		type: "text",
 		delta: parts.slice(i, i + 6).join("")
 	});
-	return [...out, {
-		type: "done",
-		stop: "end"
-	}];
+	return out;
+}
+var say = (text) => [...speak(text), {
+	type: "done",
+	stop: "end"
+}];
+var humanize = (name) => {
+	const spaced = (splitToolName(name)?.name ?? name).replace(/_/g, " ");
+	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
+};
+/** Its seeded tools, then the page's, each found by its domain and name. */
+function toolsOf(context) {
+	const seeded = SEED_TOOLS.map((seed) => {
+		return {
+			kind: "seed",
+			domainId: seed.domainId,
+			name: seed.name,
+			effect: seed.effect,
+			seed
+		};
+	});
+	const page = (context?.pageTools ?? []).filter((tool) => typeof tool.name === "string" && typeof tool.domainId === "string").map((tool) => {
+		const effect = tool.effect === "read" ? "read" : "write";
+		return {
+			kind: "page",
+			domainId: tool.domainId,
+			name: tool.name,
+			effect,
+			schema: tool.input
+		};
+	});
+	return [...seeded, ...page];
 }
+var find = (tools, domainId, name) => tools.find((tool) => tool.domainId === domainId && tool.name === name);
+var qualified = (tool) => qualifyTool(tool.domainId, tool.name);
 var call = (tool, input) => {
 	return {
-		type: "tool_use",
 		id: nextId(),
 		tool,
 		input
 	};
 };
-var humanize = (qualified) => {
-	const spaced = (qualified.split("__")[1] ?? qualified).replace(/_/g, " ");
-	return spaced.charAt(0).toUpperCase() + spaced.slice(1);
-};
-function lastUser(messages) {
-	for (let i = messages.length - 1; i >= 0; i -= 1) {
-		const message = messages[i];
-		if (message.role === "user") return {
-			message,
-			index: i
-		};
-	}
-	return null;
-}
 var VERBS = /* @__PURE__ */ new Set([
 	"select",
 	"show",
@@ -49,142 +278,331 @@ var VERBS = /* @__PURE__ */ new Set([
 ]);
 /** Entities on screen that the request describes by a word in their label or summary; all of them if none match. */
 function described(text, screen) {
+	if (screen === null) return [];
 	const terms = text.toLowerCase().split(/\W+/).filter((word) => word.length > 3 && !VERBS.has(word));
 	const hits = screen.entities.filter((ref) => terms.some((term) => `${ref.label} ${ref.summary ?? ""}`.toLowerCase().includes(term)));
 	return hits.length > 0 ? hits : screen.entities;
 }
-function describeScreen(user, tools) {
-	const can = tools.length === 0 ? "nothing yet" : tools.map((tool) => humanize(tool.name)).join(", ");
-	if (user.screen === void 0) return `Nothing on screen is shared with me right now. Reference something with @, or ask me to use one of: ${can}.`;
-	const { title, summary, entities } = user.screen;
-	const lead = `You're looking at ${title}${summary === void 0 ? "" : ` (${summary})`}, with ${entities.length} item(s) in view.`;
-	const top = entities.slice(0, 3).map((ref) => ref.label).join("; ");
-	return `${lead}${top === "" ? "" : ` First up: ${top}.`}\n\nHere I can: ${can}.`;
-}
-var toolRound = (calls, acting, reason) => {
-	return {
-		events: [...calls, {
-			type: "done",
-			stop: "tool_use"
-		}],
-		acting,
-		reason
-	};
-};
 /** Entities on screen the text names by a word in their label or summary; none if it names none. */
 function named(text, screen) {
-	if (screen === void 0) return [];
 	const all = described(text, screen);
-	return all.length === screen.entities.length && all.length > 1 ? [] : all;
+	return screen !== null && all.length === screen.entities.length && all.length > 1 ? [] : all;
+}
+/** A list of calls, as the mode would act on them: one change done, more planned, reads looked up. */
+function acting(calls, reads) {
+	const changes = calls.filter((c) => c.tool.effect !== "read").length;
+	if (changes === 0) return {
+		calls,
+		acting: "ask",
+		reason: reads
+	};
+	return changes === 1 ? {
+		calls,
+		acting: "agent",
+		reason: "one change, nothing to assume"
+	} : {
+		calls,
+		acting: "plan",
+		reason: "more than one change, so a plan first"
+	};
 }
 /** "Suppress a4", "suppress the cluster": the write tool once for each alert meant. */
-function suppressing(user, names) {
-	const tool = names.find((name) => name.includes("__suppress_"));
+function suppressing(user, context, tools) {
+	const tool = tools.find((candidate) => candidate.name.startsWith("suppress_"));
 	if (!/suppress/i.test(user.text) || tool === void 0) return null;
-	const id = /\b([a-z]\d+)\b/i.exec(user.text)?.[1];
-	const fromText = id === void 0 ? named(user.text, user.screen).map((r) => r.id) : [id];
+	const inText = [...user.text.matchAll(/\b([a-z]\d+)\b/gi)].map((match) => match[1]);
+	const fromText = inText.length > 0 ? inText : named(user.text, context.screen).map((ref) => ref.id);
 	const ids = user.refs.length > 0 ? user.refs.map((ref) => ref.id) : fromText;
-	if (ids.length === 0) return null;
-	return ids.length === 1 ? toolRound([call(tool, { id: ids[0] })], "agent", "one change, nothing to assume") : toolRound(ids.map((one) => call(tool, { id: one })), "plan", "more than one change, so a plan first");
+	return ids.length === 0 ? null : acting(ids.map((id) => call(tool, { id })), "nothing to change");
 }
 /** "Select the cluster": the page's select tool on the referenced entities, or the ones on screen the text describes. */
-function selecting(user, names) {
-	const tool = names.find((name) => name.includes("__select_"));
+function selecting(user, context, tools) {
+	const tool = tools.find((candidate) => candidate.name.startsWith("select_"));
 	if (!/\b(select|show me|highlight)\b/i.test(user.text) || tool === void 0) return null;
-	const onScreen = user.screen === void 0 ? [] : described(user.text, user.screen);
-	return toolRound([call(tool, { ids: (user.refs.length > 0 ? user.refs : onScreen).map((ref) => ref.id) })], "agent", "it only changes what you see");
+	return {
+		calls: [call(tool, { ids: (user.refs.length > 0 ? user.refs : described(user.text, context.screen)).map((ref) => ref.id) })],
+		acting: "agent",
+		reason: "it only changes what you see"
+	};
 }
 /** A reference: each one looked up with its domain's `get_<type>` tool. */
-function lookingUp(user, names) {
+function lookingUp(user, tools) {
 	const lookups = user.refs.flatMap((ref) => {
-		const tool = `${ref.domain}__get_${ref.type.replace(/-/g, "_")}`;
-		return names.includes(tool) ? [call(tool, { id: ref.id })] : [];
+		const tool = find(tools, ref.domain, `get_${ref.type.replace(/-/g, "_")}`);
+		return tool === void 0 ? [] : [call(tool, { id: ref.id })];
 	});
-	return lookups.length > 0 ? toolRound(lookups, "ask", "looking it up changes nothing") : null;
+	return lookups.length > 0 ? {
+		calls: lookups,
+		acting: "ask",
+		reason: "looking it up changes nothing"
+	} : null;
 }
 /** The inputs for one expected call: as declared, else built from the refs or the screen (suggestions spec 7). */
-function inputsFor(expected, spec, user) {
+function inputsFor(expected, tool, user, screen) {
 	if (expected.input !== void 0) return [expected.input];
-	const properties = spec.input?.properties ?? {};
-	if ("ids" in properties) {
-		const onScreen = user.screen === void 0 ? [] : described(user.text, user.screen);
-		return [{ ids: (user.refs.length > 0 ? user.refs : onScreen).map((ref) => ref.id) }];
-	}
-	if ("id" in properties) return user.refs.map((ref) => {
+	const properties = tool.kind === "page" ? tool.schema?.properties ?? {} : { id: {} };
+	if ("ids" in properties) return [{ ids: (user.refs.length > 0 ? user.refs : described(user.text, screen)).map((ref) => ref.id) }];
+	if ("id" in properties) return user.refs.length > 0 || tool.kind === "page" ? user.refs.map((ref) => {
 		return { id: ref.id };
-	});
+	}) : [{}];
 	return [{}];
 }
-/** A domain's suggestion: the calls it expects, made as it says, so a demo needs no script (suggestions spec 7). */
-function following(user, tools) {
+/** What the suggestion a message was sent from expects: a seeded prompt's, or a page suggestion's from the context. */
+function expectedBy(user, context) {
 	const from = user.suggestion;
-	if (from?.expects === void 0) return null;
-	const calls = from.expects.flatMap((expected) => {
-		const spec = tools.find((tool) => tool.name === `${from.domainId}__${expected.tool}`);
-		return spec === void 0 ? [] : inputsFor(expected, spec, user).map((input) => {
-			return {
-				spec,
-				input
-			};
-		});
+	if (from === void 0) return [];
+	const source = from.source === "domain" ? SEED_PROMPTS.find((prompt) => prompt.domainId === from.domainId && prompt.id === from.id) : context.suggestions.find((suggestion) => suggestion.domainId === from.domainId && suggestion.id === from.id);
+	return Array.isArray(source?.expects) ? source.expects : [];
+}
+/** A suggestion's expected calls, made as it says, so a demo needs no script (suggestions spec 7). */
+function following(user, context, tools) {
+	const domainId = user.suggestion?.domainId ?? "";
+	const calls = expectedBy(user, context).flatMap((expected) => {
+		const tool = find(tools, domainId, expected.tool);
+		return tool === void 0 ? [] : inputsFor(expected, tool, user, context.screen).map((input) => call(tool, input));
 	});
-	if (calls.length === 0) return null;
-	const changes = calls.filter(({ spec }) => spec.effect !== "read").length;
-	const events = calls.map(({ spec, input }) => call(spec.name, input));
-	if (changes === 0) return toolRound(events, "ask", "following the suggestion changes nothing");
-	return changes === 1 ? toolRound(events, "agent", "one change, nothing to assume") : toolRound(events, "plan", "more than one change, so a plan first");
+	return calls.length === 0 ? null : acting(calls, "following the suggestion changes nothing");
 }
-var CHANGE = /\b(suppress|select|highlight|close|assign|delete|disable)\b/i;
-var ASK_REFUSAL = "Ask mode changes nothing, so I left it as it is. Switch to Auto, Plan or Agent and send it again.";
-function firstRound(user, tools, mode) {
-	const suggested = following(user, tools);
-	if (suggested === null && mode === "ask" && CHANGE.test(user.text)) return say(ASK_REFUSAL);
-	const names = tools.map((tool) => tool.name);
-	const answer = suggested ?? suppressing(user, names) ?? selecting(user, names) ?? lookingUp(user, names) ?? {
-		events: say(describeScreen(user, tools)),
-		acting: "ask",
-		reason: "a question, so nothing changes"
-	};
-	return mode === "auto" ? [{
-		type: "mode",
-		acting: answer.acting,
-		reason: answer.reason
-	}, ...answer.events] : answer.events;
+function describeScreen(user, context, tools) {
+	const asked = stripMarkup(user.text).trim();
+	const echo = asked === "" ? "" : `About "${asked}": `;
+	const names = [...new Set(tools.map((tool) => humanize(tool.name)))];
+	const can = names.length === 0 ? "nothing yet" : names.join(", ");
+	const skills = `Skills: ${SEED_SKILLS.map((skill) => skill.title).join(", ")}.`;
+	if (context.screen === null) return `${echo}Nothing on screen is shared with me right now. ${`Reference something with @, or ask me to use one of: ${can}.`}\n\n${skills}`;
+	const { summary, entities } = context.screen;
+	const title = context.title === "" ? "this page" : context.title;
+	const count = `${entities.length} ${entities.length === 1 ? "item" : "items"}`;
+	const lead = `${echo}You're looking at ${title}${summary === void 0 ? "" : ` (${summary})`}, with ${count} in view.`;
+	const top = entities.slice(0, 3).map((ref) => ref.label).join("; ");
+	return `${lead}${top === "" ? "" : ` First up: ${top}.`}\n\nHere I can: ${can}.\n\n${skills}`;
 }
-/** A tool result as a sentence. */
+/** A call's outcome as a sentence. */
 function sentence(tool, ok, result, error) {
 	if (!ok) return `${humanize(tool)} failed: ${error ?? "unknown error"}.`;
 	const value = result ?? {};
-	if (value.declined === true) return "Understood, I left it alone.";
 	if (tool.includes("__select_")) return `I selected ${typeof value.selected === "number" ? value.selected : 0} on the page.`;
 	if (tool.includes("__suppress_")) return `Done: ${typeof value.id === "string" ? value.id : "it"} is suppressed.`;
 	const facts = Object.entries(value).filter(([, v]) => typeof v === "string" || typeof v === "number" || typeof v === "boolean").slice(0, 7).map(([k, v]) => `${k} ${String(v)}`);
 	return `${typeof value.title === "string" ? value.title : humanize(tool)}: ${facts.join(", ")}.`;
 }
-/** Which tool each call id named, from the assistant messages (as stored, or as the API takes them). */
-function callsIn(messages) {
-	const calls = /* @__PURE__ */ new Map();
-	for (const message of messages) {
-		const blocks = message.role === "assistant" ? message.blocks : [];
-		for (const block of blocks.filter((b) => b.kind === "tool")) {
-			const { id, tool } = block.call ?? {
-				id: block.id,
-				tool: block.tool
+var modeEvent = (mode, acts, reason) => mode === "auto" ? {
+	type: "mode",
+	acting: acts,
+	reason
+} : {
+	type: "mode",
+	acting: acts
+};
+var ASK_REFUSAL = "Ask mode changes nothing, so I left it as it is. Switch to Auto, Plan or Agent and send it again.";
+var CHANGE = /\b(suppress|select|highlight|close|assign|delete|disable)\b/i;
+/**
+* Runs the calls: its own at once, reported as steps, then what they found; the page's asked of the UI, whose results
+* close the turn.
+*/
+function run(calls, refs, conversation) {
+	const out = [];
+	const lines = [];
+	const asked = [];
+	for (const { id, tool, input } of calls) {
+		const name = qualified(tool);
+		if (tool.kind === "seed") {
+			const result = tool.seed.run(input, refs);
+			out.push({
+				type: "step",
+				id,
+				tool: name,
+				input,
+				state: "running"
+			}, {
+				type: "step",
+				id,
+				tool: name,
+				input,
+				state: "done",
+				result
+			});
+			lines.push(sentence(name, true, result, void 0));
+		} else asked.push({
+			type: "page_tool",
+			id,
+			domainId: tool.domainId,
+			name: tool.name,
+			input
+		});
+	}
+	out.push(...speak(lines.join("\n\n")), ...asked);
+	if (asked.length === 0) return [...out, {
+		type: "done",
+		stop: "end"
+	}];
+	conversation.pending = {
+		kind: "page_tool",
+		calls: calls.filter((c) => c.tool.kind === "page").map((c) => {
+			return {
+				id: c.id,
+				tool: qualified(c.tool)
+			};
+		})
+	};
+	return [...out, {
+		type: "done",
+		stop: "page_tool"
+	}];
+}
+/** Holds the calls for the person's approval: each as a step that waits, then the approval itself. */
+function propose(calls, conversation) {
+	const id = nextId();
+	const steps = calls.map((c) => {
+		return {
+			type: "step",
+			id: c.id,
+			tool: qualified(c.tool),
+			input: c.input,
+			state: "awaiting-approval"
+		};
+	});
+	conversation.pending = {
+		kind: "approval",
+		id,
+		calls: calls.map((c) => {
+			return {
+				id: c.id,
+				tool: qualified(c.tool),
+				input: c.input
 			};
-			if (id !== void 0 && tool !== void 0) calls.set(id, tool);
+		})
+	};
+	return [
+		...steps,
+		{
+			type: "approval",
+			id,
+			steps: calls.map((c) => c.id)
+		},
+		{
+			type: "done",
+			stop: "approval"
 		}
+	];
+}
+var QUESTION = "a question, so nothing changes";
+/** The rules after a suggestion's, in order: suppress, select, look up, else describe the screen. */
+function rules(user, context, tools) {
+	return suppressing(user, context, tools) ?? selecting(user, context, tools) ?? lookingUp(user, tools) ?? {
+		text: describeScreen(user, context, tools),
+		acting: "ask",
+		reason: QUESTION
+	};
+}
+/**
+* The mode's say on what the rules decided (plan decision 2): Ask refuses a change in text, Plan holds a write for
+* approval, Agent runs it, and Auto runs one change and plans more than one.
+*/
+function actOn(decided, mode, user, conversation) {
+	if ("text" in decided) return [modeEvent(mode, actingFor(mode, decided.acting, 0), decided.reason), ...say(decided.text)];
+	const changes = decided.calls.filter((c) => c.tool.effect !== "read").length;
+	const acts = actingFor(mode, decided.acting, changes);
+	const head = modeEvent(mode, acts, acts === decided.acting ? decided.reason : "more than one change, so a plan first");
+	if (changes === 0 || acts === "agent") return [head, ...run(decided.calls, user.refs, conversation)];
+	return acts === "plan" ? [head, ...propose(decided.calls, conversation)] : [head, ...say(ASK_REFUSAL)];
+}
+/** A skill chosen by id: the scripted reply names it and echoes the argument, or names it alone for empty text. */
+function useSkill(skill, user, mode) {
+	const title = SEED_SKILLS.find((seeded) => seeded.id === skill.id)?.title ?? skill.id;
+	const argument = user.text.trim();
+	const reply = argument === "" ? `${title}. Nothing more was given, so I used the page as it is.` : `${title}: ${argument}…`;
+	return [modeEvent(mode, actingFor(mode, "ask", 0), QUESTION), ...say(`${reply} This is the mock's scripted reply; it runs no skill.`)];
+}
+/** The first answer to a message: the rules, in order, then the mode's say on what they decided. */
+function answer(request, user, conversation) {
+	const { mode, context } = request;
+	if (user.skill !== void 0) return useSkill(user.skill, user, mode);
+	const tools = toolsOf(context);
+	const suggested = following(user, context, tools);
+	if (suggested === null && mode === "ask" && CHANGE.test(user.text)) return [modeEvent(mode, "ask", QUESTION), ...say(ASK_REFUSAL)];
+	return actOn(suggested ?? rules(user, context, tools), mode, user, conversation);
+}
+function afterPageTools(results, conversation) {
+	const pending = conversation.pending;
+	if (pending?.kind !== "page_tool") return {
+		status: 409,
+		message: "No page tool is waiting in this conversation"
+	};
+	conversation.pending = null;
+	const tools = new Map(pending.calls.map((c) => [c.id, c.tool]));
+	return say(results.map((r) => sentence(tools.get(r.id) ?? "tool", r.ok, r.result, r.error)).join("\n\n"));
+}
+/** Runs the approved calls with the tools offered now; one the page no longer offers fails as the shell would say. */
+function approved(planned, context, conversation) {
+	const tools = toolsOf(context);
+	const calls = [];
+	const missing = [];
+	for (const { id, tool: name, input } of planned) {
+		const parts = splitToolName(name);
+		const tool = parts === null ? void 0 : find(tools, parts.domain, parts.name);
+		if (tool === void 0) missing.push({
+			type: "step",
+			id,
+			tool: name,
+			input,
+			state: "error",
+			error: "Not available here"
+		});
+		else calls.push({
+			id,
+			tool,
+			input: input ?? {}
+		});
 	}
-	return calls;
+	return [...missing, ...run(calls, conversation.user?.refs ?? [], conversation)];
 }
-function afterTools(messages, from) {
-	const recent = messages.slice(from);
-	const calls = callsIn(recent);
-	return say(recent.flatMap((message) => message.role === "tool" ? message.results.map((result) => sentence(calls.get(result.id) ?? "tool", result.ok, result.result, result.error)) : []).join("\n\n"));
+function afterApproval(request, input, conversation) {
+	const pending = conversation.pending;
+	if (pending?.kind !== "approval" || pending.id !== input.id) return {
+		status: 409,
+		message: `No approval ${input.id} is waiting in this conversation`
+	};
+	conversation.pending = null;
+	conversation.context = request.context;
+	if (input.approve) return approved(pending.calls, request.context, conversation);
+	return [...pending.calls.map((c) => {
+		return {
+			type: "step",
+			id: c.id,
+			tool: c.tool,
+			input: c.input,
+			state: "declined"
+		};
+	}), ...say("Understood, I left it alone.")];
 }
-function respond(request) {
-	const found = lastUser(request.messages);
-	if (found === null) return say("Ask me something.");
-	return request.messages.slice(found.index + 1).some((message) => message.role === "tool") ? afterTools(request.messages, found.index + 1) : firstRound(found.message, request.tools, request.mode ?? "auto");
+/**
+* One request of a turn: a message starts the turn afresh, discarding anything it waited on; page tool results and an
+* approval answer what the conversation waits on, and anything else is a 409.
+*/
+function respond(request, conversation) {
+	const { input } = request;
+	if (input.kind === "message") {
+		conversation.user = input;
+		conversation.context = request.context;
+		conversation.pending = null;
+		return answer(request, input, conversation);
+	}
+	return input.kind === "page_tool_results" ? afterPageTools(input.results, conversation) : afterApproval(request, input, conversation);
+}
+/**
+* `GET /api/prompts`: a domain's seeded prompts, without what they expect, which stays on the backend. In Ask, a
+* prompt that expects a write is left out (plan decision 3).
+*/
+function promptsFor(domainId, mode, prompts = SEED_PROMPTS) {
+	const writes = (prompt) => prompt.expects.some((expected) => SEED_TOOLS.some((tool) => tool.domainId === prompt.domainId && tool.name === expected.tool && tool.effect !== "read"));
+	return prompts.filter((prompt) => prompt.domainId === domainId && (mode !== "ask" || !writes(prompt))).map(({ id, text, label }) => {
+		return {
+			id,
+			text,
+			...label === void 0 ? {} : { label }
+		};
+	});
 }
 //#endregion
 //#region src/mock/chatHandler.ts
@@ -197,40 +615,256 @@ async function readBody(req) {
 		return;
 	}
 }
-var isRequest = (value) => typeof value === "object" && value !== null && Array.isArray(value.messages) && Array.isArray(value.tools);
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var MODES = /* @__PURE__ */ new Set([
+	"auto",
+	"ask",
+	"plan",
+	"agent"
+]);
+var isSkillRef = (value) => value === void 0 || isObject(value) && typeof value.id === "string";
+function isInput(value) {
+	if (!isObject(value)) return false;
+	switch (value.kind) {
+		case "message": return typeof value.text === "string" && Array.isArray(value.refs) && isSkillRef(value.skill);
+		case "page_tool_results": return Array.isArray(value.results) && value.results.every((result) => isObject(result) && typeof result.id === "string");
+		case "approval": return typeof value.id === "string" && typeof value.approve === "boolean";
+		default: return false;
+	}
+}
+/** Enough of the context's shape for the responder to read it without throwing. */
+function isContext(value) {
+	if (!isObject(value)) return false;
+	const { route, title, screen, domains, pageTools, suggestions } = value;
+	const screenOk = screen === null || isObject(screen) && Array.isArray(screen.entities) && Array.isArray(screen.selection);
+	return isObject(route) && typeof title === "string" && screenOk && [
+		domains,
+		pageTools,
+		suggestions
+	].every((list) => Array.isArray(list));
+}
+/** `{ tenantIds: [...] }` with at least one id, or `{ all: true }`, and nothing else (authorization standard). */
+function isTenantScope(value) {
+	if (!isObject(value)) return false;
+	const keys = Object.keys(value);
+	if (keys.length === 1 && value.all === true) return true;
+	const ids = value.tenantIds;
+	return keys.length === 1 && Array.isArray(ids) && ids.length > 0 && ids.every((id) => typeof id === "string" && id !== "") && new Set(ids).size === ids.length;
+}
+var isScope = (value) => isObject(value) && typeof value.orgId === "string" && value.orgId !== "" && isTenantScope(value.tenantScope);
+/** The same org and the same tenants, in any order. */
+function sameScope(a, b) {
+	const tenants = (scope) => "all" in scope ? "*" : [...scope.tenantIds].sort().join("\n");
+	return a.orgId === b.orgId && tenants(a.tenantScope) === tenants(b.tenantScope);
+}
+var isRequest = (value) => isScope(value) && isObject(value) && MODES.has(value.mode) && isContext(value.context) && isInput(value.input);
 var pause = async (ms) => new Promise((resolve) => {
 	setTimeout(resolve, ms);
 });
-/** Dev-only `POST /api/chat`: the scripted responder, streamed as server-sent events with a little pacing. */
+function sendJson(res, status, body) {
+	res.statusCode = status;
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify(body));
+}
+/** An error in the API's envelope (agent conversations API 8). */
+function refuse(res, status, id, message) {
+	sendJson(res, status, { errors: [{
+		id,
+		message,
+		referenceId: randomUUID()
+	}] });
+}
+var notFound = (res) => refuse(res, 404, "conversation_not_found", "No such conversation");
+/** A conversation as the API returns it (agent conversations API 5.1). */
+function resourceOf(conversation) {
+	const { pending } = conversation;
+	let waiting = null;
+	if (pending?.kind === "approval") waiting = {
+		kind: "approval",
+		id: pending.id,
+		steps: pending.calls.map((call) => call.id)
+	};
+	else if (pending?.kind === "page_tool") waiting = {
+		kind: "page_tool",
+		calls: pending.calls.map((call) => {
+			const [domainId, name] = call.tool.split("__");
+			return {
+				id: call.id,
+				domainId,
+				name,
+				input: {}
+			};
+		})
+	};
+	return {
+		id: conversation.id,
+		title: null,
+		createdAt: conversation.createdAt,
+		updatedAt: conversation.updatedAt,
+		archivedAt: null,
+		...conversation.scope,
+		waiting
+	};
+}
+/** `POST /api/conversations`: a new conversation in the body's scope. */
+async function create(req, res, conversations) {
+	const body = await readBody(req);
+	if (!isScope(body)) {
+		refuse(res, 400, "invalid_request", "The body must be { orgId, tenantScope }");
+		return;
+	}
+	const conversation = conversations.create({
+		orgId: body.orgId,
+		tenantScope: body.tenantScope
+	});
+	res.setHeader("Location", `/api/conversations/${conversation.id}`);
+	sendJson(res, 201, { data: resourceOf(conversation) });
+}
+/** Why a message's skill is refused (agent conversations API 6.1), or `null`: it must be offered, and comes alone. */
+function skillRefusal(input) {
+	if (input.kind !== "message" || input.skill === void 0) return null;
+	if (input.suggestion !== void 0 || input.markup !== void 0) return "A skill does not come with a suggestion or markup";
+	const { id } = input.skill;
+	return SEED_SKILLS.some((skill) => skill.id === id) ? null : `Unknown skill ${id}`;
+}
+/**
+* `POST /api/conversations/{id}/turns`: one request of a turn, answered with the responder's events, streamed with a
+* little pacing. An unknown id, or one in another scope, is a 404 whatever the input (agent conversations API 4).
+*/
+async function turn(req, res, id, conversations, delayMs) {
+	const body = await readBody(req);
+	if (!isRequest(body)) {
+		refuse(res, 400, "invalid_request", "The body is not a turn request");
+		return;
+	}
+	const conversation = conversations.get(id);
+	if (conversation === void 0 || !sameScope(conversation.scope, body)) {
+		notFound(res);
+		return;
+	}
+	const refusal = skillRefusal(body.input);
+	if (refusal !== null) {
+		refuse(res, 400, "invalid_request", refusal);
+		return;
+	}
+	if (conversation.busy) {
+		refuse(res, 409, "turn_in_progress", "A turn is in progress on this conversation");
+		return;
+	}
+	const answer = respond(body, conversation);
+	if (!Array.isArray(answer)) {
+		refuse(res, answer.status, "not_waiting", answer.message);
+		return;
+	}
+	conversation.busy = true;
+	conversation.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+	res.on("close", () => {
+		conversation.busy = false;
+	});
+	res.statusCode = 200;
+	res.setHeader("Content-Type", "text/event-stream");
+	res.setHeader("Cache-Control", "no-cache");
+	let seq = 0;
+	for (const event of answer) {
+		if (res.destroyed) break;
+		const { type, ...data } = event;
+		seq += 1;
+		res.write(`id: ${seq}\nevent: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
+		await pause(delayMs);
+	}
+	conversation.busy = false;
+	res.end();
+}
+/** `GET /api/prompts?domain=&mode=`: the domain's seeded prompts in the mode. */
+function prompts(url, res) {
+	const domain = url.searchParams.get("domain");
+	const mode = url.searchParams.get("mode");
+	if (domain === null || !MODES.has(mode)) {
+		refuse(res, 400, "invalid_request", "domain and a known mode are required");
+		return;
+	}
+	sendJson(res, 200, { data: { prompts: promptsFor(domain, mode) } });
+}
+var SKILLS_LIMIT = 50;
+/** A page position as an opaque cursor, and back; `null` when the cursor is not one this handler issued. */
+var cursorOf = (index) => Buffer.from(String(index)).toString("base64url");
+function indexOf(cursor) {
+	const index = Number(Buffer.from(cursor, "base64url").toString("utf8"));
+	return Number.isInteger(index) && index >= 0 && cursorOf(index) === cursor ? index : null;
+}
+/** The page size asked for: a whole number from 1 to the maximum, 50 if none; `null` otherwise. */
+function limitOf(raw) {
+	if (raw === null) return SKILLS_LIMIT;
+	const limit = /^\d+$/.test(raw) ? Number(raw) : 0;
+	return limit >= 1 && limit <= SKILLS_LIMIT ? limit : null;
+}
+/** `GET /api/skills?limit=&cursor=`: the seeded skills, paged, with an `ETag` (agent conversations API 5.8). */
+function skills(url, req, res) {
+	const limit = limitOf(url.searchParams.get("limit"));
+	const cursor = url.searchParams.get("cursor");
+	const start = cursor === null ? 0 : indexOf(cursor);
+	if (limit === null || start === null) {
+		refuse(res, 400, "invalid_request", `limit is 1 to ${SKILLS_LIMIT}; cursor is one this API issued`);
+		return;
+	}
+	const end = start + limit;
+	const hasMore = end < SEED_SKILLS.length;
+	const data = SEED_SKILLS.slice(start, end).map(({ id, title, description }) => {
+		return {
+			id,
+			title,
+			description
+		};
+	});
+	const body = JSON.stringify({
+		data,
+		nextCursor: hasMore ? cursorOf(end) : null,
+		hasMore
+	});
+	const etag = `"${createHash("sha256").update(body).digest("hex").slice(0, 32)}"`;
+	res.setHeader("ETag", etag);
+	if (req.headers["if-none-match"] === etag) {
+		res.statusCode = 304;
+		res.end();
+		return;
+	}
+	res.statusCode = 200;
+	res.setHeader("Content-Type", "application/json");
+	res.end(body);
+}
+var TURNS = /^\/api\/conversations\/([^/]+)\/turns$/;
+/**
+* The dev-only agent backend (assistant endpoints design, decision 23), speaking the agent conversations API:
+* `POST /api/conversations`, `POST /api/conversations/{id}/turns`, `GET /api/prompts` and `GET /api/skills`. Each handler keeps its own
+* conversations, in memory.
+*/
 function createChatHandler(options = {}) {
 	const delayMs = options.delayMs ?? 40;
+	const conversations = options.conversations ?? createConversations();
+	const failed = (res) => () => {
+		if (!res.headersSent) refuse(res, 500, "internal_error", "The mock failed");
+		else res.end();
+	};
 	return (req, res) => {
-		if ((req.url ?? "").split("?")[0] !== "/api/chat") return false;
-		if (req.method !== "POST") {
-			res.statusCode = 405;
-			res.end();
-			return true;
-		}
-		readBody(req).then(async (body) => {
-			if (!isRequest(body)) {
-				res.statusCode = 400;
-				res.end();
-				return;
-			}
-			res.statusCode = 200;
-			res.setHeader("Content-Type", "text/event-stream");
-			res.setHeader("Cache-Control", "no-cache");
-			for (const event of respond(body)) {
-				const { type, ...data } = event;
-				res.write(`event: ${type}\ndata: ${JSON.stringify(data)}\n\n`);
-				await pause(delayMs);
+		const url = new URL(req.url ?? "/", "http://mock.invalid");
+		const only = (method, then) => {
+			if (req.method === method) then();
+			else {
+				res.setHeader("Allow", method);
+				refuse(res, 405, "method_not_allowed", `Only ${method}`);
 			}
-			res.end();
-		}).catch(() => {
-			res.statusCode = 500;
-			res.end();
+			return true;
+		};
+		if (url.pathname === "/api/prompts") return only("GET", () => prompts(url, res));
+		if (url.pathname === "/api/skills") return only("GET", () => skills(url, req, res));
+		if (url.pathname === "/api/conversations") return only("POST", () => {
+			create(req, res, conversations).catch(failed(res));
+		});
+		const match = TURNS.exec(url.pathname);
+		if (match === null) return false;
+		return only("POST", () => {
+			turn(req, res, decodeURIComponent(match[1]), conversations, delayMs).catch(failed(res));
 		});
-		return true;
 	};
 }
 //#endregion