@wix/himalaya-cli 0.1403.0 → 0.1405.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/dev-server/src/builder.d.ts

@@ -640,6 +640,9 @@ export declare function mediaField(props: {
     valuePath: string;
     uploadService: string;
     label?: string;
+    presentation?: string;
+    fallbackTextPath?: string;
+    heading?: string;
 }, opts?: {
     id?: string;
 }): Component;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/core/ts/src/schema.d.ts

@@ -1656,6 +1656,12 @@ export interface MediaFieldProps {
     uploadService: string;
     /** Empty-well copy (a message key or literal). Default "Add a photo". */
     label?: string;
+    /** Set to "avatar" for a circular picker row; omitted preserves the 160pt image well. */
+    presentation?: string;
+    /** `$service:<svc>.<path>` → initials shown in avatar mode when no photo is set. */
+    fallbackTextPath?: string;
+    /** Optional visible heading in avatar mode; label remains the action caption. */
+    heading?: string;
 }
 /**
  * A formatted, multiline editor that writes HTML into an enclosing Form under `id`.

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/ai-site-chat/src/extensions.d.ts

@@ -0,0 +1,10 @@
+import type { WixCallOptions, WixStreamMessagesRequest } from "./index.js";
+/** Submits a visitor message (for example a visitor-option selection) to the widget's
+ *  `messages/stream` endpoint. This is a BUFFERED call, not a stream: the endpoint
+ *  answers with an SSE body, but the Wix bridge reads the whole body before it resolves,
+ *  so the promise settles only once the response has ended and the events are not
+ *  delivered as they arrive. The payload is returned opaque, as the bridge hands it
+ *  over. Native clients expose the same buffered call as `streamMessages`. The request
+ *  is sent as the visitor or member session the host supplies; a gateway error rejects.
+ *  @scope visitor — an anonymous visitor session is enough. */
+export declare function streamMessages(req: WixStreamMessagesRequest, opts?: WixCallOptions): Promise<unknown>;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/ai-site-chat/src/index.d.ts

@@ -0,0 +1,102 @@
+declare global {
+    var himalaya: {
+        wixApi?: {
+            call: (method: string, path: string, body?: unknown, headers?: Record<string, string>) => Promise<unknown>;
+        };
+    };
+}
+/** Per-call options. `site` addresses ONE call at a business other than the app's
+ *  active one, so a cross-site rollup can read several businesses concurrently without
+ *  `setActiveSite` moving the whole process between them. Omitted ⇒ the active business,
+ *  byte-identical to a call that never passed options.
+ *
+ *  `site.forSite(msid)` from `@himalaya/wix-platform` returns a value of this shape, so
+ *  it can be passed straight through: `someMethod(req, site.forSite(msid))`. */
+export interface WixCallOptions {
+    site?: string;
+}
+export declare function wixCall<T>(method: string, path: string, body?: unknown, opts?: WixCallOptions): Promise<T>;
+/** `path` with `req` appended as the query string Wix's RPC gateway reads a GET or
+ *  DELETE request from. A nested object flattens to dotted field paths
+ *  (`{ sort: { order: "ASC" } }` → `sort.order=ASC`), an array repeats its key
+ *  (`{ id: ["a", "b"] }` → `id=a&id=b`), and an absent field contributes nothing —
+ *  so an empty request yields the bare path. A field whose value is an array of
+ *  objects has no query-string spelling and is omitted, exactly as Wix's own client
+ *  omits it; such a field has to be sent through a POST sibling endpoint instead.
+ *
+ *  Built from template literals and `encodeURIComponent`, never `URLSearchParams`:
+ *  that is a host global the bare Tier-5 worker runtimes (JSCore / Hermes /
+ *  QuickJS-ng) do not provide, so reaching for it would throw a ReferenceError
+ *  before the request went out rather than degrade.
+ *
+ *  Exported so the hand-written ./extensions sidecar can build the same URLs. */
+export declare function wixQueryPath(path: string, req: unknown): string;
+export interface WixMessage {
+    id?: string;
+    createdDate?: string;
+    sender?: string;
+    conversationId?: string;
+    answerTo?: string;
+    messageType?: string;
+    body?: WixBody;
+    inboxId?: string;
+    visitorOptions?: string[];
+    assistantActions?: string[];
+    visitorOptionsFields?: Record<string, unknown>[];
+    engineStatus?: string;
+}
+export interface WixBody {
+    mainText?: string;
+    footerText?: string;
+    additionalData?: Record<string, unknown>[];
+}
+export interface WixListMessagesRequest {
+    cursorPaging?: WixCursorPaging;
+}
+export interface WixCursorPaging {
+    limit?: number;
+    cursor?: string;
+}
+export interface WixListMessagesResponse {
+    messages?: WixMessage[];
+    pagingMetadata?: WixPagingMetadataV2;
+}
+export interface WixPagingMetadataV2 {
+    count?: number;
+    offset?: number;
+    total?: number;
+    tooManyToCount?: boolean;
+    cursors?: WixCursors;
+    hasNext?: boolean;
+}
+export interface WixCursors {
+    next?: string;
+    prev?: string;
+}
+export interface WixStreamMessagesRequest {
+    message: WixStreamMessage;
+}
+export interface WixStreamMessage {
+    sender: "SITE_VISITOR";
+    messageType: "VISITOR_OPTION_SELECTED";
+    answerTo: string;
+    body: WixStreamMessageBody;
+}
+export interface WixStreamMessageBody {
+    mainText: string;
+    additionalData: WixStreamMessageAdditionalData[];
+}
+export interface WixStreamMessageAdditionalData {
+    id: string;
+    type: "select_option";
+    action: string;
+}
+/**
+ * Lists the messages of the AI Site Chat (Wix Smart Chat) conversation for the active site, paged by cursor via `cursorPaging`. Runs as the site visitor or member session the host supplies; an empty `messages` array means the conversation has no messages yet, and a 4xx/5xx rejects with the gateway error.
+ *
+ * @scope visitor — an anonymous visitor session is enough.
+ *
+ * GET /wix-assistant-widget/v1/messages/list
+ */
+export declare function listMessages(req?: WixListMessagesRequest, opts?: WixCallOptions): Promise<WixListMessagesResponse>;
+export * from "./extensions.js";

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/_types/stdlib/wix-sdk/chat-web/src/index.d.ts

