@wix/himalaya-cli 0.1306.0 → 0.1308.0

package/templates/events-meetups-owner/tier5-src/_shared/aria-stream.ts

@@ -0,0 +1,165 @@
+// The live reply — what the Aria realtime stream says about the turn in flight.
+//
+// The chat-service publishes a reply's words as side-effect frames while the
+// agent writes it (`decisionStart` / `decisionChunk` / `decisionCompleted`), plus
+// the turn's quick replies (`receivedTags`) a moment after it ends. The
+// transcript, which the worker also polls, only ever holds a SNAPSHOT of the
+// reply, so the stream is what makes the words arrive as they are written.
+//
+// This module folds those frames into one record per turn. It is pure and
+// dependency-free: the conversation machine owns WHEN to fold (it opens one
+// stream per sent turn and resets this model with it), and this owns HOW.
+//
+// THE FOLD is the native Aria app's "accumulated" reducer, rule for rule:
+//
+//  - One record per `decisionId`. A turn can have several decisions; their text
+//    joins with a blank line (`append`), or a later one replaces the turn's text
+//    outright (`override`).
+//  - `accumulatedResponse` is the decision's WHOLE text so far, so a frame
+//    REPLACES the record's text rather than appending to it. That is what makes
+//    the fold idempotent: a frame delivered twice, or a stream re-opened and
+//    replayed from the start, converges on the same text.
+//  - A frame whose chunk index is not ahead of the latest one seen is stale and
+//    dropped — UNLESS it is the completion, which always lands.
+//  - A completed decision is final; nothing after it changes it.
+//
+// What this does NOT decide is when a turn is OVER. A completed decision is a
+// hint, not the answer: the transcript (the poll) stays the only thing that ends
+// a turn, exactly as in the native app. Completion only lets the caller ask the
+// transcript right away instead of waiting for its next scheduled read.
+//
+// This file is copied verbatim into every generated starter app, so it explains
+// itself without pointing at anything only this repo has.
+
+import { decodeSideEffect, type AriaSideEffect, type QuickReply } from "@himalaya/wix-genie-chat";
+
+/** One decision of the turn, as folded so far. */
+interface Decision {
+  id: string;
+  mode: "append" | "override";
+  latest: number;
+  completed: boolean;
+  text: string;
+}
+
+/** What one folded frame changed, so the caller re-renders (or asks the
+ *  transcript) only when something did. */
+export type LiveChange = "none" | "started" | "text" | "completed" | "tags" | "confirm";
+
+export interface LiveReply {
+  /** Start over for a new turn: drops every decision and the quick replies of
+   *  the previous one. `turnId` is the owner's stored message id, empty when the
+   *  service named none (frames are then accepted for the whole conversation). */
+  reset(conversationId: string, turnId: string): void;
+  /** Fold one raw stream event. Frames for another conversation, or for a turn
+   *  other than the current one, change nothing. */
+  fold(event: unknown): LiveChange;
+  /** The turn's text so far, joined across its decisions. Empty until the first
+   *  words arrive. */
+  text(): string;
+  /** Every decision seen has completed (and there was at least one). */
+  settled(): boolean;
+  /** The quick replies offered for the current turn, in the service's order. */
+  quickReplies(): QuickReply[];
+  /** How many frames have changed something since the last call — the caller's
+   *  clock-free way to tell a live stream from a stalled one. */
+  takeActivity(): number;
+  /** The conversation and turn this model is folding for. */
+  readonly conversationId: string;
+  readonly turnId: string;
+}
+
+/** How a turn's decisions combine, the native app's rule: `append` joins with a
+ *  blank line, `override` replaces whatever came before it. */
+function joined(decisions: Decision[]): string {
+  let out = "";
+  for (const d of decisions) {
+    if (!d.text) continue;
+    out = d.mode === "override" || !out ? d.text : `${out}\n\n${d.text}`;
+  }
+  return out;
+}
+
+export function createLiveReply(): LiveReply {
+  let conv = "";
+  let turn = "";
+  let order: Decision[] = [];
+  let byId = new Map<string, Decision>();
+  let replies: QuickReply[] = [];
+  let activity = 0;
+
+  /** Does a frame naming `userMessageId` belong to the current turn? A frame
+   *  naming NO turn is accepted — the native app routes those to the open turn
+   *  too — but one naming another turn never is: that is a late answer to a turn
+   *  the owner has since moved on from. */
+  const ours = (userMessageId: string | undefined): boolean =>
+    !userMessageId || userMessageId === "unknown" || !turn || userMessageId === turn;
+
+  const foldDecision = (e: Extract<AriaSideEffect, { kind: "decision" }>): LiveChange => {
+    if (!ours(e.userMessageId)) return "none";
+    const completed = e.phase === "completed";
+    const index = e.chunkIndex ?? -1;
+    const existing = byId.get(e.decisionId);
+    if (!existing) {
+      const d: Decision = { id: e.decisionId, mode: e.streamingMode, latest: index, completed, text: e.accumulatedResponse ?? e.chunk ?? "" };
+      byId.set(d.id, d);
+      order = [...order, d];
+      activity += 1;
+      return completed ? "completed" : d.text ? "text" : "started";
+    }
+    if (existing.completed) return "none";
+    if (!completed && e.chunkIndex !== undefined && index <= existing.latest) return "none";
+    const before = existing.text;
+    existing.latest = Math.max(existing.latest, index);
+    existing.completed = completed;
+    if (e.accumulatedResponse !== undefined) existing.text = e.accumulatedResponse;
+    else if (e.chunk !== undefined) existing.text += e.chunk;
+    activity += 1;
+    if (completed) return "completed";
+    return existing.text !== before ? "text" : "none";
+  };
+
+  return {
+    get conversationId() { return conv; },
+    get turnId() { return turn; },
+    reset(conversationId, turnId) {
+      conv = conversationId;
+      turn = turnId;
+      order = [];
+      byId = new Map();
+      replies = [];
+      activity = 0;
+    },
+    fold(event) {
+      const e = decodeSideEffect(event);
+      if (!e || !conv) return "none";
+      if (e.kind !== "messageChanged" && e.kind !== "unknown" && e.conversationId !== conv) return "none";
+      if (e.kind === "messageChanged" && e.conversationId && e.conversationId !== conv) return "none";
+      switch (e.kind) {
+        case "decision":
+          return foldDecision(e);
+        case "tags": {
+          if (!turn || e.userMessageId !== turn) return "none";
+          replies = e.quickReplies;
+          activity += 1;
+          return "tags";
+        }
+        case "messageChanged":
+          activity += 1;
+          return "confirm";
+        default:
+          // Status lines are decoded but not painted yet; an unknown frame is
+          // somebody else's. Neither changes the reply.
+          return "none";
+      }
+    },
+    text: () => joined(order),
+    settled: () => order.length > 0 && order.every((d) => d.completed),
+    quickReplies: () => replies,
+    takeActivity() {
+      const n = activity;
+      activity = 0;
+      return n;
+    },
+  };
+}

