@happyvertical/smrt-planner 0.57.6 → 0.57.7

package/dist/assistant/transport.js

@@ -1,4 +1,7 @@
+import { ASSISTANT_QUESTION_KIND, matchAssistantQuestionText, validateAssistantQuestionAnswer, } from '@happyvertical/smrt-chat/svelte';
+import { resolveRuntimeReportTimeRange } from '@happyvertical/smrt-reports/spec';
 import { createSliceController, } from "../planner/commands/index.js";
+import { sourceFollowUp, whichSourceQuestion, } from "../reports/intent.js";
 import { buildResponseSchema, describeChange, parseChange, } from "./change.js";
 import { buildMatchIndex, matchText } from "./match.js";
 import { buildSystemPrompt, REPORTS_RECIPE, } from "./prompt.js";
@@ -37,8 +40,128 @@ function runCommands(controller, calls) {
 }
 /** Said when a turn changed nothing and the model's sentence was not a question. */
 export const NOTHING_CHANGED = 'Nothing in the app changed.';
-/** Said after a report request: the planner cannot build one yet (smrt#4100). */
-export const REPORTS_PENDING = 'Building the report itself is not available in the planner yet; it will live under Reports.';
+/** Said after a report request where this planner has no sample data to report on. */
+export const REPORTS_UNAVAILABLE = 'Building a report needs the planner app and its sample records; it will live under Reports.';
+/** The tool call a report preview rides on, as smrt-chat names it. */
+export const REPORT_DEFINE_TOOL = 'reports.runtime.define';
+/** A report follow-up as smrt-chat's structured question (a form in the dock). */
+export function reportQuestion(followUp, id) {
+    return {
+        kind: ASSISTANT_QUESTION_KIND,
+        id,
+        prompt: followUp.prompt,
+        fields: [
+            {
+                name: followUp.field,
+                label: followUp.label,
+                type: 'choice',
+                options: followUp.options.map(({ value, label, keywords }) => ({
+                    value,
+                    label,
+                    ...(keywords ? { keywords } : {}),
+                })),
+                default: followUp.default,
+                required: true,
+            },
+        ],
+    };
+}
+/** Merge a follow-up pick or a model's partial answer into a pending intent. */
+function mergeIntent(base, patch) {
+    const out = { ...base };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value === undefined)
+            delete out[key];
+        else
+            out[key] = value;
+    }
+    return out;
+}
+/** Words that are filler, or time words the report reads itself. */
+const ANSWER_FILLER = new Set([
+    'a',
+    'an',
+    'and',
+    'the',
+    'by',
+    'per',
+    'of',
+    'in',
+    'on',
+    'for',
+    'to',
+    'with',
+    'please',
+    'use',
+    'i',
+    'want',
+    'it',
+    'its',
+    'group',
+    'grouped',
+    'show',
+    'me',
+    'just',
+    'ok',
+    'okay',
+    'yes',
+    'that',
+    'one',
+    'option',
+    'last',
+    'this',
+    'past',
+    'previous',
+    'current',
+    'day',
+    'week',
+    'month',
+    'quarter',
+    'year',
+    'today',
+    'yesterday',
+    'ytd',
+    'date',
+    'time',
+]);
+const answerWords = (text) => text
+    .toLowerCase()
+    .replace(/([a-z])([A-Z])/g, '$1 $2')
+    .split(/[^a-z0-9]+/)
+    .filter(Boolean)
+    .map((w) => (w.length > 3 && w.endsWith('s') ? w.slice(0, -1) : w));
+/**
+ * A typed reply that answers the pending question and says nothing else
+ * ("the date month", "status", "status last month"): every word is an
+ * option's word, filler, or a time word the report reads itself. Anything
+ * more ("invoices over $500", "add invoicing") goes to the model with the
+ * pending question in its prompt, so nothing the person said is dropped.
+ */
+function directAnswer(followUp, question, text) {
+    const values = matchAssistantQuestionText(question, text);
+    if (!values)
+        return undefined;
+    const known = new Set(followUp.options.flatMap((o) => answerWords([o.label, o.value, ...(o.keywords ?? [])].join(' '))));
+    // A number counts only when it is part of a period the time parser read
+    // ("last 90 days", "Q3", "2025"); "over 500" is a threshold for the model.
+    const period = resolveRuntimeReportTimeRange(text, new Date()) !== null;
+    const extra = answerWords(text).filter((w) => !known.has(w) &&
+        !ANSWER_FILLER.has(w) &&
+        !(period && (/^\d+$/.test(w) || /^q[1-4]$/.test(w))));
+    if (extra.length)
+        return undefined;
+    const chosen = values[followUp.field];
+    const value = Array.isArray(chosen) ? chosen[0] : chosen;
+    return followUp.options.find((o) => o.value === value);
+}
+const sameFollowUp = (a, b) => a.field === b.field &&
+    a.prompt === b.prompt &&
+    a.options.map((o) => o.value).join('|') ===
+        b.options.map((o) => o.value).join('|');
+/** What the chat says under a report preview. */
+export function reportPreviewText(title, rows) {
+    return `Here is a preview of ${title} (${rows} ${rows === 1 ? 'row' : 'rows'}). Approve it to save it under Saved reports.`;
+}
 /** The Reports menu entry (reports.runtime's RuntimeReport). */
 const REPORTS_ITEM = 'item:reports:RuntimeReport';
 /**
@@ -106,6 +229,79 @@ export function createBrowserAssistantTransport(options) {
     const messages = [];
     const seen = new Map();
     let controller = null;
+    /**
+     * The report follow-up waiting for an answer: the intent so far, the
+     * question asked (its options from the source descriptor), and the words
+     * of the original request (their time words still count).
+     */
+    let pending = null;
+    let questions = 0;
+    /**
+     * `reports.runtime.define` (preview) then `run`, by code. A follow-up the
+     * intent still needs becomes a form (and the pending question); asking the
+     * identical question twice is never done: the sensible default is taken
+     * and the reply says so.
+     */
+    async function buildReport(reports, intent, text, previous) {
+        const defined = await reports.define(intent, text);
+        if (defined.ok) {
+            pending = null;
+            // Reports must be on to keep the report; turning it on is a command
+            // like any other, so the reply says it ran.
+            const added = options.store.ids.includes(REPORTS_RECIPE)
+                ? []
+                : applyRecipes(planner, { add: [REPORTS_RECIPE], remove: [] }).added;
+            return {
+                added,
+                ref: {
+                    name: REPORT_DEFINE_TOOL,
+                    phase: 'preview',
+                    result: defined.proposal,
+                },
+                text: reportPreviewText(defined.proposal.spec.title, defined.proposal.preview.rowCount),
+            };
+        }
+        const followUp = defined.followUp;
+        if (!followUp) {
+            pending = null;
+            return { added: [], text: defined.question };
+        }
+        if (previous && sameFollowUp(previous, followUp)) {
+            const pick = followUp.options.find((o) => o.value === followUp.default);
+            if (pick) {
+                const next = await buildReport(reports, mergeIntent(intent, pick.apply), text, followUp);
+                return { ...next, text: `I went with ${pick.label}. ${next.text}` };
+            }
+        }
+        const question = reportQuestion(followUp, `report-${++questions}`);
+        pending = { intent, followUp, question, text };
+        return { added: [], ref: question, text: followUp.prompt };
+    }
+    /** The option a form submission or a typed answer picked. */
+    function pickedOption(followUp, values) {
+        const chosen = values[followUp.field];
+        const value = Array.isArray(chosen) ? chosen[0] : chosen;
+        return followUp.options.find((o) => o.value === value);
+    }
+    /** Continue a pending report with a picked option, with no model turn. */
+    async function answerPending(reports, option, reply = '') {
+        const current = pending;
+        if (!current)
+            return { content: '' };
+        const built = await buildReport(reports, mergeIntent(current.intent, option.apply), `${current.text} ${reply}`.trim(), current.followUp);
+        const content = [
+            describeChange({ added: built.added, removed: [], kept: [] }, options.recipes),
+            built.text,
+        ]
+            .filter(Boolean)
+            .join(' ');
+        if (content)
+            options.onReply?.(content);
+        return { content, refs: built.ref };
+    }
+    const reportsHost = () => options.recipes.some((r) => r.id === REPORTS_RECIPE)
+        ? (options.reports?.() ?? null)
+        : null;
     const push = (role, content, clientRequestId, toolCallData) => {
         const message = {
             id: id('m'),
@@ -133,6 +329,16 @@ export function createBrowserAssistantTransport(options) {
     });
     const greeting = push('assistant', GREETING);
     async function turn(text) {
+        // A typed answer to the pending report question resolves against its
+        // options in code: no model turn, and "the date month" means the date by
+        // month whatever the model would have made of it.
+        const pendingReports = pending ? reportsHost() : null;
+        if (pending && pendingReports) {
+            const option = directAnswer(pending.followUp, pending.question, text);
+            // The reply's own time words ("status last month") still count.
+            if (option)
+                return answerPending(pendingReports, option, text);
+        }
         const model = options.model();
         if (!model) {
             return {
@@ -155,15 +361,25 @@ export function createBrowserAssistantTransport(options) {
             }));
             const matches = matchText(index, text);
             const menu = options.menu?.() ?? [];
+            // `reports.runtime.sources`: what a report may cover in this app.
+            const reports = reportsHost();
+            const reportSources = reports?.sources() ?? [];
+            const asked = pending;
             const raw = await model.message(text, {
                 history: [
                     {
                         role: 'system',
-                        content: buildSystemPrompt(options.recipes, options.store.ids, cookbooks, options.settings?.read(), matches, options.theme ? { current: options.theme.read() } : undefined, menu),
+                        content: buildSystemPrompt(options.recipes, options.store.ids, cookbooks, options.settings?.read(), matches, options.theme ? { current: options.theme.read() } : undefined, menu, reportSources.map(({ id, label }) => ({ id, label })), asked
+                            ? {
+                                source: asked.intent.source,
+                                prompt: asked.followUp.prompt,
+                                options: asked.followUp.options.map((o) => o.label),
+                            }
+                            : undefined),
                     },
                     ...prior,
                 ],
-                responseSchema: buildResponseSchema(options.recipes, cookbooks, !!options.settings, !!options.theme, menu.map((section) => section.id)),
+                responseSchema: buildResponseSchema(options.recipes, cookbooks, !!options.settings, !!options.theme, menu.map((section) => section.id), reportSources.map((source) => source.id)),
                 temperature: 0,
                 maxTokens: MAX_REPLY_TOKENS,
                 signal: controller.signal,
@@ -173,7 +389,16 @@ export function createBrowserAssistantTransport(options) {
                     ? options.acceptCommands()
                     : options.acceptCommands,
                 sections: menu.map((section) => section.id),
+                reports: reportSources.length > 0,
             });
+            // A report turn is driven by code, not by the model's other choices: a
+            // report is never a recipe to add or a section to open ("sales report"
+            // must not land in the product catalogue). Settings and theme still apply.
+            if (change.report) {
+                change.add = [];
+                change.remove = [];
+                delete change.open;
+            }
             const applied = applyRecipes(planner, change);
             const settingsText = options.settings && hasKeys(change.settings)
                 ? runSummary(planner, 'set_settings', change.settings)
@@ -199,7 +424,49 @@ export function createBrowserAssistantTransport(options) {
                 ? change.open
                 : undefined;
             const openText = open ? openSection(planner, open, menu) : '';
-            const summary = [
+            // `reports.runtime.define` (preview) then `reports.runtime.run`, by code
+            // (`buildReport`). An answer to a pending follow-up merges into its
+            // intent; a turn that answers nothing takes the sensible default rather
+            // than asking the same question again.
+            let reportText = '';
+            let reportRef;
+            let reportIntent = null;
+            let reportWords = text;
+            if (asked && change.report) {
+                reportIntent = mergeIntent(asked.intent, change.report);
+                reportWords = `${asked.text} ${text}`;
+            }
+            else if (change.report) {
+                reportIntent = change.report;
+            }
+            const didOther = applied.added.length > 0 ||
+                applied.removed.length > 0 ||
+                !!settingsText ||
+                !!themed?.summary ||
+                !!commandText ||
+                !!openText ||
+                !!change.cookbook;
+            if (reports && reportIntent) {
+                const built = await buildReport(reports, reportIntent, reportWords, asked?.followUp ?? null);
+                applied.added.push(...built.added);
+                reportText = built.text;
+                reportRef = built.ref;
+            }
+            else if (reports && asked && !didOther) {
+                // A second miss: never the identical question again.
+                const pick = asked.followUp.options.find((o) => o.value === asked.followUp.default);
+                if (pick) {
+                    const built = await buildReport(reports, mergeIntent(asked.intent, pick.apply), asked.text, asked.followUp);
+                    applied.added.push(...built.added);
+                    reportText = `I went with ${pick.label}. ${built.text}`;
+                    reportRef = built.ref;
+                }
+            }
+            else if (asked) {
+                // The person moved on to something else.
+                pending = null;
+            }
+            const ran = [
                 describeChange(applied, options.recipes),
                 settingsText,
                 themed?.summary ?? '',
@@ -208,6 +475,30 @@ export function createBrowserAssistantTransport(options) {
             ]
                 .filter(Boolean)
                 .join(' ');
+            // The model adding Reports is a report request too, whatever the words.
+            const askedForReport = reportRequest || applied.added.includes(REPORTS_RECIPE);
+            if (askedForReport &&
+                !change.report &&
+                !asked &&
+                !openText &&
+                !applied.removed.length) {
+                // Asked for a report but named nothing to build (adding Reports alone
+                // builds nothing): ask which records, never guess, or say this planner
+                // cannot build one. Going to the Reports section needs no question.
+                const followUp = reports ? sourceFollowUp(reportSources) : null;
+                if (followUp) {
+                    const question = reportQuestion(followUp, `report-${++questions}`);
+                    pending = { intent: { source: '' }, followUp, question, text };
+                    reportText = followUp.prompt;
+                    reportRef = question;
+                }
+                else {
+                    reportText = reports
+                        ? whichSourceQuestion(reportSources)
+                        : REPORTS_UNAVAILABLE;
+                }
+            }
+            const summary = [ran, reportText].filter(Boolean).join(' ');
             // Backstop: a small model sometimes misses a plain "I run a bakery".
             // A strong cookbook match is offered anyway (never applied without the
             // click) when the model offered none and none is applied or pending.
@@ -224,16 +515,13 @@ export function createBrowserAssistantTransport(options) {
                 ? cookbooks.find((c) => c.id === cookbookId)
                 : undefined;
             const line = change.reply || (offered ? `Set up ${offered.name}?` : '');
-            const reply = [
-                honestReply(line, summary, !!offer),
-                reportRequest ? REPORTS_PENDING : '',
-            ]
-                .filter(Boolean)
-                .join(' ');
+            const reply = honestReply(line, summary, !!offer);
             if (reply)
                 options.onReply?.(reply);
-            // One ref renders as is; a cookbook offer and a theme Undo in one turn ride together.
-            const refs = offer && undo ? [offer, undo] : (offer ?? undo);
+            // One ref renders as is; several in one turn (a cookbook offer, a theme
+            // Undo, a report preview) ride together.
+            const all = [offer, undo, reportRef].filter(Boolean);
+            const refs = all.length > 1 ? all : all[0];
             return { content: reply, refs };
         }
         catch (error) {
@@ -270,6 +558,61 @@ export function createBrowserAssistantTransport(options) {
             seen.set(input.clientRequestId, result);
             return result;
         },
+        /**
+         * The report follow-up's form, submitted: its pick merges into the
+         * pending intent and the flow continues (preview, then confirmation) with
+         * no model turn. The question is marked answered for the transcript.
+         */
+        async answerQuestion(input) {
+            const cached = seen.get(input.clientRequestId);
+            if (cached)
+                return cached;
+            const reports = reportsHost();
+            if (!pending || !reports || pending.question.id !== input.questionId) {
+                throw new Error('That question is no longer open. Ask again?');
+            }
+            const values = validateAssistantQuestionAnswer(pending.question, input.values);
+            const option = values
+                ? pickedOption(pending.followUp, values)
+                : undefined;
+            if (!values || !option)
+                throw new Error('Choose one of the options.');
+            const asked = messages.find((m) => m.id === input.messageId);
+            if (asked) {
+                const mark = (ref) => {
+                    const item = ref;
+                    return item?.kind === ASSISTANT_QUESTION_KIND &&
+                        item.id === input.questionId
+                        ? { ...item, answer: values }
+                        : ref;
+                };
+                asked.toolCallData = Array.isArray(asked.toolCallData)
+                    ? asked.toolCallData.map(mark)
+                    : mark(asked.toolCallData);
+            }
+            const reply = await answerPending(reports, option);
+            const result = {
+                inProgress: false,
+                ...(asked ? { messages: [asked] } : {}),
+                assistantMessage: push('assistant', reply.content, undefined, reply.refs),
+            };
+            seen.set(input.clientRequestId, result);
+            return result;
+        },
+        recordReportOutcome(specHash, outcome) {
+            for (const message of messages) {
+                const refs = Array.isArray(message.toolCallData)
+                    ? message.toolCallData
+                    : [message.toolCallData];
+                for (const ref of refs) {
+                    const item = ref;
+                    if (item?.name === REPORT_DEFINE_TOOL &&
+                        item.result?.specHash === specHash) {
+                        item.outcome = outcome;
+                    }
+                }
+            }
+        },
         async uploadAttachment(file) {
             throw new Error(`The assistant cannot take attachments (${file.name}).`);
         },