@@ -5,8 +5,33 @@ declare global {
         };
     };
 }
+export type ChatWebErrorCode = "token_empty" | "token_mint_failed" | "invalid_argument" | "invalid_response";
+/** Typed failure so callers can tell "no token / bad input / bad response" from
+ *  an empty inbox.
+ *
+ *  A tagged Error, NOT a subclass (same pattern as `genieChatError`): Tier-5
+ *  bundles are built for a target that refuses `class` syntax, so this module
+ *  stays class-free. Test with `isChatWebError`, not `instanceof`. */
+export interface ChatWebError extends Error {
+    code: ChatWebErrorCode;
+    cause?: unknown;
+}
+/** Creates a typed error for token, validation, and malformed-response failures. */
+export declare function chatWebError(code: ChatWebErrorCode, message: string, cause?: unknown): ChatWebError;
+/** Returns whether a value is a typed Wix chat SDK error. */
+export declare function isChatWebError(e: unknown): e is ChatWebError;
+export type ChatRole = "owner" | "member";
+export interface ChatOptions {
+    /** `owner` (default) mints with isForUnifiedList=true; `member` with false. */
+    role?: ChatRole;
+    /** A caller-supplied chatToken; skips the mint. Never stored by this module. */
+    chatToken?: string;
+}
+/** Opaque server cursor. `0` is a valid cursor, so test for null/undefined only. */
+export type ChatCursor = number | string;
 export interface ChatMessage {
     id: string;
+    sequence?: number;
     summary?: string;
     createdAt?: number;
     sender?: {
@@ -29,18 +54,44 @@ export interface ChatMessage {
         };
     }>;
 }
-/** Fetch the recent messages for a chatroom. Verified live (200): the message
- *  LIST is chat-web **v1** with the chatToken in the QUERY (the v2 path is
- *  send-only — GET there is 405); `pageSize` is required. Returns `{items}`. */
-export declare function getMessages(chatroomId: string, pageSize?: number): Promise<ChatMessage[]>;
+export interface ChatMessagesPage {
+    items: ChatMessage[];
+    /** Raw server cursors: `before` pages Desc (older), `since` pages Asc (newer). */
+    next?: {
+        before?: ChatCursor | null;
+        since?: ChatCursor | null;
+    };
+    /** The cursor for the next page in the requested ordering; undefined = end. */
+    nextPointer?: ChatCursor;
+}
+export interface GetMessagesPageParams extends ChatOptions {
+    pageSize?: number;
+    /** Omitted = server default (what the array helper has always sent). */
+    ordering?: "Asc" | "Desc";
+    nextPointer?: ChatCursor;
+}
+/** One page of history. Verified live (200) for the plain form: chat-web **v1**,
+ *  chatToken in the QUERY, `pageSize` required. Contract (chat-sdk 24.0.40
+ *  `server-api.ts:128-139`): optional `ordering=Asc|Desc` and `nextPointer`,
+ *  response `{items, next:{before,since}}`. */
+export declare function getMessagesPage(chatroomId: string, params?: GetMessagesPageParams): Promise<ChatMessagesPage>;
+/** Fetch the recent messages for a chatroom (first page of `getMessagesPage`). */
+export declare function getMessages(chatroomId: string, pageSize?: number, options?: ChatOptions): Promise<ChatMessage[]>;
+export interface SendChatMessageOptions extends ChatOptions {
+    /** Caller-owned message id: the same id on a user retry is the same send
+     *  intent. Generated when omitted. */
+    messageId?: string;
+}
 /** Send a plain-text message to a chatroom. Verified live (200): the body is
  *  SendMessageRequest{sendMessageBody:{...,data:[{mimeType:"text/plain",data:{text}}]}}
- *  with the chatToken in the `ChatToken` HEADER (query param is rejected). */
-export declare function sendChatMessage(chatroomId: string, text: string): Promise<void>;
+ *  with the chatToken in the `ChatToken` HEADER (query param is rejected).
+ *  The send is issued exactly once — this module never retries it; a caller
+ *  that retries should pass the same `messageId`. */
+export declare function sendChatMessage(chatroomId: string, text: string, options?: SendChatMessageOptions): Promise<void>;
 /** Archive (or unarchive) a chatroom. Verified live (200): chat-web **v1**,
  *  `PUT .../chatrooms/{id}/archive|unarchive` with the chatToken in the QUERY.
  *  Used by the inbox swipe action. */