package/templates/events-meetups-owner/tier5-src/himi-owner-lite-aria/index.ts

@@ -34,6 +34,8 @@ import { alert } from "@himalaya/ui";
 import {
   activeSiteId,
   createAriaChat,
+  authoredRealtimeUrl,
+  stashRealtimeUrl,
   type AriaActionArg,
   type AriaChatState,
   type AriaDictationResult,
@@ -53,6 +55,10 @@ const SERVICE = "himiOwnerLiteAria";
 // clone's blocking loop, which paints nothing for the length of a turn.
 const FAST_MS = 2000;
 const IDLE_MS = 15000;
+// While the realtime stream is delivering a reply, the transcript is only read to
+// CONFIRM the turn ended — the words come from the stream — so the ladder runs at
+// this slower rate. A whole interval with no frame drops it back to FAST_MS.
+const STREAM_MS = 6000;
 
 function prompts(): AriaPromptChip[] {
   return [
@@ -250,7 +256,13 @@ const core = createAriaChat({
     const screenId = screenForUrl(url, allowedTargets());
     return screenId ? { screenId } : null;
   },
-  poll: { action: `${SERVICE}.tick`, fastMs: FAST_MS, idleMs: IDLE_MS },
+  poll: { action: `${SERVICE}.tick`, fastMs: FAST_MS, idleMs: IDLE_MS, streamMs: STREAM_MS },
+  // The realtime stream: the reply's words as they are written, plus the quick
+  // replies that follow it. Only where the screen was built with a stream url
+  // (authored onAppear load params); everywhere else — and wherever the host cannot
+  // open it — the turn is polled exactly as before. The screen must declare
+  // "stream" for the host to open it at all.
+  stream: { url: authoredRealtimeUrl },
   // Composer dictation, on the platform recognizer: SFSpeechRecognizer,
   // Android SpeechRecognizer, Web Speech. No audio crosses the bridge — only the
   // final transcript. An empty language means the device's own locale, which is
@@ -319,6 +331,12 @@ const svc = defineService<AriaChatState, {
   finishDictation: (s: AriaChatState) => AriaChatState;
   // `undefined` for a result whose session is no longer the live one — see the core.
   dictated: (s: AriaChatState, arg?: AriaDictationResult) => AriaChatState | undefined;
+  // The realtime stream's callbacks, named by the `_stream` directive the core
+  // returns from a send — never by the descriptor. `undefined` from
+  // `streamEvent` for the same reason `tick` has it.
+  streamEvent: (s: AriaChatState, event?: unknown) => Promise<AriaChatState | undefined>;
+  streamEnded: (s: AriaChatState) => AriaChatState;
+  streamFailed: (s: AriaChatState, err?: unknown) => AriaChatState;
   mentionOpen: (s: AriaChatState) => Promise<AriaChatState | undefined>;
   mentionClose: (s: AriaChatState) => AriaChatState;
   mentionBack: (s: AriaChatState) => AriaChatState;
@@ -334,7 +352,7 @@ const svc = defineService<AriaChatState, {
   state: core.initialState,
   actions: {
     // `load` is the onAppear dispatch, so it is where the copy pack arrives.
-    load: (s, arg) => { stashCopy(arg); stashTargets(arg); return core.load(s); },
+    load: (s, arg) => { stashCopy(arg); stashTargets(arg); stashRealtimeUrl(arg); return core.load(s); },
     submit: core.submit,
     submitPrompt: core.submitPrompt,
     newChat: core.newChat,
@@ -391,6 +409,12 @@ const svc = defineService<AriaChatState, {
     attachmentSettled: core.attachmentSettled,
     removeAttachment: core.removeAttachment,
     retryAttachment: core.retryAttachment,
+    // Dispatched by the HOST as the stream delivers, closes or fails. A name
+    // the entry does not export is a callback the host silently drops, and the
+    // turn would then be polled with nobody noticing the stream was ignored.
+    streamEvent: core.streamEvent,
+    streamEnded: core.streamEnded,
+    streamFailed: core.streamFailed,
   },
 });
 

package/templates/gym-fitness-owner/dev/index.ts

@@ -56677,7 +56677,8 @@ const SCREENS = runtimeSetting({
                                         "props": {
                                           "text": "$item.content",
                                           "style": "body",
-                                          "maxLines": 50
+                                          "maxLines": 50,
+                                          "animateReveal": true
                                         }
                                       },
                                       "modifiers": {
@@ -57185,7 +57186,7 @@ const SCREENS = runtimeSetting({
               }
             },
             {
-              "id": "himi_owner_lite_aria.stop",
+              "id": "",
               "body": {
                 "package": "himalaya",
                 "type": "HStack",
@@ -57201,30 +57202,19 @@ const SCREENS = runtimeSetting({
                       }
                     },
                     {
-                      "id": "",
-                      "body": {
-                        "package": "himalaya",
-                        "type": "Icon",
-                        "props": {
-                          "name": "close",
-                          "size": 14,
-                          "tint": "accentPrimary"
-                        }
-                      },
-                      "modifiers": {
-                        "accessibilityRole": "decorative"
-                      }
-                    },
-                    {
-                      "id": "",
+                      "id": "himi_owner_lite_aria.stop",
                       "body": {
                         "package": "himalaya",
-                        "type": "Text",
+                        "type": "Button",
                         "props": {
-                          "text": "Stop",
-                          "style": "footnote",
-                          "color": "accentPrimary",
-                          "maxLines": 1
+                          "title": "Stop",
+                          "style": "link",
+                          "size": "sm",
+                          "leadingIcon": "close",
+                          "fullWidth": false,
+                          "action": {
+                            "actionId": "tier5.himiOwnerLiteAria.stop"
+                          }
                         }
                       }
                     }
@@ -57238,9 +57228,6 @@ const SCREENS = runtimeSetting({
                   "top": 4,
                   "bottom": 0
                 },
-                "onTap": {
-                  "actionId": "tier5.himiOwnerLiteAria.stop"
-                },
                 "hiddenPath": "$service:himiOwnerLiteAria.stopHidden"
               }
             },
@@ -60968,7 +60955,8 @@ const SCREENS = runtimeSetting({
         "ui",
         "speech",
         "camera",
-        "presigned_upload"
+        "presigned_upload",
+        "stream"
       ],
       "minBinaryVersion": "0.1.0",
       "bundleVersion": "0.0.1"