@aglyn/plugins-ai 1.0.0-beta.143

package/src/lib/components/assist-panel.component.js

@@ -0,0 +1,1099 @@
+/**
+ * @license
+ * Copyright 2026 Aglyn LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */ 'use client';
+import { _ as _extends } from "@swc/helpers/_/_extends";
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { canvas, checkEntitlement, lockdownRefusalText, parseLockdownRefusal } from "@aglyn/aglyn";
+import { editorSessionsRevision, openEditorSession, subscribeEditorSessions } from "@aglyn/aglyn/plugin-manager/editor-sessions";
+import { trackEvent } from "@aglyn/aglyn/app-utils/analytics-events";
+import { mdiChatQuestionOutline, mdiChevronDown, mdiChevronUp, mdiClose, mdiOpenInNew, mdiSend, mdiThumbDownOutline, mdiThumbUpOutline } from "@aglyn/shared-data-mdi";
+import { AppLink, MdiIcon } from "@aglyn/shared-ui-jsx";
+import { useSnackbar } from "@aglyn/shared-ui-snackstack";
+import { Alert, Box, Button, Chip, CircularProgress, Collapse, Drawer, Fab, IconButton, Link, Paper, Stack, TextField, Tooltip, Typography } from "@mui/material";
+import { usePathname } from "next/navigation";
+import { Fragment, useCallback, useEffect, useRef, useState, useSyncExternalStore } from "react";
+import { useUser } from "@aglyn/tenant-feature-instance";
+import { authorizedFetch } from "@aglyn/shared-util-http/authorized-token";
+import { assistEditDocumentOf, isAssistEditProposal } from "../model/assist-edit.js";
+import { applyAssistEdit, describeAssistEditCanvas } from "./assist-edit-canvas.js";
+import { AssistEditCard } from "./assist-edit-card.component.js";
+import { aiInsightSurfaceForPath } from "../model/ai-insight.js";
+import { AssistJobsDrawer } from "./assist-jobs-drawer.component.js";
+import { AiModelSelector } from "./ai-model-selector.component.js";
+import { AiUsageStrip } from "./ai-usage-strip.component.js";
+import { useAiModelChoice } from "./use-ai-model-choice.js";
+import { usePublishAiUsageMeter } from "./use-ai-usage-meter.js";
+import { pluginDocsHelp } from "@aglyn/aglyn/app-utils/docs-help";
+import { HelpTip } from "@aglyn/shared-ui-jsx";
+const HISTORY_TURNS_SENT = 12;
+const storageKey = (orgId)=>`aglyn-assist:${orgId}`;
+function loadThread(orgId) {
+    if (!orgId || typeof sessionStorage === 'undefined') return [];
+    try {
+        const raw = sessionStorage.getItem(storageKey(orgId));
+        const parsed = raw ? JSON.parse(raw) : [];
+        return Array.isArray(parsed) ? parsed : [];
+    } catch (unused) {
+        return [];
+    }
+}
+function saveThread(orgId, messages) {
+    if (!orgId || typeof sessionStorage === 'undefined') return;
+    try {
+        sessionStorage.setItem(storageKey(orgId), JSON.stringify(messages));
+    } catch (unused) {
+    // Quota/full storage never breaks chat.
+    }
+}
+/**
+ * Minimal renderer for assistant text: markdown links and bare URLs become
+ * links (internal root-relative paths ride AppLink, external open in a new
+ * tab); everything else renders as plain text with line breaks. Phase 1 on
+ * purpose — no full markdown surface inside the panel.
+ */ export function renderAssistText(text) {
+    const parts = [];
+    const pattern = /\[([^\]]+)\]\((\/[^)\s]*|https?:\/\/[^)\s]+)\)|https?:\/\/[^\s)]+/g;
+    let cursor = 0;
+    for (const match of text.matchAll(pattern)){
+        var _match_index;
+        const index = (_match_index = match.index) != null ? _match_index : 0;
+        if (index > cursor) parts.push(text.slice(cursor, index));
+        if (match[1] && match[2]) parts.push({
+            label: match[1],
+            href: match[2]
+        });
+        else parts.push({
+            label: match[0],
+            href: match[0]
+        });
+        cursor = index + match[0].length;
+    }
+    if (cursor < text.length) parts.push(text.slice(cursor));
+    return /*#__PURE__*/ _jsx(_Fragment, {
+        children: parts.map((part, i)=>{
+            if (typeof part === 'string') {
+                return /*#__PURE__*/ _jsx(Fragment, {
+                    children: part
+                }, i);
+            }
+            if (part.href.startsWith('/')) {
+                return /*#__PURE__*/ _jsx(AppLink, {
+                    componentVariant: "naked",
+                    href: part.href,
+                    children: part.label
+                }, i);
+            }
+            return /*#__PURE__*/ _jsx(Link, {
+                href: part.href,
+                target: "_blank",
+                rel: "noreferrer",
+                children: part.label
+            }, i);
+        })
+    });
+}
+/**
+ * Split an answer into its plain layer and its technical tail (AGL-1988).
+ *
+ * Aglyn's users run from first-time business owners to working developers,
+ * and they get the same message. Two modes would be the obvious build and
+ * the wrong one — it asks a beginner to label themselves before they have a
+ * question, and asks a developer to opt in to being taken seriously. So the
+ * model writes one answer with a technical paragraph at the end, and the
+ * panel collapses it: the beginner never has to read past the plain steps,
+ * the developer never has to ask for the route or the field name.
+ *
+ * Degrades to "no tail" when the marker is absent, which is the common case
+ * and not a failure — plenty of answers have nothing technical to add.
+ */ export function splitAssistDisclosure(text) {
+    const match = text.match(/(?:^|\n)[ \t]*Under the hood:[ \t]*/);
+    if (!match || match.index === undefined) return {
+        plain: text,
+        technical: ''
+    };
+    const plain = text.slice(0, match.index).trimEnd();
+    const technical = text.slice(match.index + match[0].length).trim();
+    // An answer that is ONLY a technical tail is still the answer. Collapsing
+    // the whole thing would show the user an empty bubble with a toggle.
+    if (!plain || !technical) return {
+        plain: text,
+        technical: ''
+    };
+    return {
+        plain,
+        technical
+    };
+}
+/** The collapsed developer layer. */ function UnderTheHood({ technical }) {
+    const [open, setOpen] = useState(false);
+    return /*#__PURE__*/ _jsxs(Box, {
+        sx: {
+            mt: 0.5
+        },
+        children: [
+            /*#__PURE__*/ _jsxs(Link, {
+                component: "button",
+                type: "button",
+                variant: "caption",
+                underline: "hover",
+                onClick: ()=>setOpen((prior)=>!prior),
+                sx: {
+                    display: 'inline-flex',
+                    alignItems: 'center',
+                    gap: 0.25
+                },
+                children: [
+                    "Under the hood",
+                    /*#__PURE__*/ _jsx(MdiIcon, {
+                        path: open ? mdiChevronUp.path : mdiChevronDown.path,
+                        sx: {
+                            fontSize: 14
+                        }
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsx(Collapse, {
+                in: open,
+                unmountOnExit: true,
+                children: /*#__PURE__*/ _jsx(Typography, {
+                    variant: "caption",
+                    component: "div",
+                    color: "text.secondary",
+                    sx: {
+                        mt: 0.5,
+                        whiteSpace: 'pre-wrap',
+                        wordBreak: 'break-word'
+                    },
+                    children: renderAssistText(technical)
+                })
+            })
+        ]
+    });
+}
+/**
+ * The source links under an answer (AGL-2486).
+ *
+ * `docs` is server-resolved retrieval output and has ridden every `done`
+ * event since Assist shipped, but NOTHING rendered it: it set the `grounded`
+ * analytics flag and stopped there. So every answer carried its citations to
+ * a reader who never saw them, and on the MODEL path that array is the only
+ * citation there is — the completion is prose, and nothing obliges it to name
+ * the page it was grounded in.
+ *
+ * ## Why this FILTERS rather than rendering the array straight
+ *
+ * The DEFLECTED path is the opposite case. `composeDocsAnswer` deliberately
+ * puts the citation in the answer TEXT as `[label](url)`, because a link is
+ * the one markup this panel speaks (`renderAssistText`) — that is a recorded
+ * decision, not an oversight, and its own docstring names this array as the
+ * tempting-but-wrong home for the citation *because* nothing renders it.
+ * Rendering the array underneath would therefore print every heading a second
+ * time on exactly the answers that already cite well. Anything whose url is
+ * already linked in the text is dropped, which leaves a deflected answer
+ * reading precisely as it does today and gives the model answer the sources
+ * it has never shown.
+ *
+ * ## Why the array is not simply suppressed server-side instead
+ *
+ * That was the other candidate and it is a trap: `docs.length > 0` is what
+ * sets the `grounded` analytics flag, so a docs-QUOTING answer would report
+ * itself ungrounded. The most grounded turn the product serves would be
+ * counted as a documentation gap, which is precisely backwards for the signal
+ * `assist-signal-mining` exists to read.
+ */ export function AssistSources({ text, docs }) {
+    const unseen = [];
+    const shown = new Set();
+    for (const doc of docs != null ? docs : []){
+        // Already a link in the prose, or already listed here. Both are the same
+        // failure to the reader: the same page offered twice.
+        if (!(doc == null ? void 0 : doc.url) || text.includes(doc.url) || shown.has(doc.url)) continue;
+        shown.add(doc.url);
+        unseen.push(doc);
+    }
+    if (!unseen.length) return null;
+    return /*#__PURE__*/ _jsxs(Box, {
+        sx: {
+            mt: 0.75
+        },
+        children: [
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                component: "div",
+                children: unseen.length === 1 ? 'Source' : 'Sources'
+            }),
+            /*#__PURE__*/ _jsx(Stack, {
+                spacing: 0.25,
+                sx: {
+                    mt: 0.25
+                },
+                children: unseen.map((doc)=>/*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        component: "div",
+                        children: doc.url.startsWith('/') ? /*#__PURE__*/ _jsx(AppLink, {
+                            componentVariant: "naked",
+                            href: doc.url,
+                            children: doc.title
+                        }) : /*#__PURE__*/ _jsx(Link, {
+                            href: doc.url,
+                            target: "_blank",
+                            rel: "noreferrer",
+                            children: doc.title
+                        })
+                    }, doc.url))
+            })
+        ]
+    });
+}
+/**
+ * The confirm card — the whole of "automate current view", and the whole of
+ * its boundary.
+ *
+ * The assistant proposes; this card is the human confirmation; confirming
+ * navigates. There is deliberately no submit path anywhere in this
+ * component, and no network call: a chat assistant that writes without
+ * consent is a far worse launch story than one that only advises, and the
+ * cheapest way to be sure it cannot is for the code that could do it not to
+ * exist. `assist-panel-proposal.spec.tsx` greps this file for exactly that.
+ *
+ * The copy is held to the same standard. While `prefill` is false — no
+ * console page reads `assist_*` params yet — the card says it will open the
+ * page and lists the values to use. It does not say it filled anything in,
+ * because a form that comes up empty after that promise is worse than no
+ * card at all.
+ */ function ProposalCard({ proposal, onConfirm, onDismiss, brand }) {
+    return /*#__PURE__*/ _jsxs(Paper, {
+        variant: "outlined",
+        sx: {
+            mt: 1,
+            p: 1.5,
+            borderRadius: 2,
+            bgcolor: 'background.paper'
+        },
+        children: [
+            /*#__PURE__*/ _jsx(Typography, {
+                variant: "subtitle2",
+                children: proposal.label
+            }),
+            /*#__PURE__*/ _jsxs(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                component: "div",
+                children: [
+                    "Opens ",
+                    proposal.outcome,
+                    "."
+                ]
+            }),
+            proposal.values.length > 0 && /*#__PURE__*/ _jsxs(Box, {
+                sx: {
+                    mt: 1
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(Typography, {
+                        variant: "caption",
+                        color: "text.secondary",
+                        component: "div",
+                        children: proposal.prefill ? 'Filled in for you:' : 'Values to use:'
+                    }),
+                    /*#__PURE__*/ _jsx(Stack, {
+                        component: "ul",
+                        sx: {
+                            m: 0,
+                            pl: 2.5
+                        },
+                        children: proposal.values.map(({ name, value })=>/*#__PURE__*/ _jsxs(Typography, {
+                                component: "li",
+                                variant: "caption",
+                                children: [
+                                    name,
+                                    ": ",
+                                    /*#__PURE__*/ _jsx("strong", {
+                                        children: value
+                                    })
+                                ]
+                            }, name))
+                    })
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Typography, {
+                variant: "caption",
+                color: "text.secondary",
+                component: "div",
+                sx: {
+                    mt: 1
+                },
+                children: [
+                    `${brand} Assist only opens the page. Nothing is saved until you `,
+                    'fill the form in and submit it yourself.'
+                ]
+            }),
+            /*#__PURE__*/ _jsxs(Stack, {
+                direction: "row",
+                spacing: 1,
+                sx: {
+                    mt: 1.5
+                },
+                children: [
+                    /*#__PURE__*/ _jsx(AppLink, {
+                        componentVariant: "button",
+                        href: proposal.href,
+                        variant: "contained",
+                        size: "small",
+                        onClick: onConfirm,
+                        startIcon: /*#__PURE__*/ _jsx(MdiIcon, {
+                            path: mdiOpenInNew.path
+                        }),
+                        children: "Take me there"
+                    }),
+                    /*#__PURE__*/ _jsx(Button, {
+                        size: "small",
+                        color: "inherit",
+                        onClick: onDismiss,
+                        children: "No thanks"
+                    })
+                ]
+            })
+        ]
+    });
+}
+export function AssistPanelComponent(props) {
+    const { org, orgId, orgReady, scopedOrgId, orgSlug, hostId, productName, assistVisible, assistStaffPreview, generativeVisible, isStaff, aiPermissions: ai } = props;
+    const verdict = {
+        visible: assistVisible,
+        staffPreview: assistStaffPreview
+    };
+    const branding = {
+        productName
+    };
+    const billingSlug = orgSlug;
+    const pathname = usePathname();
+    const { data: user } = useUser();
+    const { enqueueSnackbar } = useSnackbar();
+    const [open, setOpen] = useState(false);
+    const [input, setInput] = useState('');
+    const [busy, setBusy] = useState(false);
+    const [messages, setMessages] = useState([]);
+    const [quota, setQuota] = useState(null);
+    const scrollRef = useRef(null);
+    // The model switch and the usage strip (AGL-2942): the pick rides the
+    // chat request, and each answer's `meter` moves every strip for the org.
+    const modelChoice = useAiModelChoice({
+        orgId: scopedOrgId,
+        hostId,
+        surface: 'assist',
+        kind: 'assist.chat'
+    });
+    const publishMeter = usePublishAiUsageMeter(scopedOrgId);
+    // The open editor, re-read whenever one opens, closes or reports a change —
+    // so a card raised on a live version offers Apply once its new version is
+    // the one open.
+    useSyncExternalStore(subscribeEditorSessions, editorSessionsRevision, editorSessionsRevision);
+    const editorSession = openEditorSession();
+    // Thread is per-org, session-persisted; switching orgs swaps threads.
+    // Keyed on the SCOPED org (AGL-1934): gating only the render would still
+    // load — and, on the next keystroke, save — a thread under the fallback
+    // org's key on every mount of a page that named no workspace.
+    useEffect(()=>{
+        setMessages(loadThread(scopedOrgId));
+        setQuota(null);
+    }, [
+        scopedOrgId
+    ]);
+    useEffect(()=>{
+        saveThread(scopedOrgId, messages);
+        const node = scrollRef.current;
+        if (node) node.scrollTop = node.scrollHeight;
+    }, [
+        scopedOrgId,
+        messages
+    ]);
+    const entitled = orgReady && checkEntitlement(org, 'aiAssist');
+    // Whether a question asked from a besigner document carries its canvas
+    // (AGL-2906). A hint, not a grant: the server decides the edit rung again
+    // from its own reads, and drops the outline below it.
+    const editRungHint = generativeVisible && ai.loaded && ai.generate && orgReady && checkEntitlement(org, 'aiGenerative');
+    const send = useCallback(async ()=>{
+        const question = input.trim();
+        if (!question || busy || !scopedOrgId || !ai.use) return;
+        setBusy(true);
+        setInput('');
+        const history = messages.slice(-HISTORY_TURNS_SENT).map(({ role, text })=>({
+                role,
+                text
+            }));
+        setMessages((prior)=>[
+                ...prior,
+                {
+                    role: 'user',
+                    text: question
+                },
+                {
+                    role: 'assistant',
+                    text: ''
+                }
+            ]);
+        const patchAnswer = (patch)=>{
+            setMessages((prior)=>{
+                const next = [
+                    ...prior
+                ];
+                const last = next[next.length - 1];
+                if ((last == null ? void 0 : last.role) === 'assistant') next[next.length - 1] = patch(last);
+                return next;
+            });
+        };
+        // A notice must not be swallowed by a partial answer: a refusal or a
+        // max_tokens cut arrives AFTER text has streamed, and substituting only
+        // when the bubble is empty would leave the user staring at half an
+        // answer with nothing saying why it stopped.
+        const failAnswer = (notice)=>{
+            patchAnswer((message)=>_extends({}, message, {
+                    text: message.text ? `${message.text}\n\n${notice}` : notice
+                }));
+        };
+        try {
+            var _ref;
+            // The canvas outline rides along from the besigner document the open
+            // editor holds — ids, component ids and short values, never the stored
+            // document — and only while that editor is on the version the route
+            // names, so the outline and the selection are the ones on screen.
+            const editDocument = editRungHint ? assistEditDocumentOf(pathname != null ? pathname : '') : null;
+            const session = editDocument ? openEditorSession() : undefined;
+            const canvasOutline = editDocument && session && session.documentKind === editDocument.kind && session.documentId === editDocument.documentId && session.versionId === editDocument.versionId ? describeAssistEditCanvas(canvas, (_ref = session.selectedNodeId == null ? void 0 : session.selectedNodeId.call(session)) != null ? _ref : null) : null;
+            const response = await authorizedFetch(user, '/api/assist/chat', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify(_extends({
+                    orgId: scopedOrgId,
+                    question,
+                    history,
+                    // Page context rides along; the server drops it for free orgs
+                    // (level 2 is Pro+). Sending it is not a grant — the capability
+                    // decision is server-side.
+                    context: {
+                        route: pathname != null ? pathname : '',
+                        hostId: hostId != null ? hostId : '',
+                        orgSlug
+                    }
+                }, modelChoice.model ? {
+                    model: modelChoice.model
+                } : {}, canvasOutline ? {
+                    canvas: canvasOutline
+                } : {}))
+            });
+            if (!response.ok || !response.body) {
+                const payload = await response.json().catch(()=>null);
+                const locked = parseLockdownRefusal(response.status, payload);
+                if (locked) {
+                    failAnswer(lockdownRefusalText(locked));
+                } else if (response.status === 501) {
+                    // 501 means the narrow thing it says: no model is available AND
+                    // the documentation had nothing to offer for this question either
+                    // — the server hands back the closest pages whenever it has any
+                    // (AGL-2486), so reaching here means it had none.
+                    //
+                    // Written for the person who is actually reading it. "Not
+                    // configured on this deployment" names a deployment the reader does
+                    // not administer and a configuration they cannot see, and landing
+                    // mid-thread after a working answer it reads as a breakage. What a
+                    // user needs here is what happened, what to try, and who can fix it
+                    // — in that order, in words that assume no idea what an API key
+                    // is. The
+                    // operator's half (the env var) stays in the API error body, where
+                    // an operator looks and a customer does not.
+                    failAnswer(`I could not find anything in the documentation about that, and I cannot work it through with you myself yet — ` + `${branding.productName} Assist has not been fully switched on here. ` + `Try asking in different words, or ask whoever set up this workspace to finish enabling the assistant.`);
+                } else if ((response.status === 429 || response.status === 402) && (payload == null ? void 0 : payload.reason) === 'quota') {
+                    var _ref1;
+                    // 402 is the org's own hard cap (AGL-2653): the band would sell
+                    // past itself and this workspace switched the sale off. The
+                    // sentence names the switch, and the credit standing beside it is
+                    // as real as a 429's, so it lands on the same line.
+                    if (payload.quota) setQuota(payload.quota);
+                    publishMeter(payload == null ? void 0 : payload.meter);
+                    failAnswer(String((_ref1 = payload == null ? void 0 : payload.error) != null ? _ref1 : 'Message limit reached.'));
+                } else {
+                    var _ref2;
+                    failAnswer(String((_ref2 = payload == null ? void 0 : payload.error) != null ? _ref2 : 'The assistant request failed — try again.'));
+                }
+                return;
+            }
+            const reader = response.body.getReader();
+            const decoder = new TextDecoder();
+            let buffer = '';
+            for(;;){
+                var _lines_pop;
+                const { done, value } = await reader.read();
+                if (done) break;
+                buffer += decoder.decode(value, {
+                    stream: true
+                });
+                const lines = buffer.split('\n');
+                buffer = (_lines_pop = lines.pop()) != null ? _lines_pop : '';
+                for (const line of lines){
+                    if (!line.startsWith('data: ')) continue;
+                    let event;
+                    try {
+                        event = JSON.parse(line.slice('data: '.length));
+                    } catch (unused) {
+                        continue;
+                    }
+                    if (event.type === 'delta' && typeof event.text === 'string') {
+                        const text = event.text;
+                        patchAnswer((message)=>_extends({}, message, {
+                                text: message.text + text
+                            }));
+                    } else if (event.type === 'done') {
+                        var _event_docs, _event_proposal;
+                        const docs = (_event_docs = event.docs) != null ? _event_docs : [];
+                        // Server-resolved and inert: an id from the closed set attached
+                        // to the view the question was asked from, plus a destination
+                        // this client did not choose. Null on every turn that proposed
+                        // nothing, which is most of them.
+                        const proposal = (_event_proposal = event.proposal) != null ? _event_proposal : null;
+                        // The edit proposal (AGL-2906), shape-checked before it can reach
+                        // a card whose Apply drives the canvas.
+                        const edit = isAssistEditProposal(event.edit) ? event.edit : null;
+                        patchAnswer((message)=>{
+                            var _event_exchangeId;
+                            return _extends({}, message, {
+                                exchangeId: (_event_exchangeId = event.exchangeId) != null ? _event_exchangeId : null,
+                                docs,
+                                proposal,
+                                edit
+                            });
+                        });
+                        if (event.quota) setQuota(event.quota);
+                        publishMeter(event.meter);
+                        trackEvent('assistant_message_sent', {
+                            tier: entitled ? 'entitled' : 'free',
+                            grounded: docs.length > 0
+                        });
+                        if (proposal) {
+                            trackEvent('assistant_proposal_shown', {
+                                action: proposal.id
+                            });
+                        }
+                        if (edit) {
+                            trackEvent('assistant_proposal_shown', {
+                                action: edit.id
+                            });
+                        }
+                    } else if (event.type === 'error') {
+                        var _event_error;
+                        failAnswer(String((_event_error = event.error) != null ? _event_error : 'The assistant stream failed.'));
+                    }
+                }
+            }
+        } catch (error) {
+            console.error(error);
+            failAnswer('The assistant request failed — check your connection and try again.');
+        } finally{
+            setBusy(false);
+        }
+    }, [
+        ai.use,
+        busy,
+        editRungHint,
+        entitled,
+        hostId,
+        input,
+        messages,
+        modelChoice.model,
+        publishMeter,
+        scopedOrgId,
+        orgSlug,
+        pathname,
+        user
+    ]);
+    /**
+   * Retire a card once it has been acted on or waved away. Local state only
+   * — there is nothing to tell the server, because the proposal was never
+   * anything the server was waiting on.
+   */ const resolveProposal = useCallback((index)=>{
+        setMessages((prior)=>prior.map((entry, i)=>i === index ? _extends({}, entry, {
+                    proposalResolved: true
+                }) : entry));
+    }, []);
+    /**
+   * Land a confirmed edit on the open editor (AGL-2906): through the canvas's
+   * own mutators, as one undo step, unsaved. The only request that follows is
+   * the activity record, and it carries counts, never content.
+   */ const applyEdit = useCallback((index)=>{
+        const message = messages[index];
+        const proposal = message == null ? void 0 : message.edit;
+        if (!proposal || !scopedOrgId) return;
+        const session = openEditorSession();
+        const result = applyAssistEdit(canvas, proposal, session);
+        if (result.ok === false) {
+            setMessages((prior)=>prior.map((entry, i)=>i === index ? _extends({}, entry, {
+                        editOutcome: {
+                            kind: 'failed',
+                            message: result.message
+                        }
+                    }) : entry));
+            return;
+        }
+        setMessages((prior)=>prior.map((entry, i)=>i === index ? _extends({}, entry, {
+                    editOutcome: {
+                        kind: 'applied'
+                    }
+                }) : entry));
+        trackEvent('assistant_proposal_confirmed', {
+            action: proposal.id
+        });
+        enqueueSnackbar('Applied as unsaved changes — undo takes them back', {
+            variant: 'success',
+            persist: false
+        });
+        if (!message.exchangeId || !session) return;
+        const report = {
+            orgId: scopedOrgId,
+            hostId: proposal.target.hostId,
+            exchangeId: message.exchangeId,
+            documentKind: proposal.target.kind,
+            documentId: proposal.target.documentId,
+            versionId: session.versionId,
+            opCounts: result.opCounts
+        };
+        // Fire and forget: the edit is already on the canvas, and a record that
+        // fails to land must not read as an edit that failed.
+        void authorizedFetch(user, '/api/assist/edit-applied', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json'
+            },
+            body: JSON.stringify(report)
+        }).catch(()=>undefined);
+    }, [
+        enqueueSnackbar,
+        messages,
+        scopedOrgId,
+        user
+    ]);
+    /** Wave an edit card away. Nothing to tell the server: nothing happened. */ const dismissEdit = useCallback((index)=>{
+        setMessages((prior)=>prior.map((entry, i)=>i === index ? _extends({}, entry, {
+                    editOutcome: {
+                        kind: 'dismissed'
+                    }
+                }) : entry));
+    }, []);
+    const sendFeedback = useCallback(async (index, feedback)=>{
+        const message = messages[index];
+        if (!(message == null ? void 0 : message.exchangeId) || !scopedOrgId) return;
+        setMessages((prior)=>prior.map((entry, i)=>i === index ? _extends({}, entry, {
+                    feedback
+                }) : entry));
+        trackEvent('assistant_feedback', {
+            feedback
+        });
+        try {
+            await authorizedFetch(user, '/api/assist/feedback', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json'
+                },
+                body: JSON.stringify({
+                    orgId: scopedOrgId,
+                    exchangeId: message.exchangeId,
+                    feedback
+                })
+            });
+        } catch (unused) {
+            enqueueSnackbar('Feedback could not be recorded', {
+                variant: 'warning',
+                persist: false
+            });
+        }
+    }, [
+        enqueueSnackbar,
+        messages,
+        scopedOrgId,
+        user
+    ]);
+    // A released-off feature does not exist (staff preview excepted) — and
+    // without an org IN SCOPE there is nothing to meter or record against
+    // (AGL-1934). `scopedOrgId`, never `orgId`: the fallback org is always
+    // present, which is exactly why gating on it announced and billed the
+    // assistant on the workspace picker. Every hook above has already run, so
+    // this early return costs no hook-order hazard.
+    if (!verdict.visible || !scopedOrgId) return null;
+    return /*#__PURE__*/ _jsxs(_Fragment, {
+        children: [
+            !open && /*#__PURE__*/ _jsx(Tooltip, {
+                title: `${branding.productName} Assist`,
+                placement: "left",
+                children: /*#__PURE__*/ _jsx(Fab, {
+                    color: "primary",
+                    size: "medium",
+                    "aria-label": `Open ${branding.productName} Assist`,
+                    onClick: ()=>setOpen(true),
+                    sx: {
+                        position: 'fixed',
+                        // Insets, not constants (AGL-2486). The console chrome leaves
+                        // the bottom-right corner empty, but the besigner does not:
+                        // its properties panel is a full-height column on that edge,
+                        // and a fixed launcher lands on the Styles form and its
+                        // scrollbar. A surface that owns the corner publishes these
+                        // variables to move the launcher clear of itself; everywhere
+                        // else the fallback is the corner it has always used. Read as
+                        // CSS rather than passed as props so the offset can follow a
+                        // panel the launcher knows nothing about — one that is
+                        // resizable and collapsible — without this component growing
+                        // a dependency on the editor.
+                        right: 'var(--aglyn-assist-inset-right, 20px)',
+                        bottom: 'var(--aglyn-assist-inset-bottom, 20px)',
+                        zIndex: (theme)=>theme.zIndex.drawer - 1
+                    },
+                    children: /*#__PURE__*/ _jsx(MdiIcon, {
+                        path: mdiChatQuestionOutline.path,
+                        fontSize: "medium"
+                    })
+                })
+            }),
+            /*#__PURE__*/ _jsx(Drawer, {
+                anchor: "right",
+                open: open,
+                onClose: ()=>setOpen(false),
+                slotProps: {
+                    paper: {
+                        sx: {
+                            width: {
+                                xs: '100%',
+                                sm: 420
+                            },
+                            display: 'flex'
+                        }
+                    }
+                },
+                children: /*#__PURE__*/ _jsxs(Stack, {
+                    sx: {
+                        height: '100%'
+                    },
+                    children: [
+                        /*#__PURE__*/ _jsxs(Stack, {
+                            direction: "row",
+                            spacing: 1,
+                            sx: {
+                                px: 2,
+                                py: 1.5,
+                                borderBottom: 1,
+                                borderColor: 'divider',
+                                alignItems: 'center'
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(MdiIcon, {
+                                    path: mdiChatQuestionOutline.path,
+                                    fontSize: "medium"
+                                }),
+                                /*#__PURE__*/ _jsx(Typography, {
+                                    variant: "h6",
+                                    sx: {
+                                        flexGrow: 1
+                                    },
+                                    children: `${branding.productName} Assist`
+                                }),
+                                verdict.staffPreview && /*#__PURE__*/ _jsx(Chip, {
+                                    size: "small",
+                                    color: "warning",
+                                    label: "Staff preview"
+                                }),
+                                /*#__PURE__*/ _jsx(HelpTip, _extends({}, pluginDocsHelp('aglynAssist', {
+                                    anchor: '#what-it-can-do'
+                                }), {
+                                    sx: {
+                                        color: 'text.secondary'
+                                    }
+                                })),
+                                /*#__PURE__*/ _jsx(Tooltip, {
+                                    title: `Close ${branding.productName} Assist`,
+                                    children: /*#__PURE__*/ _jsx(IconButton, {
+                                        "aria-label": `Close ${branding.productName} Assist`,
+                                        onClick: ()=>setOpen(false),
+                                        children: /*#__PURE__*/ _jsx(MdiIcon, {
+                                            path: mdiClose.path,
+                                            fontSize: "medium"
+                                        })
+                                    })
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ _jsxs(Box, {
+                            ref: scrollRef,
+                            sx: {
+                                flexGrow: 1,
+                                overflowY: 'auto',
+                                p: 2
+                            },
+                            children: [
+                                /*#__PURE__*/ _jsx(AssistJobsDrawer, {
+                                    orgId: scopedOrgId,
+                                    org: org,
+                                    orgReady: orgReady,
+                                    orgSlug: billingSlug,
+                                    user: user,
+                                    visible: generativeVisible,
+                                    isStaff: isStaff,
+                                    hostId: hostId,
+                                    // A question about the figures, where the page reports them
+                                    // (AGL-2915); hidden with the rest of AI jobs, and refused by
+                                    // the jobs door where the member may not generate.
+                                    insight: ai.generate ? aiInsightSurfaceForPath(pathname) : null
+                                }),
+                                !messages.length && /*#__PURE__*/ _jsxs(Alert, {
+                                    severity: "info",
+                                    sx: {
+                                        mb: 2
+                                    },
+                                    children: [
+                                        `Ask anything about using ${branding.productName} — building `,
+                                        'your site, publishing, domains, commerce, billing. Answers ',
+                                        'link the docs and the console page to use.',
+                                        orgReady && !entitled && !isStaff && /*#__PURE__*/ _jsxs(_Fragment, {
+                                            children: [
+                                                ' ',
+                                                "Free workspaces get a limited number of messages a day; Pro adds page-aware guidance."
+                                            ]
+                                        })
+                                    ]
+                                }),
+                                /*#__PURE__*/ _jsx(Stack, {
+                                    spacing: 1.5,
+                                    children: messages.map((message, index)=>{
+                                        var _message_editOutcome, _message_editOutcome1, _message_editOutcome2, _message_editOutcome3;
+                                        return /*#__PURE__*/ _jsxs(Box, {
+                                            sx: {
+                                                alignSelf: message.role === 'user' ? 'flex-end' : 'flex-start',
+                                                maxWidth: '90%',
+                                                borderRadius: 2,
+                                                px: 1.5,
+                                                py: 1,
+                                                bgcolor: message.role === 'user' ? 'primary.main' : 'action.hover',
+                                                color: message.role === 'user' ? 'primary.contrastText' : 'text.primary'
+                                            },
+                                            children: [
+                                                /*#__PURE__*/ _jsx(Typography, {
+                                                    variant: "body2",
+                                                    component: "div",
+                                                    sx: {
+                                                        whiteSpace: 'pre-wrap',
+                                                        wordBreak: 'break-word'
+                                                    },
+                                                    children: message.role === 'assistant' ? message.text ? renderAssistText(splitAssistDisclosure(message.text).plain) : /*#__PURE__*/ _jsx(CircularProgress, {
+                                                        size: 14
+                                                    }) : message.text
+                                                }),
+                                                message.role === 'assistant' && splitAssistDisclosure(message.text).technical && /*#__PURE__*/ _jsx(UnderTheHood, {
+                                                    technical: splitAssistDisclosure(message.text).technical
+                                                }),
+                                                message.role === 'assistant' && /*#__PURE__*/ _jsx(AssistSources, {
+                                                    text: message.text,
+                                                    docs: message.docs
+                                                }),
+                                                message.role === 'assistant' && message.proposal && !message.proposalResolved && /*#__PURE__*/ _jsx(ProposalCard, {
+                                                    proposal: message.proposal,
+                                                    brand: productName,
+                                                    onConfirm: ()=>{
+                                                        var _ref;
+                                                        var _message_proposal;
+                                                        trackEvent('assistant_proposal_confirmed', {
+                                                            action: (_ref = (_message_proposal = message.proposal) == null ? void 0 : _message_proposal.id) != null ? _ref : ''
+                                                        });
+                                                        resolveProposal(index);
+                                                        setOpen(false);
+                                                    },
+                                                    onDismiss: ()=>resolveProposal(index)
+                                                }),
+                                                message.role === 'assistant' && message.edit && ((_message_editOutcome = message.editOutcome) == null ? void 0 : _message_editOutcome.kind) !== 'dismissed' && ((_message_editOutcome1 = message.editOutcome) == null ? void 0 : _message_editOutcome1.kind) !== 'applied' && /*#__PURE__*/ _jsx(AssistEditCard, {
+                                                    proposal: message.edit,
+                                                    brand: productName,
+                                                    session: editorSession,
+                                                    failure: ((_message_editOutcome2 = message.editOutcome) == null ? void 0 : _message_editOutcome2.kind) === 'failed' ? message.editOutcome.message : null,
+                                                    onApply: ()=>applyEdit(index),
+                                                    onCreateVersion: ()=>{
+                                                        var _editorSession_createVersion;
+                                                        return editorSession == null ? void 0 : (_editorSession_createVersion = editorSession.createVersion) == null ? void 0 : _editorSession_createVersion.call(editorSession);
+                                                    },
+                                                    onDismiss: ()=>dismissEdit(index)
+                                                }),
+                                                message.role === 'assistant' && ((_message_editOutcome3 = message.editOutcome) == null ? void 0 : _message_editOutcome3.kind) === 'applied' && /*#__PURE__*/ _jsx(Typography, {
+                                                    variant: "caption",
+                                                    color: "text.secondary",
+                                                    component: "div",
+                                                    sx: {
+                                                        mt: 0.5
+                                                    },
+                                                    children: "Applied to the canvas as unsaved changes."
+                                                }),
+                                                message.role === 'assistant' && message.exchangeId && /*#__PURE__*/ _jsxs(Stack, {
+                                                    direction: "row",
+                                                    spacing: 0.5,
+                                                    sx: {
+                                                        mt: 0.5
+                                                    },
+                                                    children: [
+                                                        /*#__PURE__*/ _jsx(Tooltip, {
+                                                            title: message.feedback ? 'Thanks — you already rated this answer' : 'Helpful answer',
+                                                            children: /*#__PURE__*/ _jsx("span", {
+                                                                children: /*#__PURE__*/ _jsx(IconButton, {
+                                                                    size: "small",
+                                                                    "aria-label": "Helpful answer",
+                                                                    color: message.feedback === 'up' ? 'primary' : 'default',
+                                                                    disabled: Boolean(message.feedback),
+                                                                    onClick: ()=>void sendFeedback(index, 'up'),
+                                                                    children: /*#__PURE__*/ _jsx(MdiIcon, {
+                                                                        path: mdiThumbUpOutline.path,
+                                                                        sx: {
+                                                                            fontSize: 16
+                                                                        }
+                                                                    })
+                                                                })
+                                                            })
+                                                        }),
+                                                        /*#__PURE__*/ _jsx(Tooltip, {
+                                                            title: message.feedback ? 'Thanks — you already rated this answer' : 'Unhelpful answer',
+                                                            children: /*#__PURE__*/ _jsx("span", {
+                                                                children: /*#__PURE__*/ _jsx(IconButton, {
+                                                                    size: "small",
+                                                                    "aria-label": "Unhelpful answer",
+                                                                    color: message.feedback === 'down' ? 'primary' : 'default',
+                                                                    disabled: Boolean(message.feedback),
+                                                                    onClick: ()=>void sendFeedback(index, 'down'),
+                                                                    children: /*#__PURE__*/ _jsx(MdiIcon, {
+                                                                        path: mdiThumbDownOutline.path,
+                                                                        sx: {
+                                                                            fontSize: 16
+                                                                        }
+                                                                    })
+                                                                })
+                                                            })
+                                                        })
+                                                    ]
+                                                })
+                                            ]
+                                        }, index);
+                                    })
+                                })
+                            ]
+                        }),
+                        /*#__PURE__*/ _jsxs(Stack, {
+                            spacing: 1,
+                            sx: {
+                                p: 2,
+                                borderTop: 1,
+                                borderColor: 'divider'
+                            },
+                            children: [
+                                ai.loaded && !ai.use ? /*#__PURE__*/ _jsx(Typography, {
+                                    variant: "caption",
+                                    color: "text.secondary",
+                                    children: 'Your role does not include the assistant — ask an ' + 'organization admin to grant "Use AI assistance".'
+                                }) : null,
+                                /*#__PURE__*/ _jsx(AiUsageStrip, {
+                                    orgId: scopedOrgId,
+                                    orgSlug: billingSlug
+                                }),
+                                quota && quota.period === 'day' && /*#__PURE__*/ _jsxs(Typography, {
+                                    variant: "caption",
+                                    color: "text.secondary",
+                                    children: [
+                                        quota.remaining,
+                                        " of ",
+                                        quota.limit,
+                                        " free messages left today",
+                                        billingSlug ? /*#__PURE__*/ _jsxs(_Fragment, {
+                                            children: [
+                                                ' — ',
+                                                /*#__PURE__*/ _jsx(AppLink, {
+                                                    componentVariant: "naked",
+                                                    href: `/${billingSlug}/billing`,
+                                                    children: "upgrade for more"
+                                                })
+                                            ]
+                                        }) : null
+                                    ]
+                                }),
+                                entitled ? /*#__PURE__*/ _jsx(Stack, {
+                                    direction: "row",
+                                    sx: {
+                                        justifyContent: 'flex-end',
+                                        mb: -0.5
+                                    },
+                                    children: /*#__PURE__*/ _jsx(AiModelSelector, {
+                                        choice: modelChoice,
+                                        disabled: busy || !ai.loaded || !ai.use
+                                    })
+                                }) : null,
+                                /*#__PURE__*/ _jsxs(Stack, {
+                                    direction: "row",
+                                    spacing: 1,
+                                    sx: {
+                                        alignItems: 'flex-end'
+                                    },
+                                    children: [
+                                        /*#__PURE__*/ _jsx(TextField, {
+                                            fullWidth: true,
+                                            multiline: true,
+                                            maxRows: 4,
+                                            size: "small",
+                                            placeholder: "How do I…",
+                                            value: input,
+                                            disabled: busy || !ai.loaded || !ai.use,
+                                            onChange: (event)=>setInput(event.target.value),
+                                            onKeyDown: (event)=>{
+                                                if (event.key === 'Enter' && !event.shiftKey) {
+                                                    event.preventDefault();
+                                                    void send();
+                                                }
+                                            }
+                                        }),
+                                        /*#__PURE__*/ _jsx(Tooltip, {
+                                            title: busy ? 'Waiting for an answer…' : !ai.loaded ? 'Checking your permissions…' : !ai.use ? 'Your role does not include the assistant' : 'Send message',
+                                            children: /*#__PURE__*/ _jsx("span", {
+                                                children: /*#__PURE__*/ _jsx(IconButton, {
+                                                    color: "primary",
+                                                    "aria-label": "Send message",
+                                                    disabled: busy || !input.trim() || !ai.loaded || !ai.use,
+                                                    onClick: ()=>void send(),
+                                                    children: busy ? /*#__PURE__*/ _jsx(CircularProgress, {
+                                                        size: 20
+                                                    }) : // 20px to match the CircularProgress it swaps with
+                                                    // on the line above — at the inherited 14px the
+                                                    // button visibly grew its contents while busy.
+                                                    /*#__PURE__*/ _jsx(MdiIcon, {
+                                                        path: mdiSend.path,
+                                                        sx: {
+                                                            fontSize: 20
+                                                        }
+                                                    })
+                                                })
+                                            })
+                                        })
+                                    ]
+                                })
+                            ]
+                        })
+                    ]
+                })
+            })
+        ]
+    });
+}
+export default AssistPanelComponent;
+
+//# sourceMappingURL=assist-panel.component.js.map