@wix/himalaya-cli 0.1015.0 → 0.1016.0

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

@@ -185,6 +185,11 @@ export declare function emptyState(props: {
 export declare function appIntent(pkg: string, type: string, props: unknown, opts?: {
     id?: string;
 }): Component;
+/** RFC 0058 §3.3 — an `image` with a `contentDescription` is an IMAGE the tree
+ *  announces; without one it is DECORATIVE. Both are correct answers and the
+ *  choice is the author's, but `contentDescription: ""` spells the second one
+ *  ambiguously — it reads as an unfinished name rather than a decision. Pass
+ *  `decorative: true` to say it out loud (`modifiers.accessibilityRole`). */
 export declare function image(props: {
     url?: string;
     asset?: string;
@@ -194,6 +199,10 @@ export declare function image(props: {
     height?: number;
     fillWidth?: boolean;
     contentDescription?: string;
+    /** Declare the image purely presentational — it leaves the accessibility
+     *  tree instead of being announced. Mutually exclusive with a non-empty
+     *  `contentDescription`. */
+    decorative?: boolean;
     contentMode?: "fit" | "fill" | "stretch";
     shape?: "rect" | "rounded" | "circle";
     aspectRatio?: number;
@@ -206,11 +215,66 @@ export declare function divider(opts?: {
 }): Component;
 /** Vector icon from the design system's named set (search, trash,
  *  chevron_right, more, plus, person, circle_fill, …). Resolves to an SF
- *  Symbol on iOS / Material icon on Android. */
+ *  Symbol on iOS / Material icon on Android.
+ *
+ *  RFC 0058 §3.3 — an icon owes the accessibility tree exactly one of two
+ *  answers, and both are spellable here:
+ *
+ *  • `decorative: true` → `modifiers.accessibilityRole: "decorative"`. The glyph
+ *    beside a word, the chevron at the end of a row, the monogram behind a
+ *    missing photo. The node stops being an accessibility element while its
+ *    subtree stays traversable. This is the RIGHT answer for most icons — a
+ *    screen reader announcing "chevron right" is worse than one that skips it,
+ *    so a name invented for a glyph is a regression that also passes a counter.
+ *  • `contentDescription: "…"` → `IconProps.contentDescription`. The name for a
+ *    glyph that carries meaning nothing beside it repeats.
+ *
+ *  Passing both is a contradiction and throws. Passing neither leaves the role
+ *  UNSPECIFIED and lets each renderer infer (§3.3) — which is what the exemplar
+ *  apps stopped doing, because "inferred on three arms" is the shape every a11y
+ *  bug in the RFC's audit had. */
 export declare function icon(name: string, opts?: {
     id?: string;
     size?: number;
     tint?: string;
+    contentDescription?: string;
+    decorative?: boolean;
+}): Component;
+/**
+ * An icon-only tap target that CANNOT be built without a name.
+ *
+ * Promoted from the two places that had independently discovered the shape:
+ * `apps/msgr/dev/index.ts` (whose local helper folds the label into `title` so
+ * "one string, no way to ship one without the other") and `tip-calc`'s
+ * `iconButton`, which takes `accessibilityLabel` as a required parameter. This
+ * is the shared version, and `accessibilityLabel` is required by the TYPE as
+ * well as checked at build time — an omitted name is a compile error, an empty
+ * one is a thrown error, and neither reaches a descriptor.
+ *
+ * A `Button` with `iconOnly: true`, NOT an `Icon` in a tappable container. Both
+ * draw the same circle, but a container carrying `modifiers.accessibilityLabel`
+ * emits no accessible name on web (measured in msgr's composer), while
+ * `ButtonProps.title` is non-optional in the native schema precisely because it
+ * doubles as the name. The glyph rides in `leadingIcon`, so there is no second
+ * node for a screen reader to announce.
+ */
+export declare function iconButton(props: {
+    /** The glyph — `leadingIcon`, so it is never its own accessibility element. */
+    icon: string;
+    /** REQUIRED. Becomes both `title` (the native accessible name) and
+     *  `modifiers.accessibilityLabel`. Empty/whitespace throws. */
+    accessibilityLabel: string;
+    action: ActionShape;
+    /** Defaults to `tertiary` — "plain" is in none of the four renderers'
+     *  switches, so Android's `else` arm draws it as a FILLED primary. */
+    style?: string;
+    /** Square edge, in pt/dp/px. Defaults to 44 — the platform tap-target floor. */
+    size?: number;
+    disabled?: boolean;
+    /** RFC 0058 §3.1 — the supplementary "what happens if I act" phrase. */
+    accessibilityHint?: string;
+}, opts?: {
+    id?: string;
 }): Component;
 /** One named series of a multi-series {@link chart}. */
 export interface ChartSeriesShape {
@@ -910,6 +974,8 @@ export declare function rating(props: {
     color?: string;
     icon?: string;
     valuePath?: string;
+    /** `"sm"` — the compact size for dense display rows. Unset/`"md"` keeps the standard size. */
+    size?: "sm" | "md";
 }, opts?: {
     id?: string;
 }): Component;

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

@@ -56,9 +56,12 @@ export declare function withStream<S extends object>(state: S, directive: Stream
  * `_nav` field; the runtime strips it from the stored state (so it never
  * persists or re-fires on the next spread) and surfaces it on the value
  * `__invokeAction` resolves to. The host reads it there and asks the app router
- * to open the screen — but ONLY if that screen is a linkable target, the same
+ * to move the user — to a screen ONLY if that screen is a linkable target, the same
  * check a `himi.open` action already gets.
  *
+ * Three forms, one per kind of move: open a screen, go back / dismiss, or switch
+ * tab. See {@link NavToScreen}, {@link NavBackOrDismiss} and {@link NavToTab}.
+ *
  * WHY THIS EXISTS: all three hosts invoked a `tier5.*` action and threw the
  * result away, so a worker could change state but never move the user. A
  * generated (RFC 0046) row tap could therefore only *arm* an authored button —
@@ -67,15 +70,54 @@ export declare function withStream<S extends object>(state: S, directive: Stream
  * a component or a token. With `_nav`, the model still only fires an allowlisted
  * `tier5.*` action id; the WORKER maps entity → screenId from its own table.
  */
-export interface NavDirective {
+export type NavDirective = NavToScreen | NavBackOrDismiss | NavToTab;
+/**
+ * Open a screen. `presentation` picks how: `push` (the default) onto the current tab's
+ * stack, `replace` to show it in place of the current screen, or present it as a
+ * `sheet` / `full_screen` modal.
+ */
+export interface NavToScreen {
     /** Screen to open. Must be linkable, or the host ignores the directive. */
     screenId: string;
     /** Nav params for the target (e.g. the record `id`). Strings only. */
     args?: Record<string, string>;
+    /** How to show it. Absent ⇒ `push`. */
+    presentation?: "push" | "replace" | "sheet" | "full_screen";
+    tab?: never;
+}
+/**
+ * Leave the current screen. `back` pops the current stack. On iOS and Android, inside an
+ * open sheet or cover it pops the modal's own stack and closes the modal at its root; on
+ * web it pops the tab's stack, so close a modal with `dismiss`. `dismiss` closes the open
+ * sheet / full-screen cover. Both are no-ops with nothing to leave. No target: the host
+ * already knows where "back" is.
+ */
+export interface NavBackOrDismiss {
+    presentation: "back" | "dismiss";
+    screenId?: never;
+    args?: never;
+    tab?: never;
+}
+/**
+ * Switch to the top-level destination with this id — a tab-bar item, or a sidebar-rail
+ * item on a wide layout. The host closes any open sheet first. An id the app is not
+ * showing right now (unknown, or hidden by the nav worker) is ignored, and so is the tab
+ * the user is already on (their stack is kept — it is not a re-tap). A tab switch is not a
+ * stack operation: a later `back` pops the NEW tab's stack, not the switch.
+ */
+export interface NavToTab {
+    tab: string;
+    screenId?: never;
+    args?: never;
+    presentation?: never;
 }
 /**
  * Attach a {@link NavDirective} to a state object an action returns. Sugar for
- * `{ ...state, _nav: { screenId, args } }` that keeps the field name in one place.
+ * `{ ...state, _nav: target }` that keeps the field name in one place.
+ *
+ * `target` is exactly ONE of three forms — `{ screenId, args?, presentation? }`,
+ * `{ presentation: "back" | "dismiss" }`, or `{ tab }`. A directive that mixes them
+ * (a `tab` with a `screenId`, say) is dropped by every host.
  */
 export declare function navigate<S extends object>(state: S, target: NavDirective): S & {
     _nav: NavDirective;

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

@@ -80,6 +80,13 @@ export interface AppCommerceConfig {
     /** Copy-pack overrides for the paywall. */
     copy?: Record<string, string>;
 }
+/** RFC 0058 §5 — see `AppConfig.a11y`. */
+export interface A11yConfig {
+    /** `"error"` (the default when omitted), `"warn"` (non-blocking), or `"off"` (needs `reason`). */
+    enforce?: "off" | "warn" | "error";
+    /** Why the floor is lowered. Required with `"off"`; recommended with `"warn"`. */
+    reason?: string;
+}
 /**
  * RFC 0059 §3.2 — the idiom policy: which named overlay from `tokens.json`'s `idiom` block a
  * surface wears. `policy` is a tag, and each value owns its own sibling fields; the union
@@ -280,6 +287,17 @@ export interface AppConfig {
      * Omit ⇒ today's follow-the-device behavior.
      */
     locale?: LocaleConfig;
+    /**
+     * RFC 0058 §5 — the accessibility enforcement ladder for this app's `himi validate` /
+     * `himi push` lint. **Omit it**: the default is `"error"`, and a new app is gated from its
+     * first commit at zero authoring cost.
+     *
+     * `"warn"` is the deliberate, logged escape for an app mid-migration — the same findings,
+     * non-blocking. Delete it once the app's findings are cleared, so the app returns to the
+     * default. `"off"` silences the pass and requires a `reason`, so lowering the floor is a
+     * visible, reviewable act.
+     */
+    a11y?: A11yConfig;
     /**
      * The LAUNCHER icon — the mark the OS home screen, App Store / Play listing,
      * macOS Dock and browser tab show for this app.

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

@@ -1321,6 +1321,13 @@ export interface RatingProps {
     color?: TokenName;
     icon?: IconRef;
     valuePath?: string;
+    /** Star size. `"sm"` is the compact size for dense rows — a star tally sharing a row
+     *  with a tag and a meta line, where the default stars crowd the text into wrapping.
+     *  It draws 16pt cells with a 14pt glyph, 2pt apart, identically on every platform.
+     *  Leave it unset (or `"md"`) for the standard size, unchanged from before `size`
+     *  existed. `"sm"` is meant for display rows; an interactive rating still works at
+     *  it, but its tap targets shrink with it. */
+    size?: "sm" | "md";
 }
 /**
  * A compact data chart (sparkline / trend) — line, area, or bar. Tier-5 screens

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

@@ -51,6 +51,35 @@ export interface ConversationMessage {
     role?: MessageRole;
     createdDate?: string;
     status?: MessageStatus;
+    /** Client tools this assistant turn asks the CALLER to run — see `FunctionCall`. */
+    functionCalls?: FunctionCall[];
+}
+/** A client-side tool the assistant wants the caller to run before it can go on
+ *  — asking the owner for consent, say. It arrives on the `/user-message`
+ *  response and the agent then WAITS: nothing more is written until the result
+ *  comes back through `sendFunctionCallResults`.
+ *
+ *  Shape from the chat-service's generated client (`wix.genie.v1` `FunctionCall`
+ *  / `FunctionCallResult`), which the native Aria app and the React Native
+ *  dashboard assistant both drive; NOT captured from this client's own traffic,
+ *  because no hermetic account can make the agent ask for a tool on demand. */
+export interface FunctionCall {
+    /** Matches the result to the call. Copied back verbatim. */
+    id?: string;
+    /** The function's name. Also copied back. */
+    name?: string;
+    /** A JSON-ENCODED object — a string on the wire, not a nested object. */
+    arguments?: string;
+}
+/** The answer to one `FunctionCall`. Note the wire spells the flag `success`. */
+export interface FunctionCallResult {
+    id?: string;
+    name?: string;
+    /** Text for the model — the error text when `success` is false. */
+    content?: string;
+    success?: boolean;
+    /** A JSON-ENCODED object carrying the tool's structured answer. */
+    widgetResponse?: string;
 }
 /** Which assistant the conversation talks to. The real dashboard sends a
  *  `unifiedAssistantReference`; helper `ariaAssistantConfig()` builds it. */
@@ -101,6 +130,9 @@ export interface SendMessageResponse {
      *  NOT carry `userMessage`, so this field is the one reliable source; read it
      *  through `userMessageIdOf` rather than directly. */
     userMessageId?: string;
+    /** Client tools the agent is waiting on. Read through `functionCallsOf`: the
+     *  service can also nest them on the first assistant message. */
+    functionCalls?: FunctionCall[];
 }
 /** Empty on success — the service answers `{}`. Named rather than `void` so a
  *  future field has somewhere to land without changing every call site. */
@@ -175,6 +207,18 @@ export declare function sendMessage(conversationId: string, content: string, mod
  *  failed — see `sendMessage`, which attaches the id to its error for exactly
  *  this call. Carries no content: the turn it names is the content. */
 export declare function triggerAssistantMessage(conversationId: string, userMessageId: string, opts?: SendMessageOptions): Promise<SendMessageResponse>;
+/** Answer the client tools a `/user-message` response asked for, and let the
+ *  agent carry on.
+ *
+ *  The SAME route as the trigger, with a different body: no content and no
+ *  `userMessageId` — the results ARE the turn. The response has the shape of any
+ *  other send, so it can carry the NEXT round of `functionCalls`; a caller loops
+ *  until one comes back without any (see `functionCallsOf`).
+ *
+ *  Nothing here decides what a tool does or whether the owner agreed to it. That
+ *  is the caller's, and it is the part that has to be right: a result that says
+ *  `userConsent: true` is the owner's signature on whatever the agent does next. */
+export declare function sendFunctionCallResults(conversationId: string, results: FunctionCallResult[], opts?: SendMessageOptions): Promise<SendMessageResponse>;
 /** Ask the service to abandon the assistant reply it is generating for
  *  `userMessageId` — the "stop" a chat surface puts beside a reply in progress.
  *
@@ -197,6 +241,13 @@ export declare function messagesOf(res: GetConversationMessagesResponse | null |
  *  cannot be aborted, and a caller must degrade rather than send `undefined` to
  *  the abort route. */
 export declare function userMessageIdOf(res: SendMessageResponse | null | undefined): string;
+/** The client tools a send response is waiting on, or `[]`.
+ *
+ *  Under either of the two places the service puts them: nested on the FIRST
+ *  assistant message when that carries any, otherwise top-level. That order is
+ *  the one both native Aria clients read, and it matters when both are present —
+ *  the nested set is the one the agent is actually blocked on. */
+export declare function functionCallsOf(res: SendMessageResponse | null | undefined): FunctionCall[];
 /** The conversation id from a createConversation response, under either key. */
 export declare function conversationIdOf(res: CreateConversationResponse | null | undefined): string;
 /** A message's text. `content` is normally a string, but can arrive as an object

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/core.mjs

@@ -7578,6 +7578,9 @@ function validateConfigShape(config) {
   if (config.locale) {
     validateLocale(config.locale);
   }
+  if (config.a11y !== void 0) {
+    validateA11y(config.a11y);
+  }
   if (config.icon) {
     validateIcon(config.icon, config.designTokens?.colors, config.designTokensPath);
   }
@@ -7595,6 +7598,24 @@ function validateConfigShape(config) {
 var SPLASH_MIN_VISIBLE_MS_MAX = 2e3;
 var SPLASH_MAX_HOLD_MS_MAX = 8e3;
 var SPLASH_LAYOUTS = ["centered", "centeredStacked", "logoOnly"];
+function validateA11y(a11y) {
+  if (!a11y || typeof a11y !== "object" || Array.isArray(a11y)) {
+    throw new Error('defineApp: a11y must be an object like { enforce: "warn" }.');
+  }
+  if (a11y.enforce !== void 0 && !["off", "warn", "error"].includes(a11y.enforce)) {
+    throw new Error(
+      `defineApp: a11y.enforce must be "off", "warn" or "error" (got ${JSON.stringify(a11y.enforce)}).`
+    );
+  }
+  if (a11y.reason !== void 0 && typeof a11y.reason !== "string") {
+    throw new Error("defineApp: a11y.reason must be a string.");
+  }
+  if (a11y.enforce === "off" && !(a11y.reason ?? "").trim()) {
+    throw new Error(
+      'defineApp: a11y.enforce "off" needs a non-empty a11y.reason \u2014 turning the accessibility gate off has to be a visible, reviewable act (RFC 0058 \xA75), never a silent absence.'
+    );
+  }
+}
 function validateLocale(locale) {
   const tag = coerceSupportedLocale(locale.default);
   if (!tag) {

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/sdui.mjs

@@ -8045,18 +8045,75 @@ function appIntent(pkg, type, props, opts) {
   };
 }
 function image(props, opts) {
-  return {
+  const { decorative, ...imageProps } = props;
+  if (decorative && (imageProps.contentDescription ?? "").trim() !== "") {
+    throw new Error(
+      `image(): decorative and a non-empty contentDescription are mutually exclusive \u2014 an image either carries meaning or it does not (RFC 0058 \xA73.3)`
+    );
+  }
+  const node = {
     id: opts?.id ?? auto("image"),
-    body: { package: "himalaya", type: "Image", props }
+    body: { package: "himalaya", type: "Image", props: imageProps }
   };
+  return decorative ? { ...node, modifiers: { accessibilityRole: "decorative" } } : node;
 }
 function divider(opts) {
   return { id: opts?.id ?? auto("divider"), body: { package: "himalaya", type: "Divider", props: {} } };
 }
 function icon(name, opts) {
-  return {
+  if (opts?.decorative && opts?.contentDescription !== void 0) {
+    throw new Error(
+      `icon("${name}"): decorative and contentDescription are mutually exclusive \u2014 a glyph either carries meaning or it does not (RFC 0058 \xA73.3)`
+    );
+  }
+  const node = {
     id: opts?.id ?? auto("icon"),
-    body: { package: "himalaya", type: "Icon", props: { name, size: opts?.size, tint: opts?.tint } }
+    body: {
+      package: "himalaya",
+      type: "Icon",
+      props: { name, size: opts?.size, tint: opts?.tint, ...opts?.contentDescription !== void 0 ? { contentDescription: opts.contentDescription } : {} }
+    }
+  };
+  return opts?.decorative ? { ...node, modifiers: { accessibilityRole: "decorative" } } : node;
+}
+function carriesName(c) {
+  const label2 = c.modifiers?.accessibilityLabel;
+  if (typeof label2 === "string" && label2.trim() !== "") return true;
+  const props = c.body?.props;
+  const cd = props?.contentDescription;
+  return typeof cd === "string" && cd.trim() !== "";
+}
+function iconButton(props, opts) {
+  const name = props.accessibilityLabel;
+  if (typeof name !== "string" || name.trim() === "") {
+    throw new Error(
+      `iconButton("${props.icon}"): accessibilityLabel is required and must be non-empty \u2014 an icon-only control with no name is unreachable by screen reader (RFC 0058 \xA73.3)`
+    );
+  }
+  const size = props.size ?? 44;
+  return {
+    id: opts?.id ?? slugId("btn", props.action?.actionId),
+    body: {
+      package: "himalaya",
+      type: "Button",
+      props: {
+        title: name,
+        action: props.action,
+        style: props.style ?? "tertiary",
+        iconOnly: true,
+        leadingIcon: props.icon,
+        cornerRadius: Math.round(size / 2),
+        minHeight: size,
+        ...props.disabled !== void 0 ? { disabled: props.disabled } : {}
+      }
+    },
+    modifiers: {
+      width: size,
+      height: size,
+      accessibilityLabel: name,
+      accessibilityRole: "button",
+      ...props.accessibilityHint !== void 0 ? { accessibilityHint: props.accessibilityHint } : {}
+    }
   };
 }
 function chart(props, opts) {
@@ -8078,10 +8135,25 @@ function spacer(opts) {
   return { id: opts?.id ?? auto("spacer"), body: { package: "himalaya", type: "Spacer", props } };
 }
 function button(props, opts) {
+  if (props.iconOnly && (typeof props.title !== "string" || props.title.trim() === "")) {
+    throw new Error(
+      `button({ iconOnly: true }): title is required and must be non-empty \u2014 it IS the accessible name of an icon-only control (RFC 0058 \xA73.3). Prefer \`iconButton({ icon, accessibilityLabel, action })\`.`
+    );
+  }
   return { id: opts?.id ?? slugId("btn", props.action?.actionId), body: { package: "himalaya", type: "Button", props } };
 }
 function withModifiers(c, mods) {
-  return { ...c, modifiers: { ...c.modifiers, ...mods } };
+  const merged = { ...c.modifiers, ...mods };
+  if (c.body?.type === "Icon" && merged.onTap && !carriesName({ ...c, modifiers: merged })) {
+    const glyph = c.body.props?.name;
+    throw new Error(
+      `withModifiers: tappable Icon "${String(glyph)}"${c.id ? ` (${c.id})` : ""} has no accessible name \u2014 pass \`accessibilityLabel\`, or build it with \`iconButton({ icon, accessibilityLabel, action })\` (RFC 0058 \xA73.3)`
+    );
+  }
+  if (merged.accessibilityRole === "decorative" && merged.onTap) {
+    return { ...c, modifiers: { ...merged, accessibilityRole: "button" } };
+  }
+  return { ...c, modifiers: merged };
 }
 function withId(c, id) {
   return { ...c, id };
@@ -8513,7 +8585,7 @@ function skRect(height, id) {
 }
 function emptyBlock(service, titlePath, ctaTitle, ctaScreen, iconName, id, opts = {}) {
   const children = [
-    icon(iconName, { size: opts.iconSize ?? 34, tint: "textTertiary" }),
+    icon(iconName, { size: opts.iconSize ?? 34, tint: "textTertiary", decorative: true }),
     text(titlePath, "bodyEmphasis", { color: "textSecondary", collapseWhenEmpty: true })
   ];
   if (opts.subtitle !== void 0) {
@@ -8566,6 +8638,7 @@ export {
   hiddenWhen,
   hstack,
   icon,
+  iconButton,
   image,
   label,
   labeledContent,

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

@@ -93,6 +93,22 @@ function triggerAssistantMessage(conversationId, userMessageId, opts = {}) {
     ...opts.enforceAccountScopedConversations === void 0 ? {} : { enforceAccountScopedConversations: opts.enforceAccountScopedConversations }
   });
 }
+function sendFunctionCallResults(conversationId, results, opts = {}) {
+  if (!conversationId) throw new Error("sendFunctionCallResults: conversationId is required");
+  if (!results.length) throw new Error("sendFunctionCallResults: at least one result is required");
+  return wixCall("POST", `${BASE}/user-message`, {
+    conversationId,
+    functionCallResults: results,
+    userMessageInputSource: "TEXT",
+    communicationMode: opts.communicationMode ?? "POLLING",
+    enableRealtimeEvents: opts.enableRealtimeEvents ?? true,
+    origin: opts.origin ?? ARIA_ORIGIN,
+    ...opts.metadata === void 0 ? {} : { metadata: opts.metadata },
+    // The same scoping the trigger that opened this turn was sent with, so the
+    // continuation runs under the rules its start did.
+    ...opts.enforceAccountScopedConversations === void 0 ? {} : { enforceAccountScopedConversations: opts.enforceAccountScopedConversations }
+  });
+}
 function abortAssistantMessageGeneration(userMessageId) {
   if (!userMessageId) throw new Error("abortAssistantMessageGeneration: userMessageId is required");
   return wixCall("POST", `${BASE}/abort-assistant-message-generation`, { userMessageId });
@@ -107,6 +123,11 @@ function messagesOf(res) {
 function userMessageIdOf(res) {
   return (res?.userMessageId ?? res?.userMessage?.id ?? "").trim();
 }
+function functionCallsOf(res) {
+  const nested = res?.assistantMessages?.[0]?.functionCalls;
+  if (Array.isArray(nested) && nested.length) return nested;
+  return Array.isArray(res?.functionCalls) ? res.functionCalls : [];
+}
 function conversationIdOf(res) {
   return (res?.conversationId || res?.conversation?.id || "").trim();
 }
@@ -138,6 +159,7 @@ export {
   conversationIdOf,
   conversationUserMessage,
   createConversation,
+  functionCallsOf,
   genieChatError,
   getConversationMessages,
   getConversations,
@@ -145,6 +167,7 @@ export {
   lastAssistantMessage,
   messageText,
   messagesOf,
+  sendFunctionCallResults,
   sendMessage,
   triggerAssistantMessage,
   userMessageIdOf,