@mccaskie-labs/workbench-ai 0.3.0 → 0.4.0

package/dist/replies.js

@@ -0,0 +1,482 @@
+// The reply drafter (docs/capabilities/04-reply-drafter.md): structured facts
+// plus a reply guide in, a ready-to-paste reply out. The one firm rule: facts
+// come from data, words from the AI. The model places each fact as a token
+// ({{packages.0.price}}); this file fills the tokens with workbench-country's
+// formatter and then checks the finished text, so a price or date the model
+// typed itself fails the draft. All of that is plain code, so it runs the same
+// under createFakeAi.
+import { COUNTRY_PACKS, formatDate, formatMoney, formatNumber } from "@mccaskie-labs/workbench-country";
+import { z } from "zod";
+import { WorkbenchAiError } from "./errors.js";
+import { cachedBlocks } from "./helpers.js";
+import { checkWriting, SPELLING_NAMES, VOICE_NAMES, writingStops } from "./writing.js";
+/** The version of the drafter's own instructions, sent as the prompt version with the guide's. */
+export const REPLY_PROMPT_VERSION = "2026-11-13";
+export const REPLY_LANGUAGES = ["en", "tl", "taglish"];
+// ---------------------------------------------------------------- the guide
+const GUIDE_NAME = /^[a-z][a-z0-9-]{0,39}$/;
+const FACT_NAME = /^[a-z][a-z0-9_]{0,39}$/;
+const CURRENCY = /^[A-Z]{3}$/;
+const DEFAULT_MAX_WORDS = 90;
+const DEFAULT_MAX_QUESTIONS = 2;
+/** Checks a guide's JSON and returns it typed, or throws an Error naming every problem. */
+export function checkGuide(value, where = "guide") {
+    const problems = [];
+    const g = value;
+    if (!g || typeof g !== "object" || Array.isArray(g))
+        throw new Error(`${where}: not a JSON object`);
+    const known = new Set(["$schema", "format", "name", "version", "voice", "spelling", "country", "model", "max_words", "max_questions", "facts", "ask_order", "guide", "examples", "never"]);
+    for (const k of Object.keys(g))
+        if (!known.has(k))
+            problems.push(`${k} isn't a guide setting`);
+    if (g.format !== 1)
+        problems.push("format must be 1");
+    if (typeof g.name !== "string" || !GUIDE_NAME.test(g.name))
+        problems.push("name must be lower case letters, digits and dashes, starting with a letter");
+    if (!Number.isInteger(g.version) || g.version < 1)
+        problems.push("version must be a whole number from 1");
+    if (g.voice !== undefined && !VOICE_NAMES.includes(g.voice))
+        problems.push(`voice must be one of ${VOICE_NAMES.join(", ")}`);
+    if (g.spelling !== undefined && !SPELLING_NAMES.includes(g.spelling))
+        problems.push(`spelling must be one of ${SPELLING_NAMES.join(", ")}`);
+    if (g.country !== undefined && !(typeof g.country === "string" && COUNTRY_PACKS[g.country]))
+        problems.push(`country must be one of ${Object.keys(COUNTRY_PACKS).join(", ")}`);
+    if (g.model !== undefined && (typeof g.model !== "string" || !/^[a-z][a-z0-9.-]*$/.test(g.model)))
+        problems.push("model must be a Workbench alias such as claude-default");
+    if (g.max_words !== undefined && (!Number.isInteger(g.max_words) || g.max_words < 10 || g.max_words > 400))
+        problems.push("max_words must be a whole number from 10 to 400");
+    if (g.max_questions !== undefined && (!Number.isInteger(g.max_questions) || g.max_questions < 0 || g.max_questions > 5))
+        problems.push("max_questions must be a whole number from 0 to 5");
+    const f = g.facts;
+    if (!f || typeof f !== "object" || f.type !== "object" || !f.properties || typeof f.properties !== "object") {
+        problems.push('facts must be { "type": "object", "properties": { ... } }');
+    }
+    else {
+        for (const [name, s] of Object.entries(f.properties)) {
+            if (!FACT_NAME.test(name))
+                problems.push(`facts.${name}: a fact's name is lower case letters, digits and underscores`);
+            if (name === "link")
+                problems.push("facts.link: link is kept for the short link; give the fact another name");
+            checkFact(s, `facts.${name}`, 0, problems);
+        }
+        for (const r of f.required ?? [])
+            if (!Object.hasOwn(f.properties, r))
+                problems.push(`facts.required names ${r}, which isn't a fact`);
+    }
+    if (g.ask_order !== undefined && !(Array.isArray(g.ask_order) && g.ask_order.every((x) => typeof x === "string" && x !== "")))
+        problems.push("ask_order must be a list of field names");
+    if (!Array.isArray(g.guide) || g.guide.length === 0 || !g.guide.every((x) => typeof x === "string" && x.trim() !== ""))
+        problems.push("guide must be a list of plain sentences");
+    if (g.never !== undefined && !(Array.isArray(g.never) && g.never.every((x) => typeof x === "string" && x.trim() !== "")))
+        problems.push("never must be a list of plain sentences");
+    if (g.examples !== undefined) {
+        if (!Array.isArray(g.examples))
+            problems.push("examples must be a list");
+        else
+            g.examples.forEach((e, i) => {
+                if (!e || typeof e !== "object" || !REPLY_LANGUAGES.includes(e.language) || typeof e.text !== "string" || e.text.trim() === "") {
+                    problems.push(`examples[${i}] needs language (${REPLY_LANGUAGES.join(", ")}) and text`);
+                }
+            });
+    }
+    if (problems.length)
+        throw new Error(`${where}: ${problems.join("; ")}`);
+    return g;
+}
+function checkFact(s, at, depth, problems) {
+    if (!s || typeof s !== "object") {
+        problems.push(`${at}: not a schema`);
+        return;
+    }
+    const types = ["string", "number", "integer", "boolean", "array", "object"];
+    if (!types.includes(s.type))
+        problems.push(`${at}: type must be one of ${types.join(", ")}`);
+    if (s["x-money"] !== undefined && (!CURRENCY.test(s["x-money"]) || (s.type !== "number" && s.type !== "integer")))
+        problems.push(`${at}: x-money is a currency code (PHP) on a number`);
+    if (s.format !== undefined && (s.format !== "date" || s.type !== "string"))
+        problems.push(`${at}: format may only be date, on a string`);
+    if (s.enum !== undefined && (s.type !== "string" || !Array.isArray(s.enum) || s.enum.length === 0))
+        problems.push(`${at}: enum is a list of strings, on a string`);
+    if (s.type === "array") {
+        if (depth > 0)
+            problems.push(`${at}: lists can't hold lists`);
+        if (!s.items)
+            problems.push(`${at}: a list needs items`);
+        else
+            checkFact(s.items, `${at}.items`, depth + 1, problems);
+    }
+    if (s.type === "object") {
+        if (depth === 0)
+            problems.push(`${at}: a fact can be an object only inside a list (packages: a list of objects)`);
+        if (!s.properties)
+            problems.push(`${at}: an object needs properties`);
+        else
+            for (const [name, p] of Object.entries(s.properties)) {
+                if (!FACT_NAME.test(name))
+                    problems.push(`${at}.${name}: lower case letters, digits and underscores`);
+                if (p.type === "object" || p.type === "array")
+                    problems.push(`${at}.${name}: items in a list are flat`);
+                else
+                    checkFact(p, `${at}.${name}`, depth + 1, problems);
+            }
+    }
+}
+/** The pack that writes the guide's amounts and dates. */
+function packFor(guide) {
+    const fromSpelling = guide.spelling?.split("-")[1];
+    const fromMoney = moneyCodes(guide.facts).map((code) => Object.values(COUNTRY_PACKS).find((p) => p.currency.code === code)?.country)[0];
+    const country = guide.country ?? fromSpelling ?? fromMoney ?? "AU";
+    return COUNTRY_PACKS[country] ?? COUNTRY_PACKS.AU;
+}
+function moneyCodes(s) {
+    const out = [];
+    if (s["x-money"])
+        out.push(s["x-money"]);
+    if (s.items)
+        out.push(...moneyCodes(s.items));
+    for (const p of Object.values(s.properties ?? {}))
+        out.push(...moneyCodes(p));
+    return out;
+}
+const isEmpty = (v) => v === undefined || v === null || (typeof v === "string" && v.trim() === "") || (Array.isArray(v) && v.length === 0);
+function render(value, s, pack) {
+    if (isEmpty(value) || typeof value === "boolean")
+        return undefined;
+    // Money may come as workbench-availability's exact decimal string ("8500.00").
+    if (s["x-money"] && typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value.trim()))
+        value = Number(value);
+    if (typeof value === "number" && (s.type === "number" || s.type === "integer")) {
+        const code = s["x-money"];
+        if (code) {
+            const own = pack.currency.code === code ? pack : (Object.values(COUNTRY_PACKS).find((p) => p.currency.code === code) ?? `${code} `);
+            return { value: formatMoney(value, own), also: [formatNumber(value, pack)] };
+        }
+        return { value: formatNumber(value, pack), also: [String(value)] };
+    }
+    if (typeof value === "string") {
+        if (s.format === "date")
+            return { value: formatDate(value, { pack }, "weekdayDayMonth"), also: [] };
+        return { value, also: [] };
+    }
+    return undefined;
+}
+/** Every token the facts give, with its finished words. Booleans and empty facts give none. */
+export function tokensFor(guide, facts) {
+    const pack = packFor(guide);
+    const out = new Map();
+    const add = (name, fact, r) => {
+        if (r)
+            out.set(name, { name, fact, value: r.value, also: r.also });
+    };
+    for (const [fact, s] of Object.entries(guide.facts.properties)) {
+        const value = facts[fact];
+        if (s.type === "array" && Array.isArray(value) && s.items) {
+            const items = s.items;
+            if (items.type === "object") {
+                value.forEach((item, i) => {
+                    if (!item || typeof item !== "object")
+                        return;
+                    for (const [field, fs] of Object.entries(items.properties ?? {}))
+                        add(`${fact}.${i}.${field}`, fact, render(item[field], fs, pack));
+                });
+            }
+            else {
+                const parts = [];
+                value.forEach((item, i) => {
+                    const r = render(item, items, pack);
+                    add(`${fact}.${i}`, fact, r);
+                    if (r)
+                        parts.push(r.value);
+                });
+                if (parts.length)
+                    add(fact, fact, { value: new Intl.ListFormat("en", { type: "conjunction" }).format(parts), also: [] });
+            }
+        }
+        else {
+            add(fact, fact, render(value, s, pack));
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------- questions and language
+/** The fields the draft asks for: intake's missing and ambiguous fields in the guide's ask_order, none the facts hold, at most max_questions. */
+export function questionsFor(guide, facts, intake) {
+    if (!intake)
+        return [];
+    const order = guide.ask_order ?? [];
+    const wanted = new Set([...intake.missing, ...intake.ambiguous.map((a) => a.field)]);
+    return order.filter((f) => wanted.has(f) && isEmpty(facts[f])).slice(0, guide.max_questions ?? DEFAULT_MAX_QUESTIONS);
+}
+// Small, common words only: enough to tell English, Tagalog and the two mixed.
+const TL_WORDS = new Set("po opo ang ng mga sa na ba pa ko mo kayo namin natin nyo niyo ninyo kami tayo siya sila ito iyan yan yun iyon dito diyan doon ay at kung para hanggang ilan magkano salamat pwede puwede lang din rin naman talaga bukas ngayon mamaya araw gabi umaga hapon wala meron mayroon may gusto sana kasi tapos pero o hindi oo sige nga ho anong ano saan kailan bakit paano sino ilang tao katao bakante pasensya paki pakisabi lahat kasama kami pong nga".split(" "));
+const EN_WORDS = new Set("the a an is are was were be and or but for to of in on at with you your we our us i my me it this that these those what when where how much many can could would will do does have has please thanks thank available price rate rates per day night book booking reserve guests people how's there here from".split(" "));
+/** A rough reading of a short message's language, for `match` when intake gave none, and for the tests' checker. */
+export function guessLanguage(text) {
+    const words = text.toLowerCase().match(/[a-zñ']+/g) ?? [];
+    let tl = 0;
+    let en = 0;
+    for (const w of words) {
+        if (TL_WORDS.has(w))
+            tl++;
+        else if (EN_WORDS.has(w))
+            en++;
+    }
+    if (tl + en < 2)
+        return undefined;
+    const share = tl / (tl + en);
+    if (share >= 0.85)
+        return "tl";
+    if (share <= 0.15)
+        return "en";
+    return "taglish";
+}
+/** The reply's language and whether it had to fall back. */
+export function languageFor(req) {
+    const choice = req.language ?? "match";
+    if (choice !== "match")
+        return { language: choice, unsure: false };
+    const seen = req.incoming?.intake?.languages;
+    if (seen && seen.length) {
+        const tl = seen.includes("tl") || seen.includes("fil");
+        const en = seen.includes("en");
+        if (tl && en)
+            return { language: "taglish", unsure: false };
+        if (tl)
+            return { language: "tl", unsure: false };
+        if (en)
+            return { language: "en", unsure: false };
+    }
+    const guessed = req.incoming ? guessLanguage(req.incoming.text) : undefined;
+    if (guessed)
+        return { language: guessed, unsure: false };
+    return { language: req.fallbackLanguage ?? "en", unsure: req.incoming !== undefined };
+}
+/**
+ * How each language is written. Until the voices' language setting and the
+ * Filipino pack are built (docs/spec.md §2.8), these lines go in the guide's
+ * prompt; they move there when they are.
+ */
+export const LANGUAGE_LINES = {
+    en: "Write in plain English.",
+    tl: "Write in Tagalog (Filipino), as a Filipino small business writes to a customer on Messenger: polite, with po and opo, everyday words, and English only for terms Filipinos normally say in English (day use, overnight, package, reserve).",
+    taglish: "Write in Taglish: Tagalog and English mixed the way Filipino customers and small businesses chat on Messenger, polite, with po and opo. Use English for terms Filipinos normally say in English (day use, overnight, package, reserve).",
+};
+const TOKEN = /\{\{\s*([^{}]*?)\s*\}\}/g;
+const URL_RE = /\b(?:https?:\/\/|www\.)[^\s<>"')]+/gi;
+/** Where a fact couldn't be filled: plain for the person checking to see and fill in. */
+export const GAP = "___";
+/**
+ * Patterns for `never` lines code can see. A line matches a row when it
+ * mentions the row's topic; the text then fails when it matches the row's
+ * pattern. Other lines are in the prompt only.
+ */
+const NEVER_CHECKS = [
+    {
+        topic: /payment|card|bank|gcash|maya|account number/i,
+        text: /\b(card (number|details)|credit card|debit card|cvv|cvc|expiry date|bank (account|details)|account (number|no\.?)|gcash (number|no\.?)|maya (number|no\.?)|payment details|otp|one-time pin)\b/i,
+    },
+    { topic: /discount/i, text: /\b(discount|diskwento|less \d|% off|promo price)\b/i },
+    { topic: /confirm.*book|book.*confirm/i, text: /\b(booking is confirmed|you'?re (all )?booked|confirmed na|naka-?book na|reserved na kayo|we('ve| have) booked)\b/i },
+];
+/** The words "available" in the languages a reply is written in. */
+const AVAILABLE_WORDS = /\b(available|avail|bakante|open pa)\b/i;
+const countWords = (text) => (text.replace(URL_RE, " ").match(/[\p{L}\p{N}₱$][\p{L}\p{N}'’.,₱$-]*/gu) ?? []).length;
+/** Fills the tokens and checks the finished text. Plain code: no AI. */
+export function checkDraft(raw, ctx) {
+    const problems = [];
+    const used = new Set();
+    let linked = false;
+    let text = raw.replace(TOKEN, (_m, name) => {
+        if (name === "link") {
+            if (!ctx.link || linked)
+                return "";
+            linked = true;
+            return ctx.link.url;
+        }
+        const t = ctx.tokens.get(name);
+        if (!t) {
+            problems.push({ reason: "missing_fact", detail: `{{${name}}} isn't one of the facts` });
+            return GAP;
+        }
+        used.add(t.fact);
+        return t.value;
+    });
+    // A stray brace is a token the model broke: never show it raw.
+    if (/\{\{|\}\}/.test(text)) {
+        problems.push({ reason: "missing_fact", detail: "a broken token" });
+        text = text.replace(/\{\{|\}\}/g, GAP);
+    }
+    if (ctx.link && !linked)
+        text = `${text.trimEnd()} ${ctx.link.url}`;
+    text = tidy(text);
+    // Every address must be the link; every number, amount and date one the facts produced.
+    for (const url of text.match(URL_RE) ?? []) {
+        if (!ctx.link || url.replace(/[.,!?]+$/, "") !== ctx.link.url)
+            problems.push({ reason: "unknown_fact", detail: `the address ${url} isn't the link` });
+    }
+    let rest = text.replace(URL_RE, " ");
+    const allowed = [...ctx.tokens.values()].flatMap((t) => [t.value, ...t.also]).filter((s) => s !== "");
+    for (const value of allowed.sort((a, b) => b.length - a.length))
+        rest = rest.split(value).join(" ");
+    for (const m of rest.matchAll(/(?:[₱$€£]\s?)?\d[\d,.:/-]*(?:\s?(?:k|K|am|pm|AM|PM))?/g)) {
+        problems.push({ reason: "unknown_fact", detail: `"${m[0].trim()}" isn't one of the facts` });
+    }
+    const max = ctx.guide.max_words ?? DEFAULT_MAX_WORDS;
+    const words = countWords(text);
+    if (words > max * 2)
+        problems.push({ reason: "too_long", detail: `${words} words, more than twice the ${max} allowed` });
+    for (const line of ctx.guide.never ?? []) {
+        const check = NEVER_CHECKS.find((c) => c.topic.test(line));
+        const hit = check ? check.text.exec(text) : null;
+        if (hit)
+            problems.push({ reason: "never_rule", detail: `"${hit[0]}" breaks "never ${line}"` });
+    }
+    if (ctx.facts["available"] === "no") {
+        const hit = AVAILABLE_WORDS.exec(text);
+        if (hit)
+            problems.push({ reason: "contradicts_fact", detail: `"${hit[0]}", when the date isn't available` });
+        for (const [name, t] of ctx.tokens) {
+            if (/^alternatives\.\d+$/.test(name) && !text.includes(t.value))
+                problems.push({ reason: "missing_fact", detail: `the alternative ${t.value} is left out` });
+        }
+    }
+    for (const s of writingStops(checkWriting(text, { voice: ctx.guide.voice ?? "conversational", paragraphTarget: max * 2 }))) {
+        problems.push({ reason: "writing", detail: s.issue });
+    }
+    return { text, problems, answered: [...used] };
+}
+function tidy(text) {
+    return text
+        .replace(/[ \t]+([,.!?])/g, "$1")
+        .replace(/[ \t]{2,}/g, " ")
+        .replace(/[ \t]+\n/g, "\n")
+        .trim();
+}
+// ---------------------------------------------------------------- the prompt
+const SYSTEM = [
+    "You draft a reply that a business will paste into a chat with a customer. A person reads it and copies it; nothing is sent by you.",
+    "",
+    "Facts. Every price, amount, date, number, package name and link in the reply comes from the facts you are given, never from you. Put each one in as its token, written exactly as listed, such as {{packages.0.price}}. Never type a digit, an amount or a date yourself, and never work one out: no totals, no discounts, no counting of days or people. If a fact you would want isn't listed, leave it out rather than guess.",
+    "",
+    "Questions. Ask only for the fields listed under \"Ask for\", together in one short line, in that order, in plain words (never a field's code name). When the list says nothing, ask for none of the customer's details; you may still end with the guide's invitation.",
+    "",
+    "Link. When the request says there is a link, put {{link}} once where it fits. Otherwise mention no link.",
+    "",
+    "Write only the reply itself, as it will be pasted: no notes, no options, no quotation marks around it, no sign that it was drafted for someone.",
+].join("\n");
+function guideBlock(g) {
+    const lines = [`Reply guide "${g.name}", version ${g.version}.`, "", "How to answer:", ...g.guide.map((l) => `- ${l}`)];
+    if (g.never?.length)
+        lines.push("", "Never:", ...g.never.map((l) => `- ${l}`));
+    lines.push("", `Keep it to about ${g.max_words ?? DEFAULT_MAX_WORDS} words.`);
+    if (g.examples?.length) {
+        lines.push("", "Examples of the wording (tokens stand for facts):");
+        for (const e of g.examples)
+            lines.push(`- (${e.language}) ${e.text}`);
+    }
+    return lines.join("\n");
+}
+function label(field) {
+    return field.replace(/_/g, " ");
+}
+function userPrompt(o) {
+    const out = [`Language: ${LANGUAGE_LINES[o.language]}`];
+    if (o.incoming) {
+        out.push("", "The message being answered:", "<<<", o.incoming.text, ">>>");
+        const intake = o.incoming.intake;
+        if (intake?.data)
+            out.push("", `What was read from it: ${JSON.stringify(intake.data)}`);
+        if (intake?.assumptions?.length)
+            out.push(`Assumed: ${intake.assumptions.map((a) => `${a.field}: ${a.note}`).join("; ")}`);
+    }
+    out.push("", `Facts: ${JSON.stringify(o.facts)}`, "", "Tokens (use these, never the words after the equals sign):");
+    for (const t of o.tokens.values())
+        out.push(`{{${t.name}}} = ${t.value}`);
+    if (o.tokens.size === 0)
+        out.push("(none)");
+    out.push("", `Ask for: ${o.asked.length ? o.asked.map(label).join(", ") : "nothing"}`);
+    out.push(`Link: ${o.link ? "yes, put {{link}} once" : "none"}`);
+    if (o.previous)
+        out.push("", "The earlier draft, to write again:", "<<<", o.previous, ">>>");
+    if (o.note)
+        out.push(`The person asked: ${o.note}`);
+    if (o.fix) {
+        out.push("", "Your last draft failed the checks. It was:", "<<<", o.fix.draft, ">>>", "What was wrong:", ...o.fix.problems.map((p) => `- ${p.detail}`), "Write it again, fixing these. Use tokens for every fact.");
+    }
+    return out.join("\n");
+}
+const DRAFT_SCHEMA = z.object({ text: z.string().describe("The reply, with a token for every fact") });
+/** The drafter: one call, and one more when the check fails. Returns the draft and the token text it was filled from. */
+export async function draftReply(structured, guides, req) {
+    const guide = guides?.[req.guide];
+    if (!guide) {
+        throw new WorkbenchAiError(guides ? "invalid_request" : "invalid_config", guides ? `No reply guide named ${req.guide}: add workbench/replies/${req.guide}.json and run npx workbench-ai replies generate` : "No reply guides: pass replyGuides: REPLY_GUIDES (from src/replies.generated.ts) to createAi");
+    }
+    if (req.link && (typeof req.link.url !== "string" || !/^https:\/\/\S+$/.test(req.link.url)))
+        throw new WorkbenchAiError("invalid_request", "link.url must be an https address");
+    const facts = req.facts;
+    for (const r of guide.facts.required ?? []) {
+        if (isEmpty(facts[r]))
+            throw new WorkbenchAiError("invalid_request", `The facts lack ${r}, which the guide ${guide.name} requires`);
+    }
+    const tokens = tokensFor(guide, facts);
+    const asked = questionsFor(guide, facts, req.incoming?.intake);
+    const { language, unsure } = languageFor(req);
+    const link = req.link ? req.link : false;
+    const call = (fix) => structured({
+        model: guide.model ?? "claude-default",
+        job: `reply.${guide.name}`,
+        promptVersion: `${REPLY_PROMPT_VERSION}+${guide.name}.${guide.version}`,
+        system: cachedBlocks(SYSTEM, guideBlock(guide)),
+        prompt: userPrompt({
+            language,
+            ...(req.incoming ? { incoming: req.incoming } : {}),
+            facts,
+            tokens,
+            asked,
+            link: link !== false,
+            ...(req.note ? { note: req.note } : {}),
+            ...(req.previous ? { previous: req.previous } : {}),
+            ...(fix ? { fix } : {}),
+        }),
+        schema: DRAFT_SCHEMA,
+        maxTokens: 2000,
+        voice: guide.voice ?? "conversational",
+        ...(guide.spelling ? { spelling: guide.spelling } : { spelling: packFor(guide).spelling }),
+        ...(req.subject ? { subject: `${req.subject.type}:${req.subject.id}` } : {}),
+        ...(req.keep !== undefined ? { keep: req.keep } : {}),
+    });
+    const first = await call();
+    let raw = first.data.text;
+    let checked = checkDraft(raw, { guide, facts, tokens, link });
+    let last = first;
+    let cost = first.costUsd;
+    if (checked.problems.length) {
+        const second = await call({ draft: raw, problems: checked.problems });
+        cost += second.costUsd;
+        last = second;
+        raw = second.data.text;
+        checked = checkDraft(raw, { guide, facts, tokens, link });
+    }
+    const reasons = new Set();
+    for (const p of checked.problems)
+        if (p.reason !== "writing")
+            reasons.add(p.reason);
+    const intake = req.incoming?.intake;
+    if (intake?.check_reasons.some((r) => r !== "missing_required"))
+        reasons.add("ambiguous_incoming");
+    if (unsure)
+        reasons.add("language_unsure");
+    const check_reasons = [...reasons];
+    const draft = {
+        text: checked.text,
+        language,
+        asked,
+        answered: checked.answered,
+        needs_human_check: check_reasons.length > 0,
+        check_reasons,
+        ...(link ? { link } : {}),
+        workbench: { request_id: last.requestId, cost_usd: Math.round(cost * 1e6) / 1e6, model: last.model, alias: guide.model ?? "claude-default" },
+    };
+    return { draft, template: raw };
+}

package/dist/reply-ui.d.ts

@@ -0,0 +1,36 @@
+import type { ReplyCheckReason, ReplyDraft } from "./replies.ts";
+export { REPLY_STYLES } from "./styles.ts";
+export type ReplyWordKey = "copy" | "copied" | "selected" | "again" | "note_label" | "note_hint" | "check" | "refused" | "failed" | `reason.${ReplyCheckReason}`;
+/** The box's words in English, Tagalog and Taglish. A project's own strings win (`ui.wbreply.<key>`). */
+export declare const REPLY_WORDS: Readonly<Record<"en" | "tl" | "taglish", Readonly<Record<ReplyWordKey, string>>>>;
+/** The project's strings: `t("ui.wbreply.copy")`. Undefined for a word it lacks (the box's own words are used). */
+export type Words = (key: string) => string | undefined;
+export interface ReplyBoxOptions {
+    /** Where Write it again posts (the project's route that calls ai.reply with `note` and `previous`). Left out: no Write it again. */
+    againAction?: string;
+    /** Fields posted with Write it again, such as the enquiry's id. */
+    hidden?: Readonly<Record<string, string>>;
+    /** The box's own words: `en` (default), `tl` or `taglish`. */
+    language?: "en" | "tl" | "taglish";
+    /** The project's strings, which win over the box's own words. */
+    words?: Words;
+}
+/**
+ * The box for a draft, or for why there is none: pass what `ai.reply` gave, or
+ * the error it threw. A refusal by the content rules or by Claude shows "We
+ * can't draft a reply to this one"; any other error, "Try again".
+ */
+export declare function renderReplyBox(result: ReplyDraft | unknown, opts?: ReplyBoxOptions): string;
+/** What Copy needs from the page: the clipboard (absent or refusing is fine) and a way to select the text. */
+export interface CopyDeps {
+    clipboard?: {
+        writeText(text: string): Promise<void>;
+    } | undefined;
+    select(): void;
+}
+/** Copies exactly `text`; when the Clipboard API is missing or refused, selects it instead. */
+export declare function copyReply(text: string, deps: CopyDeps): Promise<"copied" | "selected">;
+/** Runs on the page: wires every box's Copy button. Stringified into REPLY_SCRIPT, so it uses nothing from outside. */
+export declare function mountReplyBoxes(copy: typeof copyReply): void;
+/** The box's script: put it in the page under its nonce, after the boxes. */
+export declare const REPLY_SCRIPT: string;

package/dist/reply-ui.js

@@ -0,0 +1,146 @@
+// '@mccaskie-labs/workbench-ai/reply-ui': the box a person copies a draft
+// from (docs/capabilities/04-reply-drafter.md). renderReplyBox draws the
+// draft, Copy reply and Write it again; REPLY_SCRIPT (under the page's nonce)
+// makes Copy work with the Clipboard API and, when the browser refuses it,
+// selects the text so the person can copy it themselves. Nothing is ever sent
+// from here: the person pastes the reply.
+//
+// Every element carries a wb-reply-* class (REPLY_STYLES), so a project
+// restyles the box from its own CSS.
+export { REPLY_STYLES } from "./styles.js";
+/** The box's words in English, Tagalog and Taglish. A project's own strings win (`ui.wbreply.<key>`). */
+export const REPLY_WORDS = {
+    en: {
+        copy: "Copy reply",
+        copied: "Copied",
+        selected: "Selected: press copy",
+        again: "Write it again",
+        note_label: "What to change",
+        note_hint: "Make it shorter, don't mention the pool…",
+        check: "Check this one before you send it:",
+        refused: "We can't draft a reply to this one. Please write it yourself.",
+        failed: "The draft didn't come through. Try again in a moment.",
+        "reason.unknown_fact": "it has a price, date or number that isn't from your details",
+        "reason.missing_fact": "something it needed is missing (shown as ___)",
+        "reason.too_long": "it's long",
+        "reason.ambiguous_incoming": "the message was hard to read",
+        "reason.language_unsure": "we weren't sure which language to reply in",
+        "reason.never_rule": "it says something your replies never say",
+        "reason.contradicts_fact": "it may say the date is free when it isn't",
+    },
+    tl: {
+        copy: "Kopyahin ang sagot",
+        copied: "Nakopya na",
+        selected: "Napili na: pindutin ang kopya",
+        again: "Isulat ulit",
+        note_label: "Ano ang babaguhin",
+        note_hint: "Paikliin, huwag banggitin ang pool…",
+        check: "Tingnan muna ito bago ipadala:",
+        refused: "Hindi namin ito masasagot. Pakisulat na lang po ninyo.",
+        failed: "Hindi dumating ang sagot. Subukan ulit mamaya.",
+        "reason.unknown_fact": "may presyo, petsa o numero na wala sa inyong detalye",
+        "reason.missing_fact": "may kulang na detalye (makikita bilang ___)",
+        "reason.too_long": "mahaba ito",
+        "reason.ambiguous_incoming": "mahirap basahin ang mensahe",
+        "reason.language_unsure": "hindi kami sigurado kung anong wika ang gagamitin",
+        "reason.never_rule": "may sinabi itong hindi dapat sabihin",
+        "reason.contradicts_fact": "baka sinasabi nitong bakante ang petsa kahit hindi",
+    },
+    taglish: {
+        copy: "Copy reply",
+        copied: "Copied na",
+        selected: "Naka-select na: pindutin ang copy",
+        again: "Isulat ulit",
+        note_label: "Ano ang babaguhin",
+        note_hint: "Paikliin, huwag i-mention ang pool…",
+        check: "I-check muna ito bago i-send:",
+        refused: "Hindi namin ma-draft ang reply dito. Pakisulat na lang po.",
+        failed: "Hindi dumating ang draft. Try ulit mamaya.",
+        "reason.unknown_fact": "may price, date o number na wala sa details ninyo",
+        "reason.missing_fact": "may kulang na detail (makikita bilang ___)",
+        "reason.too_long": "mahaba ito",
+        "reason.ambiguous_incoming": "mahirap basahin ang message",
+        "reason.language_unsure": "hindi kami sure kung anong language ang gagamitin",
+        "reason.never_rule": "may sinabi itong hindi dapat sabihin",
+        "reason.contradicts_fact": "baka sinasabi nitong available ang date kahit hindi",
+    },
+};
+const esc = (s) => s.replace(/[&<>"']/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" })[c]);
+function wordsFor(o) {
+    const own = REPLY_WORDS[o.language ?? "en"];
+    return (key) => o.words?.(`ui.wbreply.${key.replace(".", "_")}`) ?? own[key];
+}
+const isDraft = (x) => !!x && typeof x === "object" && typeof x.text === "string" && Array.isArray(x.check_reasons);
+/**
+ * The box for a draft, or for why there is none: pass what `ai.reply` gave, or
+ * the error it threw. A refusal by the content rules or by Claude shows "We
+ * can't draft a reply to this one"; any other error, "Try again".
+ */
+export function renderReplyBox(result, opts = {}) {
+    const w = wordsFor(opts);
+    if (!isDraft(result)) {
+        const code = result?.code;
+        const refused = code === "content_refused" || code === "refused";
+        return `<section class="wb-reply" data-wb-reply><p class="wb-reply-error" role="alert">${esc(w(refused ? "refused" : "failed"))}</p></section>`;
+    }
+    const parts = [`<section class="wb-reply" data-wb-reply lang="${result.language === "en" ? "en" : "fil"}">`];
+    if (result.needs_human_check && result.check_reasons.length) {
+        parts.push(`<p class="wb-reply-check" role="note">${esc(w("check"))} ${esc(result.check_reasons.map((r) => w(`reason.${r}`)).join("; "))}.</p>`);
+    }
+    const id = `wbreply-${result.workbench.request_id.replace(/[^A-Za-z0-9_-]/g, "")}`;
+    parts.push(`<textarea class="wb-reply-text" id="${id}" rows="6" spellcheck="true" aria-label="${esc(w("copy"))}">${esc(result.text)}</textarea>`);
+    parts.push(`<div class="wb-reply-actions"><button type="button" class="wb-reply-copy" data-wb-reply-copy aria-controls="${id}">${esc(w("copy"))}</button><span class="wb-reply-status" role="status" aria-live="polite" data-copied="${esc(w("copied"))}" data-selected="${esc(w("selected"))}"></span></div>`);
+    if (opts.againAction) {
+        const hidden = Object.entries(opts.hidden ?? {})
+            .map(([k, v]) => `<input type="hidden" name="${esc(k)}" value="${esc(v)}">`)
+            .join("");
+        parts.push(`<form class="wb-reply-again" method="post" action="${esc(opts.againAction)}">${hidden}<input type="hidden" name="previous" value="${esc(result.text)}"><input class="wb-reply-note" name="note" maxlength="300" aria-label="${esc(w("note_label"))}" placeholder="${esc(w("note_hint"))}"><button type="submit" class="wb-reply-again-button">${esc(w("again"))}</button></form>`);
+    }
+    parts.push("</section>");
+    return parts.join("");
+}
+/** Copies exactly `text`; when the Clipboard API is missing or refused, selects it instead. */
+export async function copyReply(text, deps) {
+    try {
+        if (!deps.clipboard)
+            throw new Error("no clipboard");
+        await deps.clipboard.writeText(text);
+        return "copied";
+    }
+    catch {
+        deps.select();
+        return "selected";
+    }
+}
+/** Runs on the page: wires every box's Copy button. Stringified into REPLY_SCRIPT, so it uses nothing from outside. */
+export function mountReplyBoxes(copy) {
+    for (const box of Array.from(document.querySelectorAll("[data-wb-reply]"))) {
+        const button = box.querySelector("[data-wb-reply-copy]");
+        const area = box.querySelector("textarea");
+        const status = box.querySelector("[role=status]");
+        if (!button || !area || !status)
+            continue;
+        let timer;
+        button.addEventListener("click", () => {
+            void copy(area.value, {
+                clipboard: navigator.clipboard,
+                select: () => {
+                    area.focus();
+                    area.select();
+                    area.setSelectionRange(0, area.value.length);
+                },
+            }).then((how) => {
+                status.textContent = status.dataset[how] ?? "";
+                button.classList.toggle("wb-reply-copied", how === "copied");
+                if (timer)
+                    clearTimeout(timer);
+                timer = setTimeout(() => {
+                    status.textContent = "";
+                    button.classList.remove("wb-reply-copied");
+                }, 4000);
+            });
+        });
+    }
+}
+/** The box's script: put it in the page under its nonce, after the boxes. */
+export const REPLY_SCRIPT = `(${mountReplyBoxes.toString()})(${copyReply.toString()});`;