@aistrike-dev/ui-shell-dev 1.0.1 → 1.0.3

package/platform/assistant/mock.js

@@ -0,0 +1,246 @@
+//#region src/mock/responder.ts
+var counter = 0;
+var nextId = () => {
+	counter += 1;
+	return `mock-${Date.now().toString(36)}-${counter}`;
+};
+var words = (text) => text.split(/(\s+)/).filter((word) => word !== "");
+/** Text as a handful of deltas, the way a model streams it. */
+function say(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"
+	}];
+}
+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",
+	"highlight",
+	"these",
+	"those"
+]);
+/** 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) {
+	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;
+}
+/** "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_"));
+	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 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");
+}
+/** "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_"));
+	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");
+}
+/** A reference: each one looked up with its domain's `get_<type>` tool. */
+function lookingUp(user, names) {
+	const lookups = user.refs.flatMap((ref) => {
+		const tool = `${ref.domain}__get_${ref.type.replace(/-/g, "_")}`;
+		return names.includes(tool) ? [call(tool, { id: ref.id })] : [];
+	});
+	return lookups.length > 0 ? toolRound(lookups, "ask", "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) {
+	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) => {
+		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) {
+	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 (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");
+}
+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;
+}
+/** A tool result 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
+			};
+			if (id !== void 0 && tool !== void 0) calls.set(id, tool);
+		}
+	}
+	return calls;
+}
+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 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");
+}
+//#endregion
+//#region src/mock/chatHandler.ts
+async function readBody(req) {
+	const chunks = [];
+	for await (const chunk of req) chunks.push(chunk);
+	try {
+		return JSON.parse(Buffer.concat(chunks).toString("utf8"));
+	} catch {
+		return;
+	}
+}
+var isRequest = (value) => typeof value === "object" && value !== null && Array.isArray(value.messages) && Array.isArray(value.tools);
+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 createChatHandler(options = {}) {
+	const delayMs = options.delayMs ?? 40;
+	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);
+			}
+			res.end();
+		}).catch(() => {
+			res.statusCode = 500;
+			res.end();
+		});
+		return true;
+	};
+}
+//#endregion
+//#region src/mock/index.ts
+/**
+* The assistant's dev API, fresh state per call. Its own dev server and the dev host's bundled copy
+* (`@aistrike-dev/ui-shell-dev`, which loads the build of this file) both run it. Never part of the MFE's build.
+*/
+function createMockHandlers() {
+	return [createChatHandler()];
+}
+//#endregion
+export { createMockHandlers };