-export declare function archiveChatroom(chatroomId: string, archived?: boolean): Promise<void>;
+export declare function archiveChatroom(chatroomId: string, archived?: boolean, options?: ChatOptions): Promise<void>;
 export interface ChatMessagePreview {
     summary?: string;
     createdAt?: number;
@@ -58,6 +109,7 @@ export interface Chatroom {
     isArchived?: boolean;
     createdAt?: number;
     participantId?: string;
+    lastReadMessageSequence?: number;
     displayData?: {
         name?: string;
         image?: {
@@ -66,26 +118,68 @@ export interface Chatroom {
     };
     lastMessage?: ChatMessagePreview;
 }
-/** Mint a chatToken (required by every chat-web call). Retries ONCE on a
- *  failed/empty mint: the token endpoint occasionally returns a transient 5xx /
- *  empty body on a cold worker, which would otherwise flash an empty thread
- *  ("No messages yet") or a spurious send failure. Every chat-web call mints via
- *  this, so the single retry hardens the whole surface at the source. */
-export declare function getChatToken(): Promise<{
+/** Mint a chatToken (required by every chat-web call). Tries the mint exactly
+ *  `TOKEN_MINT_ATTEMPTS` times: the token endpoint occasionally returns a
+ *  transient 5xx / empty body on a cold worker. If every attempt throws or
+ *  returns no token this THROWS a typed `chatWebError` (`token_mint_failed` with
+ *  the last thrown cause if any attempt threw, else `token_empty`) — it never returns an empty
+ *  token, so callers cannot render a false "No messages yet". A caller-supplied
+ *  `options.chatToken` is returned as is (no network). */
+export declare function getChatToken(options?: ChatOptions): Promise<{
     chatToken: string;
 }>;
-/** List the site's inbox chatrooms (conversations). Mints a chatToken first. */
-export declare function listChatrooms(pageSize?: number): Promise<Chatroom[]>;
-/** Mark a chatroom UNREAD. Verified live (200): chat-web **v1**,
+/** List the site's inbox chatrooms (conversations). Mints a chatToken first.
+ *  The v2 GET below is the owner (unified-list) endpoint; a member list is the v1
+ *  list view, so `role: "member"` is served by `listChatroomsPage` (first page). */
+export declare function listChatrooms(pageSize?: number, options?: ChatOptions): Promise<Chatroom[]>;
+export type ParticipantType = "business" | "siteMember";
+export interface ChatroomsPage {
+    items: Chatroom[];
+    /** Cursor for the next page (`chatrooms.next.before`); undefined = end. */
+    nextPointer?: ChatCursor;
+    unreadChatroomCount?: number;
+    unreadChatroomIds?: string[];
+}
+export interface ListChatroomsPageParams extends ChatOptions {
+    /** Optional participant filter; default and `[]` = no filter (the reference
+     *  allows it: with an `isForUnifiedList=false` chatToken the server scopes the
+     *  list itself). Elements, when present, must be non-empty strings. */
+    participantIds?: string[];
+    participantType?: ParticipantType;
+    pageSize?: number;
+    nextPointer?: ChatCursor;
+    archived?: boolean;
+    onlyUnread?: boolean;
+    unreadChatroomLimit?: number;
+}
+/** One page of the v1 list view (the member list). Contract (chat-sdk 24.0.40
+ *  `server-api.ts:107-125`): `POST v1/chatrooms-for-list-view[/{participantType}]`,
+ *  chatToken + paging in the query, body `{participantIds, labelIds}` (`participantIds` may be `[]`), response
+ *  `{chatrooms:{items,next:{before}}, unreadChatroomCount, unreadChatroomIds}`.
+ *  Not yet live-verified for a member session. */
+export declare function listChatroomsPage(params?: ListChatroomsPageParams): Promise<ChatroomsPage>;
+/** Mark ONE chatroom read up to a message sequence. Contract (chat-sdk 24.0.40
+ *  `server-api.ts:268-281`): `PUT v1/chatrooms/{id}/users` body
+ *  `{lastReadMessageSequence, readMethod?}` → `{lastReadMessageSequence}`
+ *  (the old `/read` variants 404 — that is a different path). `readMethod` names
+ *  the channel, e.g. `WixMembersMobileApp` in the member reference apps.
+ *  Not yet live-verified. */
+export declare function markChatroomRead(chatroomId: string, lastReadMessageSequence: number, options?: ChatOptions & {
+    readMethod?: string;
+}): Promise<{
+    lastReadMessageSequence?: number;
+}>;
+/** Mark a chatroom UNREAD. Verified live (200) with an empty body: chat-web **v1**,
  *  `PUT .../chatrooms/{id}/unread?chatToken=<t>` → `{hasRead, unreadChatroomCount}`.
- *  NOTE there is NO public mark-READ endpoint — every `/read` variant 404s; the
- *  real Owner app auto-reads a thread on open. Used by the inbox "Mark as unread"
- *  swipe. */
-export declare function markChatroomUnread(chatroomId: string): Promise<void>;
+ *  The reference sends `{lastReadMessageSequence}` = newest unreadable message
+ *  sequence − 1 (`server-api.ts:283-287`); pass it as `lastReadMessageSequence`.
+ *  Omitted = the legacy empty body, so existing callers are unchanged. Used by the
+ *  inbox "Mark as unread" swipe. */
+export declare function markChatroomUnread(chatroomId: string, lastReadMessageSequence?: number, options?: ChatOptions): Promise<void>;
 /** Delete a chatroom entirely. Verified live (200): chat-web **v1**,
  *  `DELETE .../chatrooms/{id}?chatToken=<t>`. Used by the inbox "Delete" swipe
  *  (distinct from Archive, which is reversible). */
-export declare function deleteChatroom(chatroomId: string): Promise<void>;
+export declare function deleteChatroom(chatroomId: string, options?: ChatOptions): Promise<void>;
 export interface SocialChatroom {
     id: string;
     name?: string;

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/wix-ai-site-chat.mjs

@@ -0,0 +1,70 @@
+// ../../stdlib/wix-sdk/ai-site-chat/src/extensions.ts
+function streamMessages(req, opts) {
+  return wixCall("POST", "/wix-assistant-widget/v1/messages/stream", req, opts);
+}
+
+// ../../stdlib/wix-sdk/ai-site-chat/src/index.ts
+function wixCallHeaders(opts) {
+  const site = opts?.site?.trim();
+  return site ? { "wix-site-id": site } : void 0;
+}
+function wixCall(method, path, body, opts) {
+  if (!globalThis.himalaya?.wixApi) {
+    return Promise.reject(
+      new Error(
+        "@himalaya/wix-ai-site-chat: host did not install the wixApi bridge"
+      )
+    );
+  }
+  return globalThis.himalaya.wixApi.call(
+    method,
+    path,
+    body,
+    wixCallHeaders(opts)
+  );
+}
+function wixQueryPath(path, req) {
+  const parts = [];
+  const pair = (key, value) => {
+    parts.push(
+      `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    );
+  };
+  const add = (key, value) => {
+    if (value === void 0 || value === null) return;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (item === void 0 || item === null || typeof item === "object")
+          continue;
+        pair(key, item);
+      }
+      return;
+    }
+    if (typeof value === "object") {
+      for (const [k, v] of Object.entries(value))
+        add(`${key}.${k}`, v);
+      return;
+    }
+    pair(key, value);
+  };
+  for (const [key, value] of Object.entries(
+    req ?? {}
+  ))
+    add(key, value);
+  return parts.length > 0 ? `${path}?${parts.join("&")}` : path;
+}
+function listMessages(req = {}, opts) {
+  return wixCall(
+    "GET",
+    wixQueryPath("/wix-assistant-widget/v1/messages/list", req),
+    void 0,
+    opts
+  );
+}
+export {
+  listMessages,
+  streamMessages,
+  wixCall,
+  wixQueryPath
+};
+//# sourceMappingURL=wix-ai-site-chat.mjs.map