@simmalugnt-se/payload-editor-assistant 0.3.3 → 0.4.0

package/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## 0.4.0
+
+- A suggestion in the form stays open while the editor writes on, so "shorter" or "another tone"
+  adjusts it instead of keeping it first. The preview shows the adjusted version, **Undo** takes the
+  form back to before the first suggestion, and **Keep** confirms every step in order on the server,
+  each against the form it was made for, so the audit log shows them all. Leaving the form or
+  starting a draft still keeps an open suggestion first.
+- The conversation is kept per document: each document and global has its own thread, and lists and
+  the dashboard share one. Threads are stored in the browser (localStorage) per user, survive a
+  reload, hold the last 50 messages and are forgotten after 30 days; **New chat** clears the current
+  one. A new document's thread becomes the document's own when it is first saved. Switching document
+  stops an unfinished request and closes an open proposal card, which belongs to the other form.
+- While the assistant works, the panel says what it is doing ("Läser formuläret…", "Förbereder
+  ändringen…", "Skriver svaret…") instead of only "Working…". A form proposal goes into the form and
+  Live Preview as soon as it exists, before the reply is written. The chat endpoint answers as NDJSON
+  events when the request asks for `stream: true`; without it, it answers JSON as before. The reply
+  text itself still arrives whole, after the checks it goes through.
+- Everything said in the thread follows the language the editor writes in, including the panel's
+  own messages ("Kept", "Undone", errors). Buttons, headings and hints still follow Admin's language.
+- With a form proposal the model's own short sentence is shown ("Här är en kortare rubrik.") instead
+  of the same fixed line every time. Sentences that say the change is saved, published or kept, or
+  that tell the editor to approve or click, are left out; if nothing is left, the fixed line is used.
+  Draft creation keeps its fixed line, since nothing exists until it is approved.
+- Undo reliably discards the proposals on the server: they are sent one at a time, as a second
+  request at once replaced the CSRF cookie the first one needed.
+- A reply that says it put a change in the form ("har lagt in", "I've put") without making one is
+  retried like other claimed changes.
+
 ## 0.3.3
 
 - A `model` function may return `null` or `undefined`, for example when no API key is set. The drawer

package/README.md

@@ -89,11 +89,13 @@ secrets (`password`, `token`, `apiKey`, ...) are always off limits.
 A proposed form change goes straight into the open form, so the fields and Live Preview show it
 before the editor decides. The changed fields are outlined in blue, and the panel offers **Keep**
 and **Undo**. Undo puts the form back as it was; if the editor typed in the form in the meantime,
-the panel asks first, since undo removes that too. Writing another message keeps the change and
-builds on it ("shorter", "now the summary").
+the panel asks first, since undo removes that too. Writing another message leaves the suggestion
+open, so the editor can adjust it ("shorter", "now the summary too"): the adjusted version replaces
+it in the preview, and Undo still goes back to the form from before the first suggestion. Leaving the
+form or starting a draft keeps an open suggestion first.
 
-Keep is still checked on the server against the form the change was made for, and logged. A
-proposal expires after 30 minutes.
+Keep is still checked on the server against the form the change was made for, and logged; an adjusted
+suggestion is kept step by step, each step against its own form. A proposal expires after 30 minutes.
 
 With autosave (`versions.drafts.autosave`) the draft is saved with the change while it is shown;
 undo saves the draft back. A preview that renders from the saved draft (`RefreshRouteOnSave`)
@@ -110,6 +112,20 @@ clicks in the assistant keep it.
 Preview clicks need `@simmalugnt-se/payload-visual-editing` (0.2.0 or later), which announces them
 with a `visual-editing:select` event. Without it the selection follows the form only.
 
+## While it works
+
+The panel shows what the assistant is doing (reading the form, searching content, preparing a
+change, writing the reply). A proposed form change is put in the form as soon as the assistant has
+made it, before its reply is written; Keep and Undo wait until the turn is over. If a proxy in front
+of Payload buffers responses, the steps arrive all at once at the end, which still works.
+
+## Conversations
+
+Each document and global has its own conversation, and lists and the dashboard share one. They are
+kept in the editor's browser (localStorage), per user: the last 50 messages, for 30 days. Nothing is
+stored in the database, so a conversation does not follow the editor to another browser. **New
+chat** clears the current one.
+
 ## Options
 
 | Option | |

package/dist/components/EditorAssistantAside.js

@@ -3,10 +3,12 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 import { Button, ChevronIcon, useConfig, useLocale, useTranslation, XIcon } from "@payloadcms/ui";
 import { usePathname, useRouter } from "next/navigation";
 import { useEffect, useLayoutEffect, useRef, useState, } from "react";
+import { resolveChatLanguage } from "../runtime/language.js";
 import { parseAdminView } from "../view.js";
-import { assistantRequest } from "./assistant-api.js";
+import { assistantRequest, assistantStream } from "./assistant-api.js";
 import { useAssistantState, } from "./assistant-context.js";
 import { COPY, uiLanguage } from "./copy.js";
+import { isFormProposal, proposalSteps, refineProposal, replaceLatestStep, } from "./proposal-chain.js";
 import { KEEP_SELECTION_ATTR } from "./selection-dom.js";
 export function EditorAssistantAside() {
     const { open, setOpen, status, messages, shortcuts, collections, bridge, formAdapter, pendingApproval, selection, setSelection, resetConversation, setStatus, setMessages, setPendingApproval, stop, setAbortController, } = useAssistantState();
@@ -15,6 +17,9 @@ export function EditorAssistantAside() {
     const locale = useLocale();
     const { i18n } = useTranslation();
     const copy = COPY[uiLanguage(i18n.language)];
+    // What is said in the thread follows the language the editor writes in, like the replies;
+    // the panel's own controls follow Admin.
+    const talk = COPY[resolveChatLanguage(messages.filter((message) => message.role === "user").map((message) => message.text), i18n.language)];
     const pathname = usePathname();
     const view = parseAdminView(pathname ?? "", config.routes.admin);
     const visibleShortcuts = shortcuts.filter((shortcut) => shortcutMatches(shortcut, view));
@@ -23,6 +28,8 @@ export function EditorAssistantAside() {
     /** Whether the editor typed in the form while a preview was in it; undo would discard that. */
     const editedSinceRef = useRef(false);
     const [confirmUndo, setConfirmUndo] = useState(false);
+    /** What the assistant is doing while a turn runs, from the server's step events. */
+    const [step, setStep] = useState(null);
     const stickToBottomRef = useRef(true);
     const apiBase = config.routes.api;
     // Scroll when the thread grows. The values are triggers, not reads.
@@ -62,8 +69,12 @@ export function EditorAssistantAside() {
     const say = (text) => {
         setMessages((current) => [...current, { id: crypto.randomUUID(), role: "assistant", text }]);
     };
-    /** Puts a form proposal into the form so the form and Live Preview show it before it is kept. */
-    const applyPreview = async (pending) => {
+    /**
+     * Puts a form proposal into the form so the form and Live Preview show it before it is kept.
+     * `basis` is the form the proposal was made for. With a suggestion already in the form, the new
+     * one refines it: undo still goes back to the form from before the first.
+     */
+    const applyPreview = async (pending, basis, open) => {
         if (pending.capability !== "form.propose" ||
             !pending.preview ||
             !formAdapter ||
@@ -77,10 +88,19 @@ export function EditorAssistantAside() {
             formAdapter.setModified(true);
         }
         catch {
+            if (open?.applied) {
+                // The earlier suggestion is still what the form shows; the refinement is dropped.
+                void decideRequest(pending, "reject", undefined).catch(() => undefined);
+                say(talk.applyFailed);
+                return open;
+            }
             return pending;
         }
+        if (open?.applied) {
+            return refineProposal(open, pending, basis);
+        }
         editedSinceRef.current = false;
-        return { ...pending, applied: { before, beforeModified: bridge.modified } };
+        return { ...pending, applied: { before, beforeModified: bridge.modified, basis } };
     };
     const restore = async (applied) => {
         if (!formAdapter) {
@@ -92,10 +112,10 @@ export function EditorAssistantAside() {
         // is also what refreshes a preview that renders from the saved draft.
         formAdapter.setModified(autosave || applied.beforeModified);
     };
-    const decideRequest = (pending, action, formData) => assistantRequest(apiBase, "/decide", {
+    const decideRequest = (step, action, formData) => assistantRequest(apiBase, "/decide", {
         action,
-        approvalId: pending.approvalId,
-        nonce: pending.nonce,
+        approvalId: step.approvalId,
+        nonce: step.nonce,
         collection: bridge?.collectionSlug,
         global: bridge?.globalSlug,
         documentId: bridge?.documentId,
@@ -103,8 +123,8 @@ export function EditorAssistantAside() {
         formData,
     });
     /**
-     * Keeps a previewed change. The server checks the proposal against the form it was made for
-     * and logs it; the form already shows the change, so nothing is applied again.
+     * Keeps a previewed change. The server checks each step against the form it was made for and
+     * logs it, oldest first; the form already shows the change, so nothing is applied again.
      */
     const keepPreview = async (pending, quiet = false) => {
         const applied = pending.applied;
@@ -113,14 +133,18 @@ export function EditorAssistantAside() {
         }
         setPendingApproval(null);
         setConfirmUndo(false);
-        const result = await decideRequest(pending, "approve", applied.before).catch(() => null);
-        if (!result?.ok) {
-            await restore(applied).catch(() => undefined);
-            say(copy.keepFailed);
-            return false;
+        const steps = proposalSteps(pending);
+        for (const [index, step] of steps.entries()) {
+            const result = await decideRequest(step, "approve", step.basis).catch(() => null);
+            if (!result?.ok) {
+                await restore(applied).catch(() => undefined);
+                void rejectSteps(steps.slice(index + 1));
+                say(talk.keepFailed);
+                return false;
+            }
         }
         if (!quiet) {
-            say(autosave ? copy.keptAutosave : copy.kept);
+            say(autosave ? talk.keptAutosave : talk.kept);
         }
         return true;
     };
@@ -137,24 +161,33 @@ export function EditorAssistantAside() {
         setConfirmUndo(false);
         try {
             await restore(applied);
-            say(copy.undone);
+            say(talk.undone);
         }
         catch {
-            say(copy.applyFailed);
+            say(talk.applyFailed);
+        }
+        void rejectSteps(proposalSteps(pending));
+    };
+    /**
+     * One at a time: each request fetches a CSRF token and replaces the cookie, so a second request
+     * started alongside would leave the first with a token that no longer matches.
+     */
+    const rejectSteps = async (steps) => {
+        for (const step of steps) {
+            await decideRequest(step, "reject", undefined).catch(() => undefined);
         }
-        void decideRequest(pending, "reject", undefined).catch(() => undefined);
     };
     const send = async (text) => {
         const trimmed = text.trim();
         if (!trimmed || status === "streaming") {
             return;
         }
-        // Writing on is taken as keeping what is in the form; the next change builds on it.
-        if (pendingApproval?.applied && !(await keepPreview(pendingApproval, true))) {
-            return;
-        }
+        // A suggestion in the form stays open while the editor writes on: the next one refines it.
+        const open = pendingApproval?.applied ? pendingApproval : null;
+        const basis = formAdapter?.getData();
         stickToBottomRef.current = true;
         setDraft("");
+        setStep(null);
         const userMessage = { id: crypto.randomUUID(), role: "user", text: trimmed };
         setMessages((current) => [...current, userMessage]);
         const controller = new AbortController();
@@ -165,16 +198,42 @@ export function EditorAssistantAside() {
                 role: message.role,
                 text: message.text,
             }));
-            const result = await assistantRequest(apiBase, "/chat", {
+            // A form proposal arrives before the reply is written and goes into the form right away.
+            // Proposals are applied one after another; a later one in the same turn replaces the earlier.
+            let shown = null;
+            let applying = Promise.resolve();
+            const showProposal = (next) => {
+                applying = applying.then(async () => {
+                    if (shown?.approvalId === next.approvalId || !basis) {
+                        return;
+                    }
+                    shown = shown?.applied
+                        ? await replacePreview(shown, next, basis)
+                        : await applyPreview(next, basis, open);
+                    setPendingApproval(shown);
+                });
+                return applying;
+            };
+            const onEvent = (event) => {
+                if (event.type === "step" && typeof event.step === "string") {
+                    setStep(event.step);
+                }
+                if (event.type === "proposal" && isFormProposal(event.pendingApproval)) {
+                    void showProposal(event.pendingApproval);
+                }
+            };
+            const result = await assistantStream(apiBase, "/chat", {
                 message: trimmed,
                 messages: history,
                 bridge,
                 view,
                 locale: locale.code,
                 uiLanguage: i18n.language,
-                formData: formAdapter?.getData(),
+                formData: basis,
                 selection: selection?.path,
-            }, controller.signal);
+                openProposal: open?.preview ? { changedPaths: open.preview.changedPaths } : undefined,
+            }, onEvent, controller.signal);
+            await applying;
             if (controller.signal.aborted) {
                 setStatus("aborted");
                 return;
@@ -187,22 +246,35 @@ export function EditorAssistantAside() {
                     {
                         id: crypto.randomUUID(),
                         role: "assistant",
-                        text: result.message ?? copy.requestFailed,
+                        text: result.message ?? talk.requestFailed,
                     },
                 ]);
                 return;
             }
             setStatus("idle");
-            if (result.data.pendingApproval) {
-                setPendingApproval(await applyPreview(result.data.pendingApproval));
-            }
             const navigate = result.data.navigate;
+            const next = result.data.pendingApproval;
+            if (isFormProposal(next) && basis) {
+                await showProposal(next);
+            }
+            else {
+                // Leaving the form or starting a draft ends the open suggestion: keep it first, as before.
+                const chain = shown ?? open;
+                if (chain?.applied && (next || (navigate && "href" in navigate))) {
+                    if (!(await keepPreview(chain, true))) {
+                        return;
+                    }
+                }
+                if (next) {
+                    setPendingApproval(next);
+                }
+            }
             setMessages((current) => [
                 ...current,
                 {
                     id: crypto.randomUUID(),
                     role: "assistant",
-                    text: result.data.text ?? copy.done,
+                    text: result.data.text ?? talk.done,
                     candidates: navigate && "candidates" in navigate ? navigate.candidates : undefined,
                 },
             ]);
@@ -215,7 +287,24 @@ export function EditorAssistantAside() {
         }
         finally {
             setAbortController(null);
+            setStep(null);
+        }
+    };
+    /** A second proposal in one turn takes the first one's place in the form and on the server. */
+    const replacePreview = async (current, next, basis) => {
+        if (!formAdapter || !next.preview) {
+            return current;
+        }
+        try {
+            await formAdapter.reset(next.preview.data);
+            formAdapter.setModified(true);
+        }
+        catch {
+            void decideRequest(next, "reject", undefined).catch(() => undefined);
+            return current;
         }
+        void decideRequest(current, "reject", undefined).catch(() => undefined);
+        return replaceLatestStep(current, next, basis);
     };
     const decide = async (action) => {
         if (!pendingApproval || status === "streaming") {
@@ -256,7 +345,7 @@ export function EditorAssistantAside() {
                     {
                         id: crypto.randomUUID(),
                         role: "assistant",
-                        text: result.message ?? copy.proposalFailed,
+                        text: result.message ?? talk.proposalFailed,
                     },
                 ]);
                 return;
@@ -270,8 +359,8 @@ export function EditorAssistantAside() {
                         id: crypto.randomUUID(),
                         role: "assistant",
                         text: pendingApproval.capability === "draft.create"
-                            ? copy.rejectedDraft
-                            : copy.rejectedForm,
+                            ? talk.rejectedDraft
+                            : talk.rejectedForm,
                     },
                 ]);
                 return;
@@ -285,7 +374,7 @@ export function EditorAssistantAside() {
                         {
                             id: crypto.randomUUID(),
                             role: "assistant",
-                            text: copy.applied,
+                            text: talk.applied,
                         },
                     ]);
                 }
@@ -296,7 +385,7 @@ export function EditorAssistantAside() {
                         {
                             id: crypto.randomUUID(),
                             role: "assistant",
-                            text: copy.applyFailed,
+                            text: talk.applyFailed,
                         },
                     ]);
                 }
@@ -311,7 +400,7 @@ export function EditorAssistantAside() {
                     {
                         id: crypto.randomUUID(),
                         role: "assistant",
-                        text: copy.draftCreated,
+                        text: talk.draftCreated,
                     },
                 ]);
                 router.push(href);
@@ -340,11 +429,11 @@ export function EditorAssistantAside() {
     }
     return (_jsxs("aside", { className: "ea-aside", "aria-label": copy.assistant, [KEEP_SELECTION_ATTR]: "", children: [_jsxs("div", { className: "ea-aside__head", children: [_jsxs("div", { className: "ea-aside__title", children: [_jsx("h2", { children: copy.assistant }), bridge ? _jsx("p", { className: "ea-aside__context", children: contextLine(bridge, config) }) : null] }), (messages.length > 0 || pendingApproval) && !pendingApproval?.applied ? (_jsx(Button, { buttonStyle: "subtle", margin: false, onClick: () => resetConversation(), size: "medium", children: copy.newChat })) : null, _jsx(Button, { "aria-label": copy.collapseLabel, buttonStyle: "icon-label", className: "ea-aside__collapse", icon: _jsx(ChevronIcon, { direction: "right" }), margin: false, onClick: () => setOpen(false), tooltip: copy.collapse })] }), _jsxs("div", { className: "ea-aside__body", children: [_jsxs("div", { className: "ea-messages", ref: threadRef, onScroll: onThreadScroll, children: [messages.length === 0 ? (_jsx("div", { className: "ea-msg ea-msg--assistant", children: introText(view, bridge, collections, config, copy) })) : null, messages.map((message) => (_jsxs("div", { className: `ea-msg ea-msg--${message.role}`, children: [message.text, message.candidates?.length ? (_jsx("div", { className: "ea-actions", children: message.candidates.map((candidate) => (_jsx(Button, { buttonStyle: "pill", margin: false, onClick: () => {
                                                 router.push(candidate.href);
-                                            }, size: "small", children: candidate.label }, candidate.href))) })) : null] }, message.id))), status === "streaming" ? (_jsxs("div", { className: "ea-msg ea-msg--working", children: [_jsxs("span", { className: "ea-dots", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", {}), _jsx("span", {})] }), _jsx("span", { children: copy.working })] })) : null] }), pendingApproval ? (_jsxs("div", { className: "ea-approval", children: [_jsx("h3", { children: pendingApproval.title }), pendingApproval.applied ? (_jsx("p", { className: "ea-approval__hint", children: autosave ? copy.previewHintAutosave : copy.previewHint })) : null, _jsx("ul", { className: "ea-approval__diff", children: pendingApproval.summary.split("\n").map((line, index) => line.startsWith("  ") ? (
+                                            }, size: "small", children: candidate.label }, candidate.href))) })) : null] }, message.id))), status === "streaming" ? (_jsxs("div", { className: "ea-msg ea-msg--working", children: [_jsxs("span", { className: "ea-dots", "aria-hidden": "true", children: [_jsx("span", {}), _jsx("span", {}), _jsx("span", {})] }), _jsx("span", { children: step ? talk.steps[step] : talk.working })] })) : null] }), pendingApproval ? (_jsxs("div", { className: "ea-approval", children: [_jsx("h3", { children: pendingApproval.title }), pendingApproval.applied ? (_jsxs("p", { className: "ea-approval__hint", children: [autosave ? copy.previewHintAutosave : copy.previewHint, pendingApproval.earlier?.length ? ` ${copy.refinedHint}` : ""] })) : null, _jsx("ul", { className: "ea-approval__diff", children: pendingApproval.summary.split("\n").map((line, index) => line.startsWith("  ") ? (
                                 // biome-ignore lint/suspicious/noArrayIndexKey: lines are static for one approval
                                 _jsx("li", { className: "ea-approval__sub", children: line.trim() }, index)) : (
                                 // biome-ignore lint/suspicious/noArrayIndexKey: lines are static for one approval
-                                _jsx("li", { children: line }, index))) }), confirmUndo ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "ea-approval__warn", children: copy.undoLosesEdits }), _jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", margin: false, onClick: () => void undoPreview(pendingApproval, true), size: "medium", children: copy.undoAnyway }), _jsx(Button, { buttonStyle: "secondary", margin: false, onClick: () => setConfirmUndo(false), size: "medium", children: copy.cancel })] })] })) : (_jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", margin: false, onClick: () => void decide("approve"), size: "medium", children: pendingApproval.applied ? copy.keep : copy.approve }), _jsx(Button, { buttonStyle: "secondary", margin: false, onClick: () => void decide("reject"), size: "medium", children: pendingApproval.applied ? copy.undo : copy.reject })] }))] })) : null, status !== "idle" && status !== "streaming" ? (_jsx("div", { className: `ea-status ea-status--${status}`, children: statusText(status, copy) })) : null, _jsxs("form", { className: "ea-composer", onSubmit: onSubmit, children: [visibleShortcuts.length > 0 ? (_jsx("div", { className: "ea-shortcuts", children: visibleShortcuts.map((shortcut) => (_jsx(Button, { buttonStyle: "pill", disabled: status === "streaming", margin: false, onClick: () => {
+                                _jsx("li", { children: line }, index))) }), confirmUndo ? (_jsxs(_Fragment, { children: [_jsx("p", { className: "ea-approval__warn", children: copy.undoLosesEdits }), _jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", margin: false, onClick: () => void undoPreview(pendingApproval, true), size: "medium", children: copy.undoAnyway }), _jsx(Button, { buttonStyle: "secondary", margin: false, onClick: () => setConfirmUndo(false), size: "medium", children: copy.cancel })] })] })) : (_jsxs("div", { className: "ea-actions", children: [_jsx(Button, { buttonStyle: "primary", disabled: status === "streaming", margin: false, onClick: () => void decide("approve"), size: "medium", children: pendingApproval.applied ? copy.keep : copy.approve }), _jsx(Button, { buttonStyle: "secondary", disabled: status === "streaming", margin: false, onClick: () => void decide("reject"), size: "medium", children: pendingApproval.applied ? copy.undo : copy.reject })] }))] })) : null, status !== "idle" && status !== "streaming" ? (_jsx("div", { className: `ea-status ea-status--${status}`, children: statusText(status, talk) })) : null, _jsxs("form", { className: "ea-composer", onSubmit: onSubmit, children: [visibleShortcuts.length > 0 ? (_jsx("div", { className: "ea-shortcuts", children: visibleShortcuts.map((shortcut) => (_jsx(Button, { buttonStyle: "pill", disabled: status === "streaming", margin: false, onClick: () => {
                                         void send(shortcut.prompt);
                                     }, size: "small", children: shortcut.label }, shortcut.id))) })) : null, selection && bridge ? (_jsxs("div", { className: "ea-selection", children: [_jsxs("span", { className: "ea-selection__label", children: [copy.selected, ": ", _jsx("strong", { children: selection.label })] }), _jsx("button", { "aria-label": copy.clearSelection, className: "ea-selection__clear", type: "button", onClick: () => setSelection(null), children: _jsx(XIcon, {}) })] })) : null, _jsxs("div", { className: "ea-composer__box", children: [_jsx("textarea", { disabled: status === "streaming", placeholder: copy.placeholder, rows: 2, value: draft, onChange: (event) => setDraft(event.target.value), onKeyDown: onKeyDown }), _jsx("div", { className: "ea-composer__bar", children: status === "streaming" ? (
                                         // While the assistant works, Send becomes Stop, where the editor's eye already is.

package/dist/components/EditorAssistantProvider.js

@@ -7,7 +7,7 @@ import { ChangedFieldsHighlight } from "./ChangedFieldsHighlight.js";
 import { EditorAssistantAside } from "./EditorAssistantAside.js";
 export function EditorAssistantProvider({ children, shortcuts = [], collections = [], }) {
     const { user } = useAuth();
-    return (_jsx(AssistantStateProvider, { shortcuts: shortcuts, collections: collections, children: user ? _jsx(EditorAssistantShell, { children: children }) : children }));
+    return (_jsx(AssistantStateProvider, { shortcuts: shortcuts, collections: collections, userId: user?.id, children: user ? _jsx(EditorAssistantShell, { children: children }) : children }));
 }
 function EditorAssistantShell({ children }) {
     const { open } = useAssistantState();

package/dist/components/assistant-api.d.ts

@@ -7,3 +7,23 @@ export declare function assistantRequest<T>(apiBase: string, path: string, body:
     message?: string;
     status: number;
 }>;
+/**
+ * Like `assistantRequest`, for a turn answered as NDJSON: `onEvent` gets each `step` and `proposal`
+ * event as it arrives, and the result is the final `done` (or `error`) event. A server that answers
+ * with plain JSON instead still works.
+ */
+export declare function assistantStream<T>(apiBase: string, path: string, body: Record<string, unknown>, onEvent: (event: StreamEvent) => void, signal?: AbortSignal): Promise<{
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    error: string;
+    message?: string;
+    status: number;
+}>;
+export type StreamEvent = {
+    type: string;
+    [key: string]: unknown;
+};
+/** Calls `handle` with each JSON object line; chunks may split a line anywhere. */
+export declare function readNdjson(body: ReadableStream<Uint8Array>, handle: (event: StreamEvent) => void): Promise<void>;

package/dist/components/assistant-api.js

@@ -1,5 +1,99 @@
 import { CSRF_HEADER, ENDPOINT_PREFIX } from "../package-name.js";
 export async function assistantRequest(apiBase, path, body, signal) {
+    const response = await post(apiBase, path, body, signal);
+    if (!(response instanceof Response)) {
+        return response;
+    }
+    const payload = (await response.json().catch(() => ({})));
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: payload.error ?? "provider_error",
+            message: payload.message,
+            status: response.status,
+        };
+    }
+    return { ok: true, data: payload };
+}
+/**
+ * Like `assistantRequest`, for a turn answered as NDJSON: `onEvent` gets each `step` and `proposal`
+ * event as it arrives, and the result is the final `done` (or `error`) event. A server that answers
+ * with plain JSON instead still works.
+ */
+export async function assistantStream(apiBase, path, body, onEvent, signal) {
+    const response = await post(apiBase, path, { ...body, stream: true }, signal);
+    if (!(response instanceof Response)) {
+        return response;
+    }
+    const type = response.headers.get("content-type") ?? "";
+    if (!response.ok || !response.body || !type.includes("ndjson")) {
+        const payload = (await response.json().catch(() => ({})));
+        return response.ok
+            ? { ok: true, data: payload }
+            : {
+                ok: false,
+                error: payload.error ?? "provider_error",
+                message: payload.message,
+                status: response.status,
+            };
+    }
+    let final;
+    await readNdjson(response.body, (event) => {
+        if (event.type === "done") {
+            final = { ok: true, data: event.result };
+        }
+        else if (event.type === "error") {
+            final = {
+                ok: false,
+                error: typeof event.error === "string" ? event.error : "provider_error",
+                message: typeof event.message === "string" ? event.message : undefined,
+                status: response.status,
+            };
+        }
+        else {
+            onEvent(event);
+        }
+    });
+    return final ?? { ok: false, error: "provider_error", status: response.status };
+}
+/** Calls `handle` with each JSON object line; chunks may split a line anywhere. */
+export async function readNdjson(body, handle) {
+    const parse = (line) => {
+        if (!line.trim()) {
+            return;
+        }
+        try {
+            const event = JSON.parse(line);
+            if (event && typeof event.type === "string") {
+                handle(event);
+            }
+        }
+        catch {
+            // A line that is not JSON is skipped.
+        }
+    };
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffered = "";
+    for (;;) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        buffered += decoder.decode(value, { stream: true });
+        const lines = buffered.split("\n");
+        buffered = lines.pop() ?? "";
+        for (const line of lines) {
+            parse(line);
+        }
+    }
+    parse(buffered + decoder.decode());
+}
+/**
+ * Posts with a fresh CSRF token. Fetching one replaces the cookie, so requests must not overlap: the
+ * earlier one would carry a token that no longer matches.
+ */
+async function post(apiBase, path, body, signal) {
     const csrfResponse = await fetch(`${apiBase}${ENDPOINT_PREFIX}/csrf`, {
         credentials: "include",
         signal,
@@ -11,7 +105,7 @@ export async function assistantRequest(apiBase, path, body, signal) {
     if (!csrf.token) {
         return { ok: false, error: "unauthorized", status: 401 };
     }
-    const response = await fetch(`${apiBase}${ENDPOINT_PREFIX}${path}`, {
+    return fetch(`${apiBase}${ENDPOINT_PREFIX}${path}`, {
         method: "POST",
         credentials: "include",
         signal,
@@ -21,14 +115,4 @@ export async function assistantRequest(apiBase, path, body, signal) {
         },
         body: JSON.stringify(body),
     });
-    const payload = (await response.json().catch(() => ({})));
-    if (!response.ok) {
-        return {
-            ok: false,
-            error: payload.error ?? "provider_error",
-            message: payload.message,
-            status: response.status,
-        };
-    }
-    return { ok: true, data: payload };
 }

package/dist/components/assistant-context.d.ts

@@ -30,11 +30,21 @@ export type PendingApproval = {
         data: Record<string, unknown>;
         changedPaths: string[];
     };
-    /** Set once the preview is in the form: what to restore on undo. */
+    /**
+     * Set once the preview is in the form: what to restore on undo (the form before the first step)
+     * and `basis`, the form this proposal was made for, which keeping it is checked against.
+     */
     applied?: {
         before: Record<string, unknown>;
         beforeModified: boolean;
+        basis: Record<string, unknown>;
     };
+    /** Earlier proposals this one refines, oldest first; kept or undone together with it. */
+    earlier?: Array<{
+        approvalId: string;
+        nonce: string;
+        basis: Record<string, unknown>;
+    }>;
 };
 export type AssistantMessage = {
     id: string;
@@ -70,10 +80,12 @@ type AssistantContextValue = {
     abortController: AbortController | null;
     setAbortController: (controller: AbortController | null) => void;
 };
-export declare function AssistantStateProvider({ children, shortcuts, collections, }: {
+export declare function AssistantStateProvider({ children, shortcuts, collections, userId, }: {
     children: ReactNode;
     shortcuts: AssistantShortcut[];
     collections: string[];
+    /** Whose conversations the browser keeps; none are kept without a signed-in user. */
+    userId?: string | number;
 }): import("react").JSX.Element;
 export declare function useAssistantState(): AssistantContextValue;
 export {};

package/dist/components/assistant-context.js

@@ -1,8 +1,9 @@
 "use client";
 import { jsx as _jsx } from "react/jsx-runtime";
-import { createContext, useCallback, useContext, useEffect, useMemo, useState, } from "react";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from "react";
+import { carriesOver, conversationKey, readConversation, sameConversation, writeConversation, } from "./conversation-store.js";
 const AssistantContext = createContext(null);
-export function AssistantStateProvider({ children, shortcuts, collections, }) {
+export function AssistantStateProvider({ children, shortcuts, collections, userId, }) {
     const [open, setOpenState] = useState(false);
     const [status, setStatus] = useState("idle");
     const [messages, setMessages] = useState([]);
@@ -20,6 +21,35 @@ export function AssistantStateProvider({ children, shortcuts, collections, }) {
         setOpenState(next);
         storeOpen(next);
     }, []);
+    // One conversation per document: switching documents stores the thread and loads the next one.
+    // An open proposal belongs to the form it was made for, so it does not follow; an unfinished
+    // request is stopped so its answer does not land in another document's thread.
+    const collectionSlug = bridge?.collectionSlug;
+    const globalSlug = bridge?.globalSlug;
+    const documentId = bridge?.documentId;
+    const hasBridge = bridge !== null;
+    const key = useMemo(() => conversationKey(userId, hasBridge ? { collectionSlug, globalSlug, documentId } : null), [userId, hasBridge, collectionSlug, globalSlug, documentId]);
+    const [loadedKey, setLoadedKey] = useState(null);
+    const abortRef = useRef(abortController);
+    abortRef.current = abortController;
+    useEffect(() => {
+        if (!key || sameConversation(key, loadedKey)) {
+            return;
+        }
+        abortRef.current?.abort();
+        setAbortController(null);
+        setStatus("idle");
+        setPendingApproval(null);
+        if (!carriesOver(loadedKey, key)) {
+            setMessages(readConversation(key));
+        }
+        setLoadedKey(key);
+    }, [key, loadedKey]);
+    useEffect(() => {
+        if (loadedKey && sameConversation(key, loadedKey)) {
+            writeConversation(loadedKey, messages);
+        }
+    }, [key, loadedKey, messages]);
     const stop = useCallback(() => {
         abortController?.abort();
         setAbortController(null);

package/dist/components/conversation-store.d.ts

@@ -0,0 +1,18 @@
+import type { AssistantMessage, DocumentBridgeSnapshot } from "./assistant-context.tsx";
+export type ConversationKey = {
+    kind: "stored";
+    key: string;
+}
+/** A create view: the thread lives in memory until the document is saved. */
+ | {
+    kind: "unsaved";
+    entity: string;
+};
+export declare function conversationKey(userId: string | number | undefined, bridge: Pick<DocumentBridgeSnapshot, "collectionSlug" | "globalSlug" | "documentId"> | null): ConversationKey | null;
+export declare function sameConversation(a: ConversationKey | null, b: ConversationKey | null): boolean;
+/** Saving a new document: the thread that created it becomes the document's own. */
+export declare function carriesOver(from: ConversationKey | null, to: ConversationKey): boolean;
+/** Storage can be unavailable or hold anything; a thread that cannot be read starts empty. */
+export declare function readConversation(key: ConversationKey): AssistantMessage[];
+export declare function writeConversation(key: ConversationKey, messages: AssistantMessage[]): void;
+export declare function parseStored(raw: string, now: number): AssistantMessage[];

package/dist/components/conversation-store.js

@@ -0,0 +1,102 @@
+/**
+ * Conversations are kept in the browser, one per user and document, plus one for everything outside
+ * a document (lists, dashboard). A document that is not saved yet has none of its own: its thread is
+ * carried over to the document once it gets an id.
+ */
+const PREFIX = "payload-editor-assistant:chat";
+const MAX_MESSAGES = 50;
+const MAX_AGE_MS = 30 * 24 * 60 * 60_000;
+export function conversationKey(userId, bridge) {
+    if (userId === undefined) {
+        return null;
+    }
+    const user = `${PREFIX}:${userId}`;
+    if (!bridge || (!bridge.collectionSlug && !bridge.globalSlug)) {
+        return { kind: "stored", key: `${user}:general` };
+    }
+    if (bridge.globalSlug) {
+        return { kind: "stored", key: `${user}:global:${bridge.globalSlug}` };
+    }
+    if (bridge.documentId === undefined || bridge.documentId === null || bridge.documentId === "") {
+        return { kind: "unsaved", entity: `collection:${bridge.collectionSlug}` };
+    }
+    return {
+        kind: "stored",
+        key: `${user}:collection:${bridge.collectionSlug}:${bridge.documentId}`,
+    };
+}
+export function sameConversation(a, b) {
+    if (!a || !b) {
+        return a === b;
+    }
+    return a.kind === "stored"
+        ? b.kind === "stored" && a.key === b.key
+        : b.kind === "unsaved" && a.entity === b.entity;
+}
+/** Saving a new document: the thread that created it becomes the document's own. */
+export function carriesOver(from, to) {
+    return (from?.kind === "unsaved" &&
+        to.kind === "stored" &&
+        to.key.includes(`:${from.entity}:`) &&
+        readConversation(to).length === 0);
+}
+/** Storage can be unavailable or hold anything; a thread that cannot be read starts empty. */
+export function readConversation(key) {
+    if (key.kind !== "stored") {
+        return [];
+    }
+    try {
+        const raw = window.localStorage.getItem(key.key);
+        return raw ? parseStored(raw, Date.now()) : [];
+    }
+    catch {
+        return [];
+    }
+}
+export function writeConversation(key, messages) {
+    if (key.kind !== "stored") {
+        return;
+    }
+    try {
+        if (messages.length === 0) {
+            window.localStorage.removeItem(key.key);
+            return;
+        }
+        const stored = { savedAt: Date.now(), messages: messages.slice(-MAX_MESSAGES) };
+        window.localStorage.setItem(key.key, JSON.stringify(stored));
+    }
+    catch {
+        // Not remembered (full or blocked storage); the thread still works for this page.
+    }
+}
+export function parseStored(raw, now) {
+    try {
+        const stored = JSON.parse(raw);
+        if (typeof stored.savedAt !== "number" || now - stored.savedAt > MAX_AGE_MS) {
+            return [];
+        }
+        return Array.isArray(stored.messages)
+            ? stored.messages.filter(isMessage).map((message) => ({
+                id: message.id,
+                role: message.role,
+                text: message.text,
+                candidates: Array.isArray(message.candidates)
+                    ? message.candidates.filter(isCandidate)
+                    : undefined,
+            }))
+            : [];
+    }
+    catch {
+        return [];
+    }
+}
+function isMessage(value) {
+    const message = value;
+    return (typeof message?.id === "string" &&
+        typeof message.text === "string" &&
+        (message.role === "user" || message.role === "assistant" || message.role === "system"));
+}
+function isCandidate(value) {
+    const candidate = value;
+    return typeof candidate?.href === "string" && typeof candidate.label === "string";
+}

package/dist/components/copy.d.ts

@@ -14,6 +14,16 @@ export declare const COPY: {
         readonly send: "Send";
         readonly stop: "Stop";
         readonly working: "Working…";
+        readonly steps: {
+            readonly thinking: "Thinking…";
+            readonly searching: "Searching the content…";
+            readonly reading: "Reading a document…";
+            readonly reading_form: "Reading the form…";
+            readonly proposing: "Preparing the change…";
+            readonly drafting: "Preparing the draft…";
+            readonly navigating: "Finding the page…";
+            readonly writing: "Writing the reply…";
+        };
         readonly selected: "Selected";
         readonly clearSelection: "Clear selection";
         readonly approve: "Approve";
@@ -25,6 +35,7 @@ export declare const COPY: {
         readonly previewHint: "Shown in the form and the preview. Nothing is saved yet.";
         readonly previewHintAutosave: "Shown in the form and the preview. The draft saves itself, but nothing is published.";
         readonly undoLosesEdits: "You edited the form after the suggestion. Undo removes those edits too.";
+        readonly refinedHint: "The list shows the latest adjustment. Undo takes the form back to before the first suggestion.";
         readonly requestFailed: "I could not complete that request.";
         readonly done: "Done.";
         readonly proposalFailed: "The proposal could not be applied.";
@@ -65,6 +76,16 @@ export declare const COPY: {
         readonly send: "Skicka";
         readonly stop: "Stoppa";
         readonly working: "Arbetar…";
+        readonly steps: {
+            readonly thinking: "Tänker…";
+            readonly searching: "Söker bland innehållet…";
+            readonly reading: "Läser ett dokument…";
+            readonly reading_form: "Läser formuläret…";
+            readonly proposing: "Förbereder ändringen…";
+            readonly drafting: "Förbereder utkastet…";
+            readonly navigating: "Letar upp sidan…";
+            readonly writing: "Skriver svaret…";
+        };
         readonly selected: "Markerat";
         readonly clearSelection: "Ta bort markering";
         readonly approve: "Godkänn";
@@ -76,6 +97,7 @@ export declare const COPY: {
         readonly previewHint: "Syns i formuläret och förhandsvisningen. Inget är sparat än.";
         readonly previewHintAutosave: "Syns i formuläret och förhandsvisningen. Utkastet sparas automatiskt, men inget publiceras.";
         readonly undoLosesEdits: "Du har ändrat i formuläret efter förslaget. Ångra tar bort de ändringarna också.";
+        readonly refinedHint: "Listan visar den senaste justeringen. Ångra tar formuläret tillbaka till hur det var före första förslaget.";
         readonly requestFailed: "Jag kunde inte slutföra det.";
         readonly done: "Klart.";
         readonly proposalFailed: "Förslaget kunde inte genomföras.";

package/dist/components/copy.js

@@ -15,6 +15,16 @@ export const COPY = {
         send: "Send",
         stop: "Stop",
         working: "Working…",
+        steps: {
+            thinking: "Thinking…",
+            searching: "Searching the content…",
+            reading: "Reading a document…",
+            reading_form: "Reading the form…",
+            proposing: "Preparing the change…",
+            drafting: "Preparing the draft…",
+            navigating: "Finding the page…",
+            writing: "Writing the reply…",
+        },
         selected: "Selected",
         clearSelection: "Clear selection",
         approve: "Approve",
@@ -26,6 +36,7 @@ export const COPY = {
         previewHint: "Shown in the form and the preview. Nothing is saved yet.",
         previewHintAutosave: "Shown in the form and the preview. The draft saves itself, but nothing is published.",
         undoLosesEdits: "You edited the form after the suggestion. Undo removes those edits too.",
+        refinedHint: "The list shows the latest adjustment. Undo takes the form back to before the first suggestion.",
         requestFailed: "I could not complete that request.",
         done: "Done.",
         proposalFailed: "The proposal could not be applied.",
@@ -66,6 +77,16 @@ export const COPY = {
         send: "Skicka",
         stop: "Stoppa",
         working: "Arbetar…",
+        steps: {
+            thinking: "Tänker…",
+            searching: "Söker bland innehållet…",
+            reading: "Läser ett dokument…",
+            reading_form: "Läser formuläret…",
+            proposing: "Förbereder ändringen…",
+            drafting: "Förbereder utkastet…",
+            navigating: "Letar upp sidan…",
+            writing: "Skriver svaret…",
+        },
         selected: "Markerat",
         clearSelection: "Ta bort markering",
         approve: "Godkänn",
@@ -77,6 +98,7 @@ export const COPY = {
         previewHint: "Syns i formuläret och förhandsvisningen. Inget är sparat än.",
         previewHintAutosave: "Syns i formuläret och förhandsvisningen. Utkastet sparas automatiskt, men inget publiceras.",
         undoLosesEdits: "Du har ändrat i formuläret efter förslaget. Ångra tar bort de ändringarna också.",
+        refinedHint: "Listan visar den senaste justeringen. Ångra tar formuläret tillbaka till hur det var före första förslaget.",
         requestFailed: "Jag kunde inte slutföra det.",
         done: "Klart.",
         proposalFailed: "Förslaget kunde inte genomföras.",

package/dist/components/proposal-chain.d.ts

@@ -0,0 +1,22 @@
+import type { PendingApproval } from "./assistant-context.tsx";
+/** One server-side proposal and the form it was made for; keeping it is checked against that form. */
+export type ProposalStep = {
+    approvalId: string;
+    nonce: string;
+    basis: Record<string, unknown>;
+};
+/**
+ * A suggestion the editor refined before keeping it ("shorter", "another tone"). The new proposal
+ * was made against the form with the earlier one in it, so the chain keeps the form from before the
+ * first step for undo, and every step so each can be kept in order against its own form.
+ */
+export declare function refineProposal(open: PendingApproval, next: PendingApproval, basis: Record<string, unknown>): PendingApproval;
+/** Every step of an applied proposal, oldest first. */
+export declare function proposalSteps(pending: PendingApproval): ProposalStep[];
+/**
+ * The same turn produced a second proposal. It was made against the same form as the one it
+ * replaces, so it takes that step's place: undo and the earlier steps stay as they were.
+ */
+export declare function replaceLatestStep(current: PendingApproval, next: PendingApproval, basis: Record<string, unknown>): PendingApproval;
+/** A form proposal with the form it would produce: the only kind shown in the form before keeping. */
+export declare function isFormProposal(value: unknown): value is PendingApproval;

package/dist/components/proposal-chain.js

@@ -0,0 +1,57 @@
+/**
+ * A suggestion the editor refined before keeping it ("shorter", "another tone"). The new proposal
+ * was made against the form with the earlier one in it, so the chain keeps the form from before the
+ * first step for undo, and every step so each can be kept in order against its own form.
+ */
+export function refineProposal(open, next, basis) {
+    if (!open.applied) {
+        return next;
+    }
+    const changed = new Set([
+        ...(open.preview?.changedPaths ?? []),
+        ...(next.preview?.changedPaths ?? []),
+    ]);
+    return {
+        ...next,
+        preview: next.preview && { ...next.preview, changedPaths: [...changed] },
+        earlier: proposalSteps(open),
+        applied: { ...open.applied, basis },
+    };
+}
+/** Every step of an applied proposal, oldest first. */
+export function proposalSteps(pending) {
+    if (!pending.applied) {
+        return [];
+    }
+    return [
+        ...(pending.earlier ?? []),
+        { approvalId: pending.approvalId, nonce: pending.nonce, basis: pending.applied.basis },
+    ];
+}
+/**
+ * The same turn produced a second proposal. It was made against the same form as the one it
+ * replaces, so it takes that step's place: undo and the earlier steps stay as they were.
+ */
+export function replaceLatestStep(current, next, basis) {
+    if (!current.applied) {
+        return next;
+    }
+    const changed = new Set([
+        ...(current.preview?.changedPaths ?? []),
+        ...(next.preview?.changedPaths ?? []),
+    ]);
+    return {
+        ...next,
+        preview: next.preview && { ...next.preview, changedPaths: [...changed] },
+        earlier: current.earlier,
+        applied: { ...current.applied, basis },
+    };
+}
+/** A form proposal with the form it would produce: the only kind shown in the form before keeping. */
+export function isFormProposal(value) {
+    const pending = value;
+    return (pending?.capability === "form.propose" &&
+        typeof pending.approvalId === "string" &&
+        typeof pending.nonce === "string" &&
+        Boolean(pending.preview && typeof pending.preview.data === "object"));
+}

package/dist/endpoints/chat.d.ts

@@ -1,3 +1,7 @@
 import type { Endpoint } from "payload";
 import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
 export declare function createChatEndpoint(options: ValidatedEditorAssistantOptions): Endpoint;
+/** Only a short list of form paths; the prompt names them as data. */
+export declare function sanitizeOpenProposal(value: unknown): {
+    changedPaths: string[];
+} | undefined;

package/dist/endpoints/chat.js

@@ -26,6 +26,8 @@ export function createChatEndpoint(options) {
             if (!beginInflight(actor)) {
                 return Response.json({ error: "rate_limited" }, { status: 429 });
             }
+            // A streamed turn ends when its stream does, not when the handler returns.
+            let streaming = false;
             try {
                 let body;
                 try {
@@ -45,7 +47,8 @@ export function createChatEndpoint(options) {
                     ? body.messages.filter(isChatMessage)
                     : [{ role: "user", text: body.message }];
                 const language = resolveChatLanguage(messages.filter((message) => message.role === "user").map((message) => message.text), nonEmpty(body.uiLanguage));
-                const result = await runAgentTurn(req, options, {
+                const run = (onEvent) => runAgentTurn(req, options, {
+                    onEvent,
                     message: body.message,
                     messages,
                     bridge: {
@@ -58,9 +61,15 @@ export function createChatEndpoint(options) {
                         uiLanguage: nonEmpty(body.uiLanguage)?.startsWith("sv") ? "sv" : "en",
                         view: sanitizeAdminView(body.view, options),
                         selection: typeof body.selection === "string" ? body.selection : undefined,
+                        openProposal: sanitizeOpenProposal(body.openProposal),
                     },
                     formData: body.formData,
                 });
+                if (body.stream === true) {
+                    streaming = true;
+                    return streamTurn(run, language, () => endInflight(actor));
+                }
+                const result = await run();
                 if (!result.ok) {
                     const status = result.error === "timeout" ? 504 : 503;
                     return Response.json({ error: result.error, message: result.message }, { status });
@@ -68,11 +77,69 @@ export function createChatEndpoint(options) {
                 return Response.json({ ...result, language });
             }
             finally {
-                endInflight(actor);
+                if (!streaming) {
+                    endInflight(actor);
+                }
             }
         },
     };
 }
+/**
+ * One JSON object per line: `step` and `proposal` events while the turn runs, then `done` with the
+ * same result the JSON answer has, or `error`. Errors after the stream started cannot change the
+ * HTTP status, so they travel as an event.
+ */
+function streamTurn(run, language, finished) {
+    const encoder = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            const send = (value) => {
+                try {
+                    controller.enqueue(encoder.encode(`${JSON.stringify(value)}\n`));
+                }
+                catch {
+                    // The editor stopped the request; the turn is aborted through the request signal.
+                }
+            };
+            try {
+                const result = await run(send);
+                send(result.ok
+                    ? { type: "done", result: { ...result, language } }
+                    : { type: "error", error: result.error, message: result.message });
+            }
+            catch {
+                send({ type: "error", error: "provider_error" });
+            }
+            finally {
+                finished();
+                try {
+                    controller.close();
+                }
+                catch {
+                    // Already closed by the client.
+                }
+            }
+        },
+    });
+    return new Response(stream, {
+        headers: {
+            "Content-Type": "application/x-ndjson; charset=utf-8",
+            "Cache-Control": "no-cache, no-transform",
+            "X-Accel-Buffering": "no",
+        },
+    });
+}
+/** Only a short list of form paths; the prompt names them as data. */
+export function sanitizeOpenProposal(value) {
+    const paths = value?.changedPaths;
+    if (!Array.isArray(paths)) {
+        return undefined;
+    }
+    const changedPaths = paths
+        .filter((path) => typeof path === "string" && /^[\w.]{1,200}$/.test(path))
+        .slice(0, 50);
+    return changedPaths.length > 0 ? { changedPaths } : undefined;
+}
 function nonEmpty(value) {
     return typeof value === "string" && value.trim() ? value : undefined;
 }

package/dist/runtime/agent.d.ts

@@ -32,11 +32,26 @@ type ChatMessage = {
     role: "user" | "assistant" | "system";
     text: string;
 };
+/** What the assistant is doing right now, for the panel to show while the turn runs. */
+export type AgentStep = "thinking" | "searching" | "reading" | "reading_form" | "proposing" | "drafting" | "navigating" | "writing";
+export type AgentEvent = {
+    type: "step";
+    step: AgentStep;
+}
+/** A form proposal, sent as soon as it exists so Admin can show it before the reply is written. */
+ | {
+    type: "proposal";
+    pendingApproval: NonNullable<Extract<AgentChatResult, {
+        ok: true;
+    }>["pendingApproval"]>;
+};
+export type AgentEventSink = (event: AgentEvent) => void;
 export declare function runAgentTurn(req: PayloadRequest, options: ValidatedEditorAssistantOptions, input: {
     message: string;
     messages?: ChatMessage[];
     bridge: ToolContext["bridge"];
     formData?: Record<string, unknown>;
+    onEvent?: AgentEventSink;
 }): Promise<AgentChatResult>;
 export declare function collectResult(text: string, result: {
     steps?: unknown;

package/dist/runtime/agent.js

@@ -7,7 +7,24 @@ import { editorFacingText } from "./voice.js";
 const MAX_MESSAGES = 20;
 const MAX_STEPS = 8;
 const TIMEOUT_MS = 60_000;
+const STEP_FOR_TOOL = {
+    "schema.discover": "thinking",
+    "content.find": "searching",
+    "content.findById": "reading",
+    "form.read": "reading_form",
+    "form.propose": "proposing",
+    "draft.create": "drafting",
+    "admin.navigate": "navigating",
+};
 export async function runAgentTurn(req, options, input) {
+    const emit = (event) => {
+        try {
+            input.onEvent?.(event);
+        }
+        catch {
+            // A listener that went away (closed stream) does not stop the turn.
+        }
+    };
     const model = await resolveModel(options, req.user?.id);
     if (!model) {
         req.payload?.logger?.warn(`${PACKAGE_NAME}: no model: the \`model\` option resolved to nothing for this user`);
@@ -29,10 +46,11 @@ export async function runAgentTurn(req, options, input) {
     const history = truncateMessages(input.messages ?? [{ role: "user", text: input.message }]);
     const captured = [];
     const previews = new Map();
-    const tools = buildSdkTools(ai, ctx, captured, previews);
+    const tools = buildSdkTools(ai, ctx, captured, previews, emit);
     const turnContext = await loadTurnContext(req, options, input.bridge, input.formData);
     const system = buildSystemPrompt(options.instructions, input.bridge, turnContext);
     const sdkMessages = toSdkMessages(history);
+    emit({ type: "step", step: "thinking" });
     try {
         const first = await generate(ai, {
             model,
@@ -60,7 +78,7 @@ export async function runAgentTurn(req, options, input) {
             return collected;
         }
         const retryCaptured = [];
-        const retryTools = buildSdkTools(ai, ctx, retryCaptured, previews);
+        const retryTools = buildSdkTools(ai, ctx, retryCaptured, previews, emit);
         const retry = await generate(ai, {
             model,
             system,
@@ -168,7 +186,7 @@ function isToolOutcome(value) {
     const record = value;
     return typeof record.ok === "boolean" && typeof record.capability === "string";
 }
-function buildSdkTools(ai, ctx, captured, previews) {
+function buildSdkTools(ai, ctx, captured, previews, emit) {
     const tools = {};
     for (const capability of Object.keys(TOOL_JSON_SCHEMAS)) {
         const schema = TOOL_JSON_SCHEMAS[capability];
@@ -180,6 +198,7 @@ function buildSdkTools(ai, ctx, captured, previews) {
             execute: async (raw) => {
                 try {
                     const input = raw && typeof raw === "object" ? raw : {};
+                    emit({ type: "step", step: STEP_FOR_TOOL[capability] ?? "thinking" });
                     const executed = await executeTool(fromProviderToolName(name), input, ctx);
                     // The whole form with the change applied is for Admin, not another round through the model.
                     const { preview, ...outcome } = executed.ok
@@ -187,7 +206,12 @@ function buildSdkTools(ai, ctx, captured, previews) {
                         : { ...executed, preview: undefined };
                     if (preview && executed.ok && executed.pendingApproval) {
                         previews.set(executed.pendingApproval.approvalId, preview);
+                        emit({ type: "proposal", pendingApproval: { ...executed.pendingApproval, preview } });
                     }
+                    emit({
+                        type: "step",
+                        step: executed.ok && executed.pendingApproval ? "writing" : "thinking",
+                    });
                     captured.push(outcome);
                     return outcome;
                 }

package/dist/runtime/propose-loop.js

@@ -12,9 +12,9 @@ export function offeredValue(text, request) {
 }
 // A request for a change, or a yes to one the assistant asked about. Letter lookarounds rather
 // than \b, which treats å, ä and ö as word boundaries.
-const ASKS_FOR_CHANGE = /(?<!\p{L})(make|change|rewrite|write|add|replace|shorten|tighten|fill|translate|update|improve|set|rename|remove|delete|yes|yeah|sure|ok|okay|do it|go ahead|gör|göra|ändra|skriv|skriva|lägg|lägga|byt|byta|korta|fyll|fylla|översätt|uppdatera|förbättra|sätt|ta bort|ja|japp|kör|gärna)(?!\p{L})/iu;
+const ASKS_FOR_CHANGE = /(?<!\p{L})(make|change|rewrite|write|add|replace|shorten|tighten|fill|translate|update|improve|set|rename|shorter|longer|simpler|remove|delete|yes|yeah|sure|ok|okay|do it|go ahead|gör|göra|ändra|skriv|skriva|lägg|lägga|byt|byta|korta|fyll|fylla|översätt|uppdatera|förbättra|sätt|ta bort|kortare|längre|enklare|ja|japp|kör|gärna)(?!\p{L})/iu;
 const QUOTED = /["“”«»][^"“”«»]{2,}["“”«»]|'[^']{2,}'/;
-const CLAIMED_CHANGE = /godkänn|godkann|approve|rubriken är nu|the headline is now|sparas den på sidan|fälten i på sidan|pending form change|i've applied|i have applied/i;
+const CLAIMED_CHANGE = /godkänn|godkann|approve|rubriken är nu|the headline is now|sparas den på sidan|fälten i på sidan|pending form change|i've applied|i have applied|har lagt in|i've put|i have put/i;
 const ASKED_TO_MUTATE = /ska jag (lägga|fylla|ändra|sätta|uppdatera)|should i (put|fill|change|set|update|apply)|shall i (put|fill|change|set|update|apply)|want me to (put|fill|change|set|update|apply)/i;
 export function needsProposeRetry(input) {
     if (!input.hasOpenDocument || input.pendingApproval || input.navigate) {

package/dist/runtime/system-prompt.js

@@ -7,7 +7,7 @@ export function buildSystemPrompt(instructions, bridge, turnContext) {
         "Two to five short sentences. Use visible field labels (Title, Headline, Summary).",
         "Never ask whether you should proceed. When you have the new values, call form.propose in the same turn.",
         "If the editor confirms a change you already described, call form.propose with those values. Do not ask again.",
-        "Do not claim the form already has the new values. Do not tell the editor to approve; the panel does that when the proposal exists.",
+        'When you call form.propose, the change is shown in the form and preview for the editor to keep or undo. Then say in one short sentence what you changed ("Här är en kortare rubrik."). Never say it is saved, published or kept, and do not tell them to approve or click anything; the panel does that. Without a form.propose call, do not claim the form has new values.',
         "If form.propose fails, say you could not apply it and they can try again. Never tell them to copy-paste.",
         "When the editor asks you to create a document, call draft.create in the same turn with sensible content based on their request. Do not ask for a title or summary first; they review the draft before it is created.",
         "Never save, publish, unpublish, delete, bulk-mutate, or upload files.",
@@ -62,7 +62,7 @@ function viewLine(turnContext) {
 function thisTurnBlock(bridge, turnContext) {
     const locale = bridge?.locale ?? turnContext?.open?.locale;
     const chat = bridge?.language ?? locale;
-    if (!chat && !turnContext?.form) {
+    if (!chat && !turnContext?.form && !bridge?.openProposal) {
         return "";
     }
     const lines = [
@@ -81,6 +81,9 @@ function thisTurnBlock(bridge, turnContext) {
             ? `Selected field: ${selection.field.path}.`
             : `Selected: ${selection.path}; its fields are under that path in the form.`);
     }
+    if (bridge?.openProposal) {
+        lines.push(`The form shows your earlier suggestion, not kept yet; it changed ${bridge.openProposal.changedPaths.join(", ")}. Those values are in the form now. If the editor asks to adjust it (shorter, another tone, other wording, one more field), call form.propose now with the adjusted values; it replaces the suggestion in the preview. Do not say it is saved or kept.`);
+    }
     const form = turnContext?.form;
     if (form) {
         const empty = listEmptyTextPaths(form);

package/dist/runtime/tools.d.ts

@@ -18,6 +18,10 @@ export type ToolBridge = {
     view?: AdminView;
     /** Form path of what the editor last clicked or focused in the open form, unverified. */
     selection?: string;
+    /** A suggestion shown in the form that the editor has not kept yet: the paths it changed. */
+    openProposal?: {
+        changedPaths: string[];
+    };
 };
 export type ToolContext = {
     req: PayloadRequest;

package/dist/runtime/voice.d.ts

@@ -7,5 +7,6 @@ export declare function editorFacingText(input: {
     expectedProposal?: boolean;
 }): string;
 export declare function stripInternalSpeech(text: string, locale: string): string;
+export declare function withoutOverclaims(text: string): string;
 export declare function approvalCopy(locale: string, capability: "form.propose" | "draft.create"): string;
 export declare function couldNotStageCopy(locale: string): string;

package/dist/runtime/voice.js

@@ -3,7 +3,12 @@ const INTERNAL = /\b(form\.propose|form_propose|draft\.create|draft_create|schem
 const ENGLISH_META = /\b(despite|therefore|however|the tool|I should|I've|has been issued|appropriate turn|proposed values)\b/i;
 export function editorFacingText(input) {
     if (input.pendingApproval) {
-        return approvalCopy(input.locale, input.pendingApproval.capability);
+        // A form change is in the form now, so the model's own words about it can stand, minus any
+        // claim the panel contradicts. A draft is not created until approved; that keeps fixed copy.
+        const own = input.pendingApproval.capability === "form.propose"
+            ? withoutOverclaims(stripInternalSpeech(input.text, input.locale))
+            : "";
+        return own || approvalCopy(input.locale, input.pendingApproval.capability);
     }
     const cleaned = stripInternalSpeech(input.text, input.locale);
     if (input.expectedProposal ||
@@ -26,6 +31,16 @@ export function stripInternalSpeech(text, locale) {
     });
     return kept.join(" ").replace(/\s+/g, " ").trim();
 }
+/** Keeping, saving and publishing are the editor's; a sentence that claims or asks for them goes. */
+const OVERCLAIM = /godkänn|godkann|approve|spara|sparat|sparad|sparats|publicer|\bsaved?\b|publish|behåll|\bkeep\b|klicka|\bclick/i;
+const MAX_OWN_TEXT = 600;
+export function withoutOverclaims(text) {
+    const kept = splitSentences(text)
+        .filter((sentence) => !OVERCLAIM.test(sentence))
+        .join(" ")
+        .trim();
+    return kept.length <= MAX_OWN_TEXT ? kept : "";
+}
 export function approvalCopy(locale, capability) {
     if (isSwedish(locale)) {
         return capability === "draft.create"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simmalugnt-se/payload-editor-assistant",
-  "version": "0.3.3",
+  "version": "0.4.0",
   "description": "Context-aware editor assistant plugin for Payload Admin",
   "keywords": [
     "payload",