@wix/himalaya-cli 0.970.0 → 0.972.0

package/templates/nonprofit-cause-owner/tier5-src/_shared/aria-chat.ts

@@ -89,6 +89,19 @@ export interface AriaChatState {
   error: string;
   /** Bound seed for the composer field. */
   input: string;
+  /** Transient result of the last Copy: the confirmation, or the failure.
+   *
+   *  It exists because `writeText` resolves or throws and NOTHING else in the
+   *  state changes either way — so without this the owner cannot tell a copy
+   *  that took from one the platform refused. Saying "Copied" when nothing
+   *  reached the clipboard is a known way for a copy control to lie; this is
+   *  the field that makes the difference observable. */
+  copyNote: string;
+  /** Collapses the Copy / Regenerate row. Derived, like `stopHidden`: shown
+   *  only when the newest bubble is a REPLY (not the owner's message, not the
+   *  local greeting) and no turn is out. A pure function of other fields, so it
+   *  is computed once in `gated` rather than maintained by every reducer. */
+  replyActionsHidden: boolean;
   messages: AriaBubble[];
   /** Non-empty ONLY on the greeting-only empty state. */
   prompts: AriaPromptChip[];
@@ -199,6 +212,12 @@ export interface AriaChatLabels {
   /** Status line after the owner stopped a reply. Sits in the NEUTRAL slot:
    *  they asked for it, so nothing went wrong. */
   stopped?: Resolvable<string>;
+  /** Shown after a clipboard write that RESOLVED. */
+  copied?: Resolvable<string>;
+  /** Shown after a clipboard write that threw, or when the host supplied no
+   *  clipboard at all. Deliberately distinct from `copied`: the point of the
+   *  pair is that the owner can tell which of the two happened. */
+  copyFailed?: Resolvable<string>;
   /** Shown under a picker once the owner has chosen as many options as the
    *  service allows. Takes the limit, because "pick up to 3" is the whole of
    *  the information. */
@@ -242,6 +261,13 @@ export interface AriaChatOptions {
   /** Opens an external URL. Apps whose descriptors carry their own open-url
    *  action (the clone) leave this unset and never invoke `openLink`. */
   openLink?: (url: string) => Promise<boolean>;
+
+  /** Put `text` on the system clipboard. Injected rather than imported so the
+   *  shared core stays free of the SDK, exactly as `openLink` is.
+   *
+   *  It RESOLVES or THROWS — there is no boolean. A host that does not supply
+   *  it has no clipboard, and `copyMessage` says so rather than pretending. */
+  copyText?: (text: string) => Promise<void>;
   /** Maps an Aria action-link URL to an in-app screen. A hit navigates via a
    *  `_nav` directive — the host applies the same linkable-target check an
    *  authored `himi.open` gets — and a miss falls through to `openLink`. */
@@ -559,7 +585,10 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
       // way, and an aborted turn consists of nothing else. Then envelopes, then
       // the markdown stripper — each stage handing on only what a reader should
       // actually see.
-      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, true).parts);
+      // A row the service is still writing is scanned as STREAMING: an
+      // envelope whose `>>` has not arrived yet is held back rather than
+      // painted as raw JSON until the row finishes.
+      const prose = role === "USER" ? raw : proseOfParts(scanEnvelopes(stripHidden(raw), 0, !stillWriting(m)).parts);
       return {
         id: m.id || `m${i}`,
         role,
@@ -573,6 +602,16 @@ export function toBubbles(msgs: ConversationMessage[], assistantName: string, yo
     .filter((b) => b.content && b.content.trim());
 }
 
+/** The reply the Copy / Regenerate row acts on: the LAST bubble, when it is an
+ *  answer. Not "the newest assistant bubble": a widget-only answer leaves no
+ *  bubble, so the transcript then ends on the owner's question, and searching
+ *  back past it would offer the previous turn's answer as if it were this one.
+ *  The greeting is excluded because it is a local bubble, not a reply. */
+function lastReply(s: { messages: AriaBubble[] }): AriaBubble | undefined {
+  const last = s.messages[s.messages.length - 1];
+  return last && last.notUser && last.id !== GREETING_ID ? last : undefined;
+}
+
 /** Chips are visible only before the owner has said anything. */
 function promptsFor(msgs: AriaBubble[], prompts: AriaPromptChip[]): AriaPromptChip[] {
   return msgs.some((b) => b.role === "USER") ? [] : prompts;
@@ -653,6 +692,29 @@ function answerText(m: ConversationMessage): string {
   return stripHidden(messageText(m)).trim();
 }
 
+/** Is the service still WRITING this assistant row?
+ *
+ *  The chat-service stamps every message with a status, and an ASSISTANT row
+ *  that is `STATUS_PENDING` holds a draft: the agent has started the reply and
+ *  not finished it. Whatever text it carries is worth PAINTING — it is the only
+ *  view of a reply in progress a worker has, since the words themselves stream
+ *  over a socket no host exposes (see the genie-chat client's header) — but it
+ *  is not the answer, and ending the turn on it is the bug this exists for: the
+ *  typing line clears, Stop disappears while the agent is still writing, and the
+ *  ladder drops to its idle rung, so the rest of the reply sits unseen for a
+ *  whole idle interval. The native Aria app ends a turn only on
+ *  `STATUS_COMPLETED`, for the same reason.
+ *
+ *  Only an explicit PENDING counts. An absent or unrecognised status is
+ *  "settled": no capture in this repo has ever shown the field, and a gate that
+ *  demanded `STATUS_COMPLETED` would hang every turn on a service that simply
+ *  does not send it. Callers apply it to ASSISTANT rows only: a USER row is
+ *  counted to retire the optimistic bubble, and holding one back would paint
+ *  the owner's words twice. */
+function stillWriting(m: ConversationMessage): boolean {
+  return m.status === "STATUS_PENDING";
+}
+
 export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean | null {
   if (!turnId) return null;
   const at = msgs.findIndex((m) => m.id === turnId);
@@ -665,7 +727,9 @@ export function repliedTo(msgs: ConversationMessage[], turnId: string): boolean
   for (let i = at + 1; i < msgs.length; i++) {
     const m = msgs[i];
     if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
-    if (answerText(m)) return true;
+    // A row still being written is not the answer yet — keep looking, since
+    // the finished answer can land in a later row of the same turn.
+    if (answerText(m) && !stillWriting(m)) return true;
   }
   return false;
 }
@@ -700,6 +764,26 @@ export function countTurns(msgs: ConversationMessage[], role: string): number {
   return n;
 }
 
+/** How many FINISHED assistant answers the transcript holds — `countTurns`
+ *  minus the rows the service is still writing (`stillWriting`).
+ *
+ *  The counted path compares THIS against a mark taken with `countTurns`, and
+ *  the asymmetry is the point. The mark includes drafts, so a follow-up sent
+ *  while an earlier reply is still being written is marked AFTER that reply;
+ *  the earlier reply finishing then leaves this count equal to the mark rather
+ *  than past it, and cannot end the new turn. Were the mark taken without
+ *  drafts too, that finish would read as the new turn's answer. And a draft
+ *  of the turn's OWN answer is not counted here, so it does not end the turn
+ *  either — the same rule `repliedTo` applies on the exact path. */
+export function countSettledAnswers(msgs: ConversationMessage[]): number {
+  let n = 0;
+  for (const m of msgs) {
+    if ((m.role || "ASSISTANT") !== "ASSISTANT") continue;
+    if (answerText(m) && !stillWriting(m)) n++;
+  }
+  return n;
+}
+
 /** Has the turn stored under `userMessageId` already been answered?
  *
  *  Per-TURN, and that is the entire point. A COUNT of assistant replies says
@@ -749,6 +833,12 @@ export function turnAnswered(msgs: ConversationMessage[], userMessageId: string)
     // exactly these two, and the two scanners read the same transcript: if they
     // disagree, one of them ends the turn while the other leaves the ladder
     // running at the fast cadence.
+    //
+    // They DO part on one case, deliberately: a row the service is still
+    // writing (`stillWriting`). That does not end a turn, but it IS proof the
+    // trigger landed — the agent is answering — so re-triggering the stored id
+    // here would have it answer the same turn twice. The ladder never reads
+    // this scanner, so the split cannot pin it fast.
     if (role === "ASSISTANT" && answerText(m)) return true;
   }
   return false;
@@ -845,6 +935,24 @@ export interface AriaChatCore {
    *  that moved during the abort makes this snapshot stale, and committing it
    *  would end a turn the owner has since started. */
   stop(s: AriaChatState): Promise<AriaChatState | undefined>;
+
+  /** Put one reply's prose on the clipboard. Defaults to the newest assistant
+   *  bubble, which is the only one the descriptor offers the control on.
+   *
+   *  Copies `bubble.content`, which is ALREADY the normalized prose — the
+   *  envelope scan and the markdown stripper both ran on the way in
+   *  (`bubblesFrom`), so the owner gets what they can read rather than the
+   *  wire text. */
+  /** `undefined` when the turn moved on while the write was out — see `stop`. */
+  copyMessage(s: AriaChatState, arg?: AriaActionArg): Promise<AriaChatState | undefined>;
+
+  /** Ask for another answer.
+   *
+   *  NOT a protocol feature: it sends ordinary user text, the same literal the
+   *  native Aria app sends, through the one send path (`send`). Not through
+   *  `submit`: with no argument that reads the COMPOSER, so a regenerate would
+   *  send whatever the owner had half-typed instead of the retry. */
+  regenerate(s: AriaChatState): Promise<AriaChatState>;
   /** Tapping the active widget's primary / secondary footer button.
    *
    *  The url is read from STATE rather than bound into the action's params.
@@ -880,6 +988,10 @@ export interface AriaChatCore {
 }
 
 const POLL_ID = "aria-turn";
+/** What Regenerate sends. Ordinary user text, matching the native Aria app —
+ *  the chat-service has no retry verb, and inventing one here would be a
+ *  protocol we then had to keep. */
+const REGENERATE_TEXT = "Let's try that again.";
 /** Id of the local greeting bubble. Shared by the minting and the
  *  "is it still the empty state?" test so the two cannot drift apart. */
 const GREETING_ID = "greeting";
@@ -915,7 +1027,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
   const localHistory = o.localHistory !== false;
 
   const initialState: AriaChatState = {
-    status: "loading", statusText: "", error: "", input: "",
+    status: "loading", statusText: "", error: "", input: "", copyNote: "", replyActionsHidden: true,
     messages: [], prompts: [], _convId: "", _siteId: "", _pending: "",
     _pendingAfter: 0, _replyAfter: 0, _srvUsers: 0, _srvAssistants: 0,
     _abortId: "", _turnId: "", stopHidden: true, ok: false,
@@ -966,6 +1078,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  those. `submitting` stays on the state because the descriptor needs
    *  something to disable a button with; it is the shadow, not the guard. */
   let widgetSending = false;
+  /** A regenerate is on its way. Refuses a double-tap in the window before
+   *  `send` has written `_pending` — the same window `widgetSending` next door
+   *  closes for two taps of one option. */
+  let regenerating = false;
 
   /** A turn the server STORED but never got asked to answer.
    *
@@ -1093,7 +1209,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // both; the widget path did neither.
     widget: carrySelection(
       activeWidgetOf(
-        msgs.map((m) => ({ role: m.role, content: stripHidden(messageText(m)) })),
+        // A draft offers no controls: the agent has not finished asking, and
+        // an answer tapped now would start a second turn on top of this one.
+        // An empty newest row is NO_WIDGET — the placeholder rule.
+        msgs.map((m) => ({ role: m.role, content: stillWriting(m) ? "" : stripHidden(messageText(m)) })),
         disclosedLabel,
         o.subtree,
         (url) => isWixMediaHost(hostOf(url)),
@@ -1158,7 +1277,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       // widget-only reply is, even though it leaves no bubble to inspect. Asking
       // the last BUBBLE stalled this loop on exactly that reply, the same way it
       // stalled `tick`.
-      if (repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter) {
+      if (repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter) {
         return { ...s, status: "ready", _convId: convId, messages: bubbles, prompts: [], input: "", statusText: "", error: "", _pending: "", ...observed(raw, s.widget), ok: false };
       }
     }
@@ -1188,7 +1307,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     // state this action RETURNS, so on the `_poll` path they paint immediately.
     const optimistic: AriaBubble[] = [...s.messages, plainBubble(`u${s.messages.length}`, "USER", you(), content)];
     const base: AriaChatState = {
-      ...s, prompts: [], input: "", error: "",
+      // `copyNote: ""` — a Copy confirmation belongs to the moment, and a new
+      // turn ends it. Left in place it would sit under the next reply saying
+      // "Copied" about text the owner copied several turns ago.
+      ...s, prompts: [], input: "", error: "", copyNote: "",
       // The PREVIOUS turn's handles must not survive into this one: aborting by
       // a stale id would abandon a reply that has already been read, and waiting
       // on a stale turn id would look for an answer that already exists. Both
@@ -1410,9 +1532,36 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
    *  function of two other fields, and eight reducers each remembering to set it
    *  is eight chances for the control to be shown when there is nothing to stop
    *  — or, worse, hidden while a reply the owner wants to abandon runs on. */
+  let committed: AriaChatState | null = null;
+  let commits = 0;
+  /** A result as the runtime stores it: the one-shot directives it strips on
+   *  commit (`_stream`, `_nav`, `_poll`, `_error` — see `applyNext` in the web
+   *  host's runtime bootstrap) removed. */
+  const settled = (s: AriaChatState): AriaChatState => {
+    const r = s as AriaChatState & Record<string, unknown>;
+    if (r._stream === undefined && r._nav === undefined && r._poll === undefined && r._error === undefined) return s;
+    const { _stream: _a, _nav: _b, _poll: _c, _error: _d, ...rest } = r;
+    return rest as AriaChatState;
+  };
   const gated = (s: AriaChatState): AriaChatState => {
     const hidden = !(turnInFlight(s) && !!s._abortId);
-    return s.stopHidden === hidden ? s : { ...s, stopHidden: hidden };
+    // The reply actions follow the same rule for the same reason: a derived
+    // flag, recomputed on every action's way out, so no reducer can forget it.
+    // `_pending` rather than `turnInFlight` — see `regenerate` for why `status`
+    // is not trusted to have been cleared.
+    const replyActionsHidden = !(lastReply(s) && !s._pending);
+    const out = s.stopHidden === hidden && s.replyActionsHidden === replyActionsHidden
+      ? s
+      : { ...s, stopHidden: hidden, replyActionsHidden };
+    // Every state the runtime commits passes through here (an `undefined`
+    // result commits nothing and skips it), so this is the newest committed
+    // state — what `copyMessage` puts its note on when other actions landed
+    // while its write was out. Kept as the runtime STORES it, i.e. without the
+    // transient directives it strips on commit: re-returning a `_nav` or a
+    // `_poll` from here would navigate, or re-arm the timer, a second time.
+    committed = settled(out);
+    commits += 1;
+    return out;
   };
 
   /** Ask the service how an async job is getting on.
@@ -1550,7 +1699,10 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
           const raw = messagesOf(gm);
           const bubbles = toBubbles(raw, assistant(), you());
           const resumed = bubbles.length ? bubbles : greetingOnly();
-          return { ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "",
+          // `copyNote: ""` — a resumed transcript ends in a reply, so the row is
+          // shown at once; a note carried over would say "Copied" beside an
+          // answer from a different conversation that nobody copied.
+          return { ...s, status: "ready", _convId: resumeId, _siteId: site, _pending: "", statusText: "", error: "", copyNote: "",
             messages: resumed, ...observed(raw, s.widget), prompts: promptsFor(resumed, promptList()) };
         } catch { /* expired or unreachable — fall through to a fresh one */ }
       }
@@ -1649,11 +1801,11 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // previous one, which reads as ➕ having done nothing.
         turnSeq += 1;
         return slow({ ...s, status: "ready", _convId: conversationIdOf(res), _siteId: site, input: "", statusText: "", error: "",
-          _pending: "", _abortId: "", _turnId: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
+          _pending: "", _abortId: "", _turnId: "", copyNote: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
       } catch (e) {
         turnSeq += 1;   // see above — a failed create commits state too
         return slow({ ...s, status: "ready", _convId: "", _siteId: site, input: "", ...failureSlots(e, unavailableText),
-          _pending: "", _abortId: "", _turnId: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
+          _pending: "", _abortId: "", _turnId: "", copyNote: "", messages: greetingOnly(), ...observed([]), prompts: promptList(), ok: false });
       }
     },
 
@@ -1709,7 +1861,7 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
         // Counted over RAW messages, so a widget-only answer still ends the turn
         // instead of pinning the ladder to its fast rung forever (`countTurns`).
         // Exact when the service named the turn, counted when it did not.
-        const replied = repliedTo(raw, s._turnId) ?? countTurns(raw, "ASSISTANT") > s._replyAfter;
+        const replied = repliedTo(raw, s._turnId) ?? countSettledAnswers(raw) > s._replyAfter;
         const next: AriaChatState = {
           ...s,
           status: replied ? "ready" : s.status,
@@ -1972,6 +2124,79 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
       return slow(withDraft(
         { ...s, status: "ready", statusText: stoppedText(), error: "", _pending: "", _abortId: "" }, typedAt));
     },
+
+    copyMessage: async (s, arg) => {
+      // Which bubble. The descriptor offers Copy on the newest assistant reply,
+      // so the id is optional and that bubble is the default — but an id IS
+      // accepted, because a row-scoped control passing `$item.id` is the
+      // established shape on this screen (the link rows do exactly that).
+      const wanted = typeof arg === "object" && arg !== null ? String((arg as { id?: string }).id ?? "") : "";
+      const target = wanted
+        ? s.messages.find((m) => m.id === wanted)
+        // The LAST bubble, and only if it is a reply — the same test `gated`
+        // shows the row on. Searching back for the newest reply instead would,
+        // after a widget-only answer (which leaves no bubble), skip over the
+        // owner's question and copy the answer to the turn BEFORE it. The
+        // greeting is excluded because it is a local bubble, not a reply.
+        : lastReply(s);
+      // `content` is ALREADY the prose: `bubblesFrom` scans the widget envelope
+      // out first and then strips markdown, so this is what the owner can read
+      // rather than the wire text.
+      const text = (target?.content ?? "").trim();
+      const failed = () => res(o.labels?.copyFailed ?? "Couldn't copy");
+      if (!text) return { ...s, copyNote: failed() };
+      // No clipboard on this host: say so, rather than report a success that
+      // never happened. Same rule as the throw below.
+      if (!o.copyText) return { ...s, copyNote: failed() };
+      // Read BEFORE the await, compared after: `s` is a pre-await snapshot,
+      // and the runtime commits the whole returned state. Two cases.
+      //  - A send or + moved the turn boundary: the note is about a reply that
+      //    is gone, so stand down and commit nothing (as `stop` does).
+      //  - Anything else landed — a keystroke, a widget selection, a query —
+      //    so `{ ...s }` would silently undo it. Put the note on the newest
+      //    COMMITTED state instead of on the snapshot.
+      const seq = turnSeq;
+      const at = commits;
+      let note: string;
+      try {
+        await o.copyText(text);
+        note = res(o.labels?.copied ?? "Copied");
+      } catch {
+        // The web Async Clipboard API rejects without a user gesture, and
+        // Android refuses while the app is unfocused. Both land here, and both
+        // are a FAILURE the owner is told about.
+        note = failed();
+      }
+      if (turnSeq !== seq) return undefined;
+      // No separate guard for a resume: `load` resumes only when the screen
+      // holds no live conversation, and a Copy row exists only under a reply
+      // in one — so a resume cannot land while a Copy is out. (The nav input
+      // and site are fixed for a worker's life; a site switch boots a new one.)
+      return { ...(commits !== at && committed ? committed : s), copyNote: note };
+    },
+
+    regenerate: async (s) => {
+      // Refuse a double-tap, and refuse while a reply is still coming — there
+      // is nothing to regenerate until the last one has landed.
+      // `_pending` rather than `turnInFlight`, and the difference is load-bearing.
+      // `turnInFlight` is `status === "sending" || !!_pending`, and `status` can
+      // still read "sending" after a turn has actually closed — a tick whose read
+      // straddled a turn boundary returns `undefined` and writes nothing back, so
+      // the status it would have cleared stays put. Measured: with `turnInFlight`
+      // here, the SECOND regenerate of a conversation was refused even though the
+      // first reply had landed. `_pending` is set by `send` and cleared when the
+      // reply arrives, so it tracks "a turn is out" exactly; the latch above
+      // covers the double-tap that `_pending` is too slow for.
+      if (regenerating || !!s._pending) return s;
+      regenerating = true;
+      try {
+        // `send` directly: it is the one send path, and `submit` with no
+        // argument would read the composer instead of sending the retry.
+        return await send(s, REGENERATE_TEXT);
+      } finally {
+        regenerating = false;
+      }
+    },
   };
 
   // Every action's result goes through the Stop gate on its way out.
@@ -1985,6 +2210,8 @@ export function createAriaChat(o: AriaChatOptions): AriaChatCore {
     tick: (s) => impl.tick(s).then((r) => (r ? gated(r) : r)),
     openLink: (s, arg) => impl.openLink(s, arg).then(gated),
     stop: (s) => impl.stop(s).then((r) => (r ? gated(r) : r)),
+    copyMessage: (s, arg) => impl.copyMessage(s, arg).then((r) => (r ? gated(r) : r)),
+    regenerate: (s) => impl.regenerate(s).then(gated),
     // Synchronous, like `typing`: a selection edit makes no network call, so
     // gating it is a plain call rather than a `.then`.
     widgetToggle: (s, arg) => gated(impl.widgetToggle(s, arg)),

package/templates/nonprofit-cause-owner/tier5-src/himi-owner-lite-aria/index.ts

@@ -23,6 +23,7 @@
 
 import { defineService } from "@himalaya/state";
 import { open } from "@himalaya/open-url";
+import { writeText } from "@himalaya/clipboard";
 import {
   activeSiteId,
   createAriaChat,
@@ -148,6 +149,11 @@ const core = createAriaChat({
     typing: () => copyParam("ownerAria.typing", "Aria is typing…"),
     slow: () => copyParam("ownerAria.slow", "Aria is taking a while…"),
     stopped: () => copyParam("ownerAria.stopped", "Stopped."),
+    // The note beside Copy. Through copyParam for the same reason as the rest:
+    // the buttons are localized by the pack, and a note left on the core's
+    // English default would be the one line under them that is not.
+    copied: () => copyParam("ownerAria.copied", "Copied"),
+    copyFailed: () => copyParam("ownerAria.copyFailed", "Couldn't copy"),
     // Shown when the HOST carries no Wix app binding, so no Wix call can leave
     // the browser (the web preview). Through copyParam like every other string
     // here — a default baked into the shared core cannot be localized by this
@@ -167,6 +173,9 @@ const core = createAriaChat({
   localHistory: false,
   siteId: activeSiteId,
   openLink: async (url) => (await open(url, "system_browser")).opened,
+  // Resolves or throws — `copyMessage` keys its confirmation on which, so a
+  // write the platform refused is never reported as a copy.
+  copyText: (text) => writeText(text),
   resolveEntity: (url) => {
     const screenId = screenForUrl(url, allowedTargets());
     return screenId ? { screenId } : null;
@@ -191,6 +200,10 @@ const svc = defineService<AriaChatState, {
   // new chat) holds a pre-boundary snapshot, and committing it would end the
   // turn the owner has since started.
   stop: (s: AriaChatState) => Promise<AriaChatState | undefined>;
+  // `undefined` for the same reason again: a write still out when the turn
+  // moved on must not commit its pre-await snapshot over the new one.
+  copyMessage: (s: AriaChatState, arg?: AriaActionArg) => Promise<AriaChatState | undefined>;
+  regenerate: (s: AriaChatState) => Promise<AriaChatState>;
   widgetPrimary: (s: AriaChatState) => Promise<AriaChatState>;
   widgetSecondary: (s: AriaChatState) => Promise<AriaChatState>;
   widgetToggle: (s: AriaChatState, arg?: AriaActionArg) => AriaChatState;
@@ -218,6 +231,8 @@ const svc = defineService<AriaChatState, {
     // false — so this is only ever dispatched while a reply is outstanding and
     // the worker is holding the handle that can abort it.
     stop: core.stop,
+    copyMessage: core.copyMessage,
+    regenerate: core.regenerate,
     // The active widget's footer buttons. Named here as well as in the core:
     // the descriptor dispatches `tier5.<service>.<action>`, and an action the
     // entry does not export is a control that renders and does nothing.

package/templates/owner-lite/config.ts

@@ -37,7 +37,7 @@ export default defineApp({
     actions: "http://localhost:8190/v1/actions",
     sync: "http://localhost:8190/v1/sync",
   },
-  capabilities: ["live_activity","push","share","secure_storage","open_url","local_database"],
+  capabilities: ["live_activity","push","share","secure_storage","open_url","local_database","clipboard"],
   designTokensPath: "./tokens.json",
   navigation: {
     "navKind": "responsive",

package/templates/owner-lite/dev/index.ts

@@ -54961,6 +54961,83 @@ const SCREENS = runtimeSetting({
                 }
               }
             },
+            {
+              "id": "himi_owner_lite_aria.reply_actions",
+              "body": {
+                "package": "himalaya",
+                "type": "HStack",
+                "props": {
+                  "spacing": 4,
+                  "children": [
+                    {
+                      "id": "himi_owner_lite_aria.copy",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Copy",
+                          "style": "plain",
+                          "size": "sm",
+                          "fullWidth": false,
+                          "leadingIcon": "copy",
+                          "action": {
+                            "actionId": "tier5.himiOwnerLiteAria.copyMessage"
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "id": "himi_owner_lite_aria.regenerate",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Button",
+                        "props": {
+                          "title": "Regenerate",
+                          "style": "plain",
+                          "size": "sm",
+                          "fullWidth": false,
+                          "leadingIcon": "refresh",
+                          "action": {
+                            "actionId": "tier5.himiOwnerLiteAria.regenerate"
+                          }
+                        }
+                      }
+                    },
+                    {
+                      "id": "",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Text",
+                        "props": {
+                          "text": "$service:himiOwnerLiteAria.copyNote",
+                          "style": "footnote",
+                          "color": "textSecondary",
+                          "maxLines": 1,
+                          "collapseWhenEmpty": true
+                        }
+                      }
+                    },
+                    {
+                      "id": "",
+                      "body": {
+                        "package": "himalaya",
+                        "type": "Spacer",
+                        "props": {}
+                      }
+                    }
+                  ]
+                }
+              },
+              "modifiers": {
+                "padding": {
+                  "leading": 0,
+                  "trailing": 0,
+                  "top": 0,
+                  "bottom": 4
+                },
+                "hiddenPath": "$service:himiOwnerLiteAria.replyActionsHidden"
+              }
+            },
             {
               "id": "himi_owner_lite_aria.prompts.bound",
               "body": {
@@ -58340,7 +58417,8 @@ const SCREENS = runtimeSetting({
       "contentType": "application/javascript+ts-bundle",
       "declaredCapabilities": [
         "wix_api",
-        "open_url"
+        "open_url",
+        "clipboard"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"