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

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.";
@@ -43,6 +54,7 @@ export declare const COPY: {
             readonly rate_limited: "Too many messages at once. Wait a moment and try again.";
             readonly timeout: "The assistant took too long to answer. Try again.";
             readonly provider_error: "The AI service did not answer. The server log has the cause.";
+            readonly no_model: "No AI model is set up yet, for example because an API key is missing. Ask whoever runs the site to add one.";
             readonly tool_denied: "That is not something the assistant may do here.";
             readonly stale_context: "The form changed in the meantime. Try again.";
             readonly aborted: "Stopped.";
@@ -64,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";
@@ -75,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.";
@@ -93,6 +116,7 @@ export declare const COPY: {
             readonly rate_limited: "För många meddelanden på en gång. Vänta en stund och försök igen.";
             readonly timeout: "Assistenten tog för lång tid på sig. Försök igen.";
             readonly provider_error: "AI-tjänsten svarade inte. Orsaken finns i serverloggen.";
+            readonly no_model: "Ingen AI-modell är inställd än, till exempel för att en API-nyckel saknas. Be den som sköter webbplatsen att lägga till en.";
             readonly tool_denied: "Det får assistenten inte göra här.";
             readonly stale_context: "Formuläret ändrades under tiden. Försök igen.";
             readonly aborted: "Stoppat.";

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.",
@@ -44,6 +55,7 @@ export const COPY = {
             rate_limited: "Too many messages at once. Wait a moment and try again.",
             timeout: "The assistant took too long to answer. Try again.",
             provider_error: "The AI service did not answer. The server log has the cause.",
+            no_model: "No AI model is set up yet, for example because an API key is missing. Ask whoever runs the site to add one.",
             tool_denied: "That is not something the assistant may do here.",
             stale_context: "The form changed in the meantime. Try again.",
             aborted: "Stopped.",
@@ -65,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",
@@ -76,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.",
@@ -94,6 +117,7 @@ export const COPY = {
             rate_limited: "För många meddelanden på en gång. Vänta en stund och försök igen.",
             timeout: "Assistenten tog för lång tid på sig. Försök igen.",
             provider_error: "AI-tjänsten svarade inte. Orsaken finns i serverloggen.",
+            no_model: "Ingen AI-modell är inställd än, till exempel för att en API-nyckel saknas. Be den som sköter webbplatsen att lägga till en.",
             tool_denied: "Det får assistenten inte göra här.",
             stale_context: "Formuläret ändrades under tiden. Försök igen.",
             aborted: "Stoppat.",

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,11 +7,28 @@ 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) {
-        logProviderError(req, "no model: the `model` option resolved to nothing for this user");
-        return { ok: false, error: "provider_error" };
+        req.payload?.logger?.warn(`${PACKAGE_NAME}: no model: the \`model\` option resolved to nothing for this user`);
+        return { ok: false, error: "no_model" };
     }
     const ai = await loadAiSdk();
     if (!ai) {
@@ -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;