stream-chat-react-native-core 9.12.1-beta.1 → 9.13.0

package/lib/typescript/ai-components/conversation/list/useEndInView.d.ts

@@ -0,0 +1,26 @@
+import { type RefObject } from 'react';
+import type { SharedValue } from 'react-native-reanimated';
+import type { LegendListRef } from '@legendapp/list/react-native';
+import { type KeyboardFrame } from './useKeyboardOverlap';
+export type UseEndInViewOptions = {
+    /** The room for a composer floating over the bottom of the list, which is not in view. */
+    bottomInset: number;
+    /** The height of the list's header, which its positions leave out. */
+    headerSize: RefObject<number>;
+    /** The keyboard, which covers the bottom of the list by as much as it reaches over it. */
+    keyboard: SharedValue<KeyboardFrame>;
+    /** How far above the bottom of the screen the list ends. */
+    keyboardOffset: RefObject<number>;
+    listRef: RefObject<LegendListRef | null>;
+};
+/**
+ * Whether the end of the last row's content is in view: not the room the anchored latest turn
+ * leaves under a short reply, nor the room for the floating composer. Call `scheduleCheckEnd`
+ * whenever that may have changed: a scroll, or a row changing size without one, such as an answer
+ * typing out, or the keyboard moving. It checks once a frame at most.
+ */
+export declare const useEndInView: ({ bottomInset, headerSize, keyboard, keyboardOffset, listRef, }: UseEndInViewOptions) => {
+    isEndInView: boolean;
+    scheduleCheckEnd: () => void;
+};
+//# sourceMappingURL=useEndInView.d.ts.map

package/lib/typescript/ai-components/conversation/list/useEndInView.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEndInView.d.ts","sourceRoot":"","sources":["../../../../../src/ai-components/conversation/list/useEndInView.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA4C,MAAM,OAAO,CAAC;AAEjF,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAE3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,OAAO,EAAE,KAAK,aAAa,EAAqB,MAAM,sBAAsB,CAAC;AAK7E,MAAM,MAAM,mBAAmB,GAAG;IAChC,0FAA0F;IAC1F,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9B,0FAA0F;IAC1F,QAAQ,EAAE,WAAW,CAAC,aAAa,CAAC,CAAC;IACrC,4DAA4D;IAC5D,cAAc,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAClC,OAAO,EAAE,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;CAC1C,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,YAAY,GAAI,iEAM1B,mBAAmB;;;CAyBrB,CAAC"}

package/lib/typescript/ai-components/conversation/list/useKeyboardOverlap.d.ts

@@ -0,0 +1,17 @@
+import { type SharedValue } from 'react-native-reanimated';
+export type KeyboardFrame = {
+    height: number;
+    progress: number;
+};
+/**
+ * How far the keyboard reaches over a view that ends `offset` above the bottom of the screen, as
+ * `KeyboardAwareLegendList` reckons it: the keyboard's height less the offset, scaled by how far
+ * the keyboard is open. In a worklet or on the JS thread.
+ */
+export declare const keyboardOverlapOf: (keyboard: KeyboardFrame, offset: number) => number;
+/**
+ * The keyboard's height and how far it is open, as it moves. `onSettled` runs on the JS thread
+ * once it has finished moving.
+ */
+export declare const useKeyboardFrame: (onSettled?: () => void) => SharedValue<KeyboardFrame>;
+//# sourceMappingURL=useKeyboardOverlap.d.ts.map

package/lib/typescript/ai-components/conversation/list/useKeyboardOverlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardOverlap.d.ts","sourceRoot":"","sources":["../../../../../src/ai-components/conversation/list/useKeyboardOverlap.ts"],"names":[],"mappings":"AAEA,OAAO,EAAW,KAAK,WAAW,EAAkB,MAAM,yBAAyB,CAAC;AAEpF,MAAM,MAAM,aAAa,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjE;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,UAAU,aAAa,EAAE,QAAQ,MAAM,WAGxE,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GAAI,YAAY,MAAM,IAAI,KAAG,WAAW,CAAC,aAAa,CA8BlF,CAAC"}

package/lib/typescript/ai-components/conversation/list/useLoadOlder.d.ts

@@ -0,0 +1,24 @@
+import { type RefObject } from 'react';
+import type { LegendListRef } from '@legendapp/list/react-native';
+export type UseLoadOlderOptions = {
+    listRef: RefObject<LegendListRef | null>;
+    /** Loads the rows before the first one. `undefined` once there are none left. */
+    loadOlderMessages?: () => Promise<void> | void;
+};
+/**
+ * Loads older messages once the spinner above the turns has been in view a moment, and again
+ * while it stays in view after a load that failed, or brought nothing while there is more. Only
+ * while the list is at rest: on iOS, what arrives above while a finger holds the list, or while
+ * it glides or bounces, pushes what is in view down rather than staying out of sight.
+ *
+ * Returns the list's handlers for it, or none while there is nothing to load.
+ */
+export declare const useLoadOlder: ({ listRef, loadOlderMessages }: UseLoadOlderOptions) => {
+    onMomentumScrollBegin: () => void;
+    onMomentumScrollEnd: () => void;
+    onScrollBeginDrag: () => void;
+    onScrollEndDrag: () => void;
+    onStartReached: () => void;
+    onStartReachedThreshold: number;
+} | undefined;
+//# sourceMappingURL=useLoadOlder.d.ts.map

package/lib/typescript/ai-components/conversation/list/useLoadOlder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLoadOlder.d.ts","sourceRoot":"","sources":["../../../../../src/ai-components/conversation/list/useLoadOlder.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAkC,MAAM,OAAO,CAAC;AAEvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAUlE,MAAM,MAAM,mBAAmB,GAAG;IAChC,OAAO,EAAE,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IACzC,iFAAiF;IACjF,iBAAiB,CAAC,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC;CAChD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,YAAY,GAAI,gCAAgC,mBAAmB;;;;;;;aAsE/E,CAAC"}

package/lib/typescript/ai-components/conversation/list/usePinnedAnchor.d.ts

@@ -0,0 +1,26 @@
+import { type RefObject } from 'react';
+import type { AnchoredEndSpaceConfig, LegendListRef } from '@legendapp/list/react-native';
+export type UsePinnedAnchorOptions<T> = {
+    /** The key of the row to pin to the top, such as the latest question's. */
+    anchorKey: string | undefined;
+    data: readonly T[];
+    /** The height of the list's header, which its positions leave out. */
+    headerSize: RefObject<number>;
+    keyExtractor: (item: T) => string;
+    listRef: RefObject<LegendListRef | null>;
+    /** Called once the anchor is laid out, and whenever the room the list leaves under it changes. */
+    onAnchorLayout?: () => void;
+};
+/**
+ * Pins a row to the top of what is visible: the list leaves room under it (`anchoredEndSpace`),
+ * and a new anchor is scrolled to once it is laid out. The keyboard-aware list keeps that room as
+ * the scroll view's inset, which follows what is below the row shrinking, and which the keyboard
+ * takes before it lifts anything.
+ */
+export declare const usePinnedAnchor: <T>({ anchorKey, data, headerSize, keyExtractor, listRef, onAnchorLayout, }: UsePinnedAnchorOptions<T>) => {
+    anchoredEndSpace: AnchoredEndSpaceConfig | undefined;
+    onMetricsChange: ({ headerSize: size }: {
+        headerSize: number;
+    }) => void;
+};
+//# sourceMappingURL=usePinnedAnchor.d.ts.map

package/lib/typescript/ai-components/conversation/list/usePinnedAnchor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePinnedAnchor.d.ts","sourceRoot":"","sources":["../../../../../src/ai-components/conversation/list/usePinnedAnchor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAAiD,MAAM,OAAO,CAAC;AAEtF,OAAO,KAAK,EAAE,sBAAsB,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAI1F,MAAM,MAAM,sBAAsB,CAAC,CAAC,IAAI;IACtC,2EAA2E;IAC3E,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,IAAI,EAAE,SAAS,CAAC,EAAE,CAAC;IACnB,sEAAsE;IACtE,UAAU,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;IAC9B,YAAY,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;IAClC,OAAO,EAAE,SAAS,CAAC,aAAa,GAAG,IAAI,CAAC,CAAC;IACzC,kGAAkG;IAClG,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC;CAC7B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe,GAAI,CAAC,EAAE,yEAOhC,sBAAsB,CAAC,CAAC,CAAC;;4CAsDD;QAAE,UAAU,EAAE,MAAM,CAAA;KAAE;CA2BhD,CAAC"}

package/lib/typescript/ai-components/conversation/types.d.ts

@@ -0,0 +1,55 @@
+import type { AIUIDocument } from '../generative-ui/AIUIDocument';
+import type { AIMessageAttachmentData } from '../message/AIMessageAttachment';
+import type { AIMessageRating } from '../message/AIReplyActions';
+import type { AIMessagePartData } from '../message-parts/types';
+/** Who wrote a message: the person using the app (`user`) or the agent (`assistant`). */
+export type AIMessageRole = 'user' | 'assistant' | (string & {});
+/**
+ * A message of the conversation as the AI components show it. `fromStreamMessage` makes one
+ * from a Stream message.
+ */
+export type AIMessage = {
+    id: string;
+    /** Who wrote it. Each of the person's messages starts a turn. */
+    role: AIMessageRole;
+    /** What it says. A reply's text is Markdown. */
+    text: string;
+    /** What it carries besides its text, such as images and files. */
+    attachments?: AIMessageAttachmentData[];
+    /** Whether the agent is still writing it. */
+    isGenerating?: boolean;
+    /**
+     * How the person rated a reply, as your backend has it. An `AIConversationController` shows it
+     * until the person rates the reply on this device.
+     */
+    rating?: AIMessageRating | null;
+    /** The steps the agent took for it, in order: reasoning, tool calls and kinds of its own. */
+    parts?: AIMessagePartData[];
+    /**
+     * The whole of a reasoning step's thinking when the app has it, such as from live updates.
+     * Without it, the step shows its own excerpt. It is read on every render, so look it up
+     * rather than work it out.
+     */
+    reasoningText?: (stepId: string) => string | undefined;
+    /**
+     * The UI the agent wrote for a reply, which shows in place of its text when the
+     * conversation's `ui` host has a renderer for it. A person's message has none.
+     */
+    uiDocument?: AIUIDocument;
+};
+/**
+ * A message the person sent that is not in the conversation's messages yet. The conversation
+ * shows it until its copy arrives, and shows the agent thinking meanwhile.
+ */
+export type AIPendingMessage = {
+    /**
+     * The message's id once it arrives, when you know it (such as the id you send it with). Its
+     * copy is then found by it rather than by where it lands. Keep it the same while it waits.
+     */
+    id: string;
+    /** What the person wrote. */
+    text: string;
+    /** What they sent with it, such as the photos and files they picked. Its copy shows these too. */
+    attachments?: AIMessageAttachmentData[];
+};
+//# sourceMappingURL=types.d.ts.map

package/lib/typescript/ai-components/conversation/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/conversation/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,gCAAgC,CAAC;AAC9E,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,2BAA2B,CAAC;AACjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wBAAwB,CAAC;AAEhE,yFAAyF;AACzF,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG,WAAW,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAEjE;;;GAGG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,iEAAiE;IACjE,IAAI,EAAE,aAAa,CAAC;IACpB,gDAAgD;IAChD,IAAI,EAAE,MAAM,CAAC;IACb,kEAAkE;IAClE,WAAW,CAAC,EAAE,uBAAuB,EAAE,CAAC;IACxC,6CAA6C;IAC7C,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,eAAe,GAAG,IAAI,CAAC;IAChC,6FAA6F;IAC7F,KAAK,CAAC,EAAE,iBAAiB,EAAE,CAAC;IAC5B;;;;OAIG;IACH,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAC;IACvD;;;OAGG;IACH,UAAU,CAAC,EAAE,YAAY,CAAC;CAC3B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,6BAA6B;IAC7B,IAAI,EAAE,MAAM,CAAC;IACb,kGAAkG;IAClG,WAAW,CAAC,EAAE,uBAAuB,EAAE,CAAC;CACzC,CAAC"}

package/lib/typescript/ai-components/conversation/useConversationRows.d.ts

@@ -0,0 +1,66 @@
+import { type ReactNode } from 'react';
+import { type AIConversationCanShowUI, type AIConversationEntry } from './entries';
+import type { AIMessage, AIPendingMessage } from './types';
+import { AIThinkingClock } from '../reasoning/thinkingClock';
+/**
+ * Where a row is: the first of a turn, or within one. The first turn has the same room above it as
+ * the others, so older messages arriving above it leave it where it is.
+ */
+export type RowPosition = 'turn' | 'message';
+/** A row of the list: one message, with the turn it belongs to. */
+export type EntryRow = {
+    entry: AIConversationEntry;
+    key: string;
+    kind: 'entry';
+    position: RowPosition;
+    turnKey: string;
+    /** The turn's first reasoning step, which takes over the seconds the turn was seen thinking. */
+    firstStepId?: string;
+    /**
+     * When the agent started thinking again between the steps of this reply, which is being
+     * written, and which its seconds count from. It thinks under the reply, in the reply's row, so
+     * it moves with the reply's steps as they fold.
+     */
+    thinkingSince?: number;
+};
+/**
+ * What ends the latest turn: the agent thinking, and the app's footer. A row of its own rather than
+ * the list's footer: the list lays its rows out itself, together with the room it leaves under the
+ * latest turn, while a footer that goes away shrinks the content at once, which moves the view.
+ */
+export type TailRow = {
+    isThinking: boolean;
+    key: string;
+    kind: 'tail';
+    turnKey: string;
+    firstStepId?: string;
+    footer?: ReactNode;
+};
+export type ConversationRow = EntryRow | TailRow;
+export type UseConversationRowsOptions = {
+    messages: AIMessage[];
+    /** Whether a reply's generated UI shows, so a reply that shows only UI has a row. */
+    canShowUI?: AIConversationCanShowUI;
+    footer?: ReactNode;
+    isThinking?: boolean;
+    /** Whether `isThinking` alone says whether the agent is thinking, rather than the rows too. */
+    isThinkingKnown?: boolean;
+    pendingMessage?: AIPendingMessage | null;
+};
+export type ConversationRows = {
+    /** The key of the latest turn's first row, which pins to the top: `undefined` with no turns. */
+    anchorKey: string | undefined;
+    /** The turns' thinking clock, for `AIThinkingTurnContext`. */
+    clock: AIThinkingClock;
+    /** The rows to list: each message, then what ends the latest turn while there is any. */
+    rows: ConversationRow[];
+    /** Whether there are no messages to show yet, not even one on its way. */
+    isEmpty: boolean;
+};
+/**
+ * The conversation's data, as rows for a list: its messages grouped into turns, a message on its
+ * way until its copy arrives, and what ends the latest turn. Each unchanged row keeps its object,
+ * so the list renders only the rows that changed. Knows nothing about the list itself.
+ */
+export declare const useConversationRows: ({ canShowUI, footer, isThinking, isThinkingKnown, messages, pendingMessage, }: UseConversationRowsOptions) => ConversationRows;
+//# sourceMappingURL=useConversationRows.d.ts.map

package/lib/typescript/ai-components/conversation/useConversationRows.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useConversationRows.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/conversation/useConversationRows.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,SAAS,EAA8C,MAAM,OAAO,CAAC;AAEnF,OAAO,EACL,KAAK,uBAAuB,EAC5B,KAAK,mBAAmB,EAKzB,MAAM,WAAW,CAAC;AACnB,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAG3D,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAE7D;;;GAGG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,SAAS,CAAC;AAE7C,mEAAmE;AACnE,MAAM,MAAM,QAAQ,GAAG;IACrB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,OAAO,CAAC;IACd,QAAQ,EAAE,WAAW,CAAC;IACtB,OAAO,EAAE,MAAM,CAAC;IAChB,gGAAgG;IAChG,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB;;;;OAIG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,OAAO,GAAG;IACpB,UAAU,EAAE,OAAO,CAAC;IACpB,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,MAAM,CAAC,EAAE,SAAS,CAAC;CACpB,CAAC;AAEF,MAAM,MAAM,eAAe,GAAG,QAAQ,GAAG,OAAO,CAAC;AAqCjD,MAAM,MAAM,0BAA0B,GAAG;IACvC,QAAQ,EAAE,SAAS,EAAE,CAAC;IACtB,qFAAqF;IACrF,SAAS,CAAC,EAAE,uBAAuB,CAAC;IACpC,MAAM,CAAC,EAAE,SAAS,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,+FAA+F;IAC/F,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,cAAc,CAAC,EAAE,gBAAgB,GAAG,IAAI,CAAC;CAC1C,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,gGAAgG;IAChG,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,8DAA8D;IAC9D,KAAK,EAAE,eAAe,CAAC;IACvB,yFAAyF;IACzF,IAAI,EAAE,eAAe,EAAE,CAAC;IACxB,0EAA0E;IAC1E,OAAO,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,+EAOjC,0BAA0B,KAAG,gBA0G/B,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIAction.d.ts

@@ -0,0 +1,48 @@
+import type { AIUIFormat } from './AIUIDocument';
+/**
+ * What the person did in a reply's UI, such as tapping a place or submitting a form. It goes to
+ * the agent as their next message: `label` is its text and `aiUIActionJSON(action)` what it
+ * carries.
+ */
+export type AIUIAction = {
+    /** The format of the UI it came from. */
+    format: AIUIFormat;
+    /** What the person did, in their words, such as "Tell me more about St. Naum". */
+    label: string;
+    /** The reply whose UI it came from. */
+    messageId: string;
+    /**
+     * What happened, such as an event of an app's component (`ask_about`) or OpenUI's
+     * `continue_conversation`.
+     */
+    name: string;
+    /** The details in the format's own shape, such as what was chosen and a form's values. */
+    payload: Record<string, unknown>;
+};
+/** The action as the JSON object an agent's backend reads. */
+export type AIUIActionJSON = {
+    format: AIUIFormat;
+    message_id: string;
+    name: string;
+    payload: Record<string, unknown>;
+    v: 1;
+};
+/** The custom field of the person's message that holds the action. */
+export declare const AI_UI_ACTION_CUSTOM_DATA_KEY = "ai_ui_action";
+/**
+ * The most an action may take as JSON. The agents router refuses a larger one, and its
+ * refusal would lose the person's message with it.
+ */
+export declare const AI_UI_ACTION_MAX_BYTES: number;
+/**
+ * The action as the JSON object an agent's backend reads, such as the `uiAction` of
+ * `session.responses.create(action.label, { uiAction })`. The label is not in it: it is the
+ * text of the person's message.
+ */
+export declare const aiUIActionJSON: (action: AIUIAction) => AIUIActionJSON;
+/**
+ * Why the agent's backend would refuse the action, or `undefined` when it would take it: it
+ * names its reply, its format and what happened, in at most `AI_UI_ACTION_MAX_BYTES` of JSON.
+ */
+export declare const aiUIActionProblem: (action: AIUIAction) => string | undefined;
+//# sourceMappingURL=AIUIAction.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIAction.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIAction.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGjD;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,yCAAyC;IACzC,MAAM,EAAE,UAAU,CAAC;IACnB,kFAAkF;IAClF,KAAK,EAAE,MAAM,CAAC;IACd,uCAAuC;IACvC,SAAS,EAAE,MAAM,CAAC;IAClB;;;OAGG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,0FAA0F;IAC1F,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAClC,CAAC;AAEF,8DAA8D;AAC9D,MAAM,MAAM,cAAc,GAAG;IAC3B,MAAM,EAAE,UAAU,CAAC;IACnB,UAAU,EAAE,MAAM,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACjC,CAAC,EAAE,CAAC,CAAC;CACN,CAAC;AAEF,sEAAsE;AACtE,eAAO,MAAM,4BAA4B,iBAAiB,CAAC;AAC3D;;;GAGG;AACH,eAAO,MAAM,sBAAsB,QAAW,CAAC;AAE/C;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,QAAQ,UAAU,KAAG,cAMlD,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,UAAU,KAAG,MAAM,GAAG,SAc/D,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIArguments.d.ts

@@ -0,0 +1,15 @@
+import type { AIUIParameter } from './AIUIComponentDefinition';
+/**
+ * A date the agent wrote: an RFC 3339 moment, or a whole day as `yyyy-MM-dd` that the calendar
+ * has, which is that day's start where the person is. Anything else is not a date.
+ */
+export declare const aiUIDate: (text: string) => Date | undefined;
+/** `place_name` as `placeName`, the way the agent's snake_case reads in JavaScript. */
+export declare const aiUICamelCase: (key: string) => string;
+/**
+ * The arguments the agent wrote for a component, as its view reads them: keys in camelCase,
+ * dates as `Date`s. `undefined` while they do not fit its parameters, such as while they are
+ * still streaming in: a required one is missing, or one is of the wrong type.
+ */
+export declare const decodeAIUIArguments: <Arguments = Record<string, unknown>>(args: Record<string, unknown>, parameters: AIUIParameter[]) => Arguments | undefined;
+//# sourceMappingURL=AIUIArguments.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIArguments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIArguments.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIArguments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAkB,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAU/E;;;GAGG;AACH,eAAO,MAAM,QAAQ,GAAI,MAAM,MAAM,KAAG,IAAI,GAAG,SAa9C,CAAC;AAEF,uFAAuF;AACvF,eAAO,MAAM,aAAa,GAAI,KAAK,MAAM,WAUxC,CAAC;AA6DF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrE,MAAM,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC7B,YAAY,aAAa,EAAE,KAC1B,SAAS,GAAG,SAOd,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIComponent.d.ts

@@ -0,0 +1,51 @@
+import React, { type ComponentType } from 'react';
+import type { AIUIComponentDefinition } from './AIUIComponentDefinition';
+import type { AIUIHost } from './AIUIHost';
+/** Where an app's component is shown, and how it tells the agent what the person did. */
+export type AIUIComponentContext = {
+    /**
+     * Tells the agent about one of the component's events, as the person's next message.
+     * `label` is what the person did, in their words, such as "Tell me more about St. Naum".
+     */
+    emit: (event: string, label: string, payload?: Record<string, unknown>) => void;
+    /** The conversation's host, for running the app's tools and opening links. */
+    host: AIUIHost;
+    /** Whether the agent is still writing the reply's UI, so the arguments may still change. */
+    isStreaming: boolean;
+    /** The reply the component is in. */
+    messageId: string;
+};
+export type AIUIComponentProps<Arguments> = {
+    /** What the agent filled in: keys in camelCase, dates as `Date`s. */
+    args: Arguments;
+    context: AIUIComponentContext;
+};
+/**
+ * One of the app's views that the agent can place in a reply's UI, in whichever format it
+ * writes, such as a map or a card over the app's own data.
+ */
+export type AIUIComponent = {
+    Component: ComponentType<AIUIComponentProps<never>>;
+    /** Its description, the same on every platform and for the agent. */
+    definition: AIUIComponentDefinition;
+};
+/**
+ * One of the app's components, with what its view reads from the agent's arguments. The view
+ * gets them only once they fit the definition's parameters, so it can rely on their types.
+ *
+ * A conversation reuses its views: one scrolled out of sight shows another reply's UI next, so
+ * state the view keeps of its own has to start afresh for a new `context.messageId`.
+ */
+export declare const defineAIUIComponent: <Arguments>(definition: AIUIComponentDefinition, Component: ComponentType<AIUIComponentProps<Arguments>>) => AIUIComponent;
+/**
+ * An app's component for the arguments the agent wrote, coming in as it shows, or nothing
+ * while they don't fit its parameters, such as while they are still streaming in. Renderers
+ * place the app's components with it. One that throws leaves only itself out of the reply's
+ * UI, is tried again when its arguments change, and is reported once the reply is written.
+ */
+export declare const AIUIComponentView: ({ args, component, context, }: {
+    args: Record<string, unknown>;
+    component: AIUIComponent;
+    context: AIUIComponentContext;
+}) => React.JSX.Element | null;
+//# sourceMappingURL=AIUIComponent.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIComponent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIComponent.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIComponent.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,KAAK,aAAa,EAAW,MAAM,OAAO,CAAC;AAG3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,2BAA2B,CAAC;AAGzE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,yFAAyF;AACzF,MAAM,MAAM,oBAAoB,GAAG;IACjC;;;OAGG;IACH,IAAI,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAC;IAChF,8EAA8E;IAC9E,IAAI,EAAE,QAAQ,CAAC;IACf,4FAA4F;IAC5F,WAAW,EAAE,OAAO,CAAC;IACrB,qCAAqC;IACrC,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AAEF,MAAM,MAAM,kBAAkB,CAAC,SAAS,IAAI;IAC1C,qEAAqE;IACrE,IAAI,EAAE,SAAS,CAAC;IAChB,OAAO,EAAE,oBAAoB,CAAC;CAC/B,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B,SAAS,EAAE,aAAa,CAAC,kBAAkB,CAAC,KAAK,CAAC,CAAC,CAAC;IACpD,qEAAqE;IACrE,UAAU,EAAE,uBAAuB,CAAC;CACrC,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,SAAS,EAC3C,YAAY,uBAAuB,EACnC,WAAW,aAAa,CAAC,kBAAkB,CAAC,SAAS,CAAC,CAAC,KACtD,aAID,CAAC;AAWH;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,+BAI/B;IACD,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,SAAS,EAAE,aAAa,CAAC;IACzB,OAAO,EAAE,oBAAoB,CAAC;CAC/B,6BA2BA,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIComponentDefinition.d.ts

@@ -0,0 +1,84 @@
+/** A JSON Schema, as a component's parameters are described to the agent. */
+export type AIUIJSONSchema = Record<string, unknown>;
+/** Something the agent fills in for a component. */
+export type AIUIParameter = {
+    /** Whether the agent must fill it in. */
+    isRequired: boolean;
+    /** The name the agent fills it in by, such as `title`. */
+    name: string;
+    /** What it holds, as a JSON Schema, such as `AIUIParameterType.string`. */
+    type: AIUIJSONSchema;
+    /** What it is, for the agent. */
+    description?: string;
+};
+/** Something a component reports when the person uses it, such as tapping a place. */
+export type AIUIComponentEvent = {
+    /** When it happens, for the agent. */
+    description: string;
+    /** The name it is reported by, such as `ask_about`. */
+    name: string;
+    /** What it carries, in order. */
+    parameters: AIUIParameter[];
+};
+/**
+ * An app's component as the agent knows it: its name, what it shows, what the agent fills in
+ * and what it reports. It is portable JSON, the same on every platform, so one description
+ * (such as a `UIComponents.json` shared with the iOS and Android apps) serves them all.
+ */
+export type AIUIComponentDefinition = {
+    /** What it shows and when to use it, for the agent. */
+    description: string;
+    /** What it reports when the person uses it. */
+    events: AIUIComponentEvent[];
+    /** The name the agent places it by, such as `place_card`. */
+    name: string;
+    /**
+     * What the agent fills in, in order: a format such as OpenUI Lang passes arguments by
+     * position.
+     */
+    parameters: AIUIParameter[];
+};
+/** The types a parameter commonly has, as JSON Schemas. */
+export declare const AIUIParameterType: {
+    /** A list of values of one type. */
+    array: (items: AIUIJSONSchema) => AIUIJSONSchema;
+    boolean: AIUIJSONSchema;
+    /** A day, such as `2026-11-14`. */
+    date: AIUIJSONSchema;
+    /** A moment, such as `2026-11-14T09:30:00Z`. */
+    dateTime: AIUIJSONSchema;
+    /** One of a fixed set of strings. */
+    enumeration: (values: string[]) => AIUIJSONSchema;
+    integer: AIUIJSONSchema;
+    number: AIUIJSONSchema;
+    /** An object with named fields, in order. */
+    object: (fields: AIUIParameter[]) => AIUIJSONSchema;
+    string: AIUIJSONSchema;
+    /** A link, such as an image's. */
+    url: AIUIJSONSchema;
+};
+/** A parameter the agent must fill in. */
+export declare const requiredAIUIParameter: (name: string, type: AIUIJSONSchema, description?: string) => AIUIParameter;
+/** A parameter the agent may leave out. */
+export declare const optionalAIUIParameter: (name: string, type: AIUIJSONSchema, description?: string) => AIUIParameter;
+/** Parameters as a JSON Schema object, the way a tool's are described, keeping their order. */
+export declare const aiUIObjectSchema: (parameters: AIUIParameter[]) => AIUIJSONSchema;
+/** The fields of a JSON Schema object, in the order it keeps, then by name. */
+export declare const aiUIParametersOf: (schema: unknown) => AIUIParameter[];
+/**
+ * Reads a component's portable JSON, such as one entry of a `UIComponents.json`, or returns
+ * `undefined` for one without a name.
+ */
+export declare const parseAIUIComponentDefinition: (json: unknown) => AIUIComponentDefinition | undefined;
+/** A component's portable JSON, as `parseAIUIComponentDefinition` reads it back. */
+export declare const aiUIComponentDefinitionJSON: (definition: AIUIComponentDefinition) => {
+    description: string;
+    events: {
+        parameters?: AIUIJSONSchema | undefined;
+        description: string;
+        name: string;
+    }[];
+    name: string;
+    parameters: AIUIJSONSchema;
+};
+//# sourceMappingURL=AIUIComponentDefinition.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIComponentDefinition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIComponentDefinition.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIComponentDefinition.ts"],"names":[],"mappings":"AAEA,6EAA6E;AAC7E,MAAM,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAErD,oDAAoD;AACpD,MAAM,MAAM,aAAa,GAAG;IAC1B,yCAAyC;IACzC,UAAU,EAAE,OAAO,CAAC;IACpB,0DAA0D;IAC1D,IAAI,EAAE,MAAM,CAAC;IACb,2EAA2E;IAC3E,IAAI,EAAE,cAAc,CAAC;IACrB,iCAAiC;IACjC,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB,CAAC;AAEF,sFAAsF;AACtF,MAAM,MAAM,kBAAkB,GAAG;IAC/B,sCAAsC;IACtC,WAAW,EAAE,MAAM,CAAC;IACpB,uDAAuD;IACvD,IAAI,EAAE,MAAM,CAAC;IACb,iCAAiC;IACjC,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,uBAAuB,GAAG;IACpC,uDAAuD;IACvD,WAAW,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,MAAM,EAAE,kBAAkB,EAAE,CAAC;IAC7B,6DAA6D;IAC7D,IAAI,EAAE,MAAM,CAAC;IACb;;;OAGG;IACH,UAAU,EAAE,aAAa,EAAE,CAAC;CAC7B,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,iBAAiB;IAC5B,oCAAoC;mBACrB,cAAc,KAAG,cAAc;aACd,cAAc;IAC9C,mCAAmC;UACS,cAAc;IAC1D,gDAAgD;cACK,cAAc;IACnE,qCAAqC;0BACf,MAAM,EAAE,KAAG,cAAc;aACf,cAAc;YAChB,cAAc;IAC5C,6CAA6C;qBAC5B,aAAa,EAAE,KAAG,cAAc;YACnB,cAAc;IAC5C,kCAAkC;SACQ,cAAc;CACzD,CAAC;AAEF,0CAA0C;AAC1C,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,MAAM,cAAc,EACpB,cAAc,MAAM,KACnB,aAAgE,CAAC;AAEpE,2CAA2C;AAC3C,eAAO,MAAM,qBAAqB,GAChC,MAAM,MAAM,EACZ,MAAM,cAAc,EACpB,cAAc,MAAM,KACnB,aAAiE,CAAC;AAQrE,+FAA+F;AAC/F,eAAO,MAAM,gBAAgB,GAAI,YAAY,aAAa,EAAE,KAAG,cAU7D,CAAC;AAEH,+EAA+E;AAC/E,eAAO,MAAM,gBAAgB,GAAI,QAAQ,OAAO,KAAG,aAAa,EAqB/D,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,4BAA4B,GACvC,MAAM,OAAO,KACZ,uBAAuB,GAAG,SAqB5B,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,2BAA2B,GAAI,YAAY,uBAAuB;;;;;;;;;CAS7E,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIDocument.d.ts

@@ -0,0 +1,50 @@
+/**
+ * The format a reply's UI is written in, such as `a2ui` or `openui`. Formats are an open set:
+ * a renderer says which one it reads.
+ */
+export type AIUIFormat = 'a2ui' | 'openui' | (string & {});
+/**
+ * The UI an agent wrote for a reply, which shows in place of the reply's text.
+ */
+export type AIUIDocument = {
+    /** The document in its format's own shape: a program's text, or JSON. */
+    content: unknown;
+    /** The format it is written in. */
+    format: AIUIFormat;
+    /** Whether the agent is still writing it. */
+    isStreaming: boolean;
+    /** The format's version, when the agent names one. */
+    version?: string;
+};
+/**
+ * A reply's `ai_ui` field as the agents router writes it. An app that reads it from its Stream
+ * messages types it there with `ai_ui?: AIUIDocumentJSON` in its `CustomMessageData`.
+ */
+export type AIUIDocumentJSON = {
+    /** The document in its format's own shape: usually text, such as A2UI's JSON lines. */
+    content: unknown;
+    format: AIUIFormat;
+    /** `streaming` while the agent writes it, then `complete`. */
+    status?: 'streaming' | 'complete' | (string & {});
+    /** The version of the field's own layout; a newer one than this SDK reads shows the text. */
+    v?: number;
+    version?: string;
+};
+/** The custom field of a message that holds its document. */
+export declare const AI_UI_CUSTOM_DATA_KEY = "ai_ui";
+/** The newest version of the `ai_ui` field this SDK reads. */
+export declare const AI_UI_SUPPORTED_VERSION = 1;
+/**
+ * Reads the document of a message's `ai_ui` field, or returns `undefined` when it carries none
+ * this SDK can read: no format, no content, or a field newer than this SDK, which can lay its
+ * documents out differently. The reply then shows its text.
+ */
+export declare const parseAIUIDocument: (field: unknown) => AIUIDocument | undefined;
+/** The content of a document when it is text, such as an OpenUI program or A2UI's JSON lines. */
+export declare const aiUIDocumentText: (document: AIUIDocument) => string | undefined;
+/**
+ * Whether two documents are the same, content included. A message is a new object on every
+ * update while a reply streams, so a document is compared by what it holds.
+ */
+export declare const isSameAIUIDocument: (a: AIUIDocument | undefined, b: AIUIDocument | undefined) => boolean;
+//# sourceMappingURL=AIUIDocument.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIDocument.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIDocument.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIDocument.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;AAE3D;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG;IACzB,yEAAyE;IACzE,OAAO,EAAE,OAAO,CAAC;IACjB,mCAAmC;IACnC,MAAM,EAAE,UAAU,CAAC;IACnB,6CAA6C;IAC7C,WAAW,EAAE,OAAO,CAAC;IACrB,sDAAsD;IACtD,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,uFAAuF;IACvF,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,EAAE,UAAU,CAAC;IACnB,8DAA8D;IAC9D,MAAM,CAAC,EAAE,WAAW,GAAG,UAAU,GAAG,CAAC,MAAM,GAAG,EAAE,CAAC,CAAC;IAClD,6FAA6F;IAC7F,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB,CAAC;AAEF,6DAA6D;AAC7D,eAAO,MAAM,qBAAqB,UAAU,CAAC;AAC7C,8DAA8D;AAC9D,eAAO,MAAM,uBAAuB,IAAI,CAAC;AAEzC;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,YAAY,GAAG,SAYjE,CAAC;AAEF,iGAAiG;AACjG,eAAO,MAAM,gBAAgB,GAAI,UAAU,YAAY,uBACc,CAAC;AAEtE;;;GAGG;AACH,eAAO,MAAM,kBAAkB,GAAI,GAAG,YAAY,GAAG,SAAS,EAAE,GAAG,YAAY,GAAG,SAAS,YAOtD,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIEntrance.d.ts

@@ -0,0 +1,75 @@
+import React, { type ReactNode } from 'react';
+import { type StyleProp, type ViewStyle } from 'react-native';
+/**
+ * Spaces out the parts of a reply's UI that come in together, so they come in one after another
+ * rather than at once.
+ */
+export declare class AIUICascade {
+    /** How long after the part before it a part comes in, in seconds. */
+    static readonly step = 0.1;
+    /** The longest a part waits for the parts before it, in seconds. */
+    static readonly longestWait = 0.4;
+    private next;
+    /** How long a part that comes in at `now`, in seconds, waits for the parts before it. */
+    delay(now?: number): number;
+}
+/**
+ * A reply's generated UI as a whole: it comes in when it first shows while the agent writes it,
+ * and shows at once when it was written before, such as a reply from history.
+ */
+export declare const AIUIEntranceStage: ({ children, isStreaming, resetKey, style, }: {
+    children: ReactNode;
+    /** Whether the agent is writing the UI as it first shows. */
+    isStreaming: boolean;
+    /**
+     * Which reply's UI it shows: when it changes, it shows the UI as one mounted for it would, as
+     * when a list reuses it for another reply.
+     */
+    resetKey?: unknown;
+    style?: StyleProp<ViewStyle>;
+}) => React.JSX.Element;
+/**
+ * Whether a part of a reply's generated UI comes in, as it was when the part mounted: a part
+ * that shows at once, such as one of a reply from history, can show in a plain view.
+ */
+export declare const useAIUIComesIn: () => boolean;
+/**
+ * What a part of a reply's generated UI needs to come in when it shows, for a renderer that
+ * animates a view of its own rather than wrap the part in `AIUIEntrance`: the animated `style`
+ * for that view, and `scope`, to wrap what the part shows in, so what shows with it comes in
+ * with it. The same entrance as `AIUIEntrance`'s.
+ */
+export declare const useAIUIEntrance: () => {
+    scope: (children: ReactNode) => React.JSX.Element;
+    style: ({
+        transformOrigin: string;
+    } | import("react-native-reanimated/lib/typescript/hook/commonTypes").AnimatedStyleHandle<{
+        opacity: number;
+    } | {
+        filter?: {
+            blur: number;
+        }[] | undefined;
+        opacity: number;
+        transform: ({
+            translateY: number;
+            scale?: undefined;
+        } | {
+            scale: number;
+            translateY?: undefined;
+        })[];
+    }>)[];
+};
+/**
+ * Brings a part of a reply's generated UI in when it shows, such as when the agent writes it:
+ * the part fades in, rising into place and, on Android 12 and later, coming into focus, after the
+ * parts that came in just before it. What shows together with the reply's UI, or with a part
+ * around it, comes in with that, so a reply written before it showed shows at once. With reduced
+ * motion it only fades.
+ *
+ * Renderers give it to each part they place. Every app component has it.
+ */
+export declare const AIUIEntrance: ({ children, style, }: {
+    children: ReactNode;
+    style?: StyleProp<ViewStyle>;
+}) => React.JSX.Element;
+//# sourceMappingURL=AIUIEntrance.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIEntrance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIEntrance.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIEntrance.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAEZ,KAAK,SAAS,EAOf,MAAM,OAAO,CAAC;AACf,OAAO,EAAY,KAAK,SAAS,EAAoB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAC;AAa1F;;;GAGG;AACH,qBAAa,WAAW;IACtB,qEAAqE;IACrE,MAAM,CAAC,QAAQ,CAAC,IAAI,OAAO;IAC3B,oEAAoE;IACpE,MAAM,CAAC,QAAQ,CAAC,WAAW,OAAO;IAElC,OAAO,CAAC,IAAI,CAAK;IAEjB,yFAAyF;IACzF,KAAK,CAAC,GAAG,SAA+E;CAKzF;AAqED;;;GAGG;AACH,eAAO,MAAM,iBAAiB,GAAI,6CAK/B;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,6DAA6D;IAC7D,WAAW,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B,sBAsBA,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,eAI1B,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe;sBAQP,SAAS;;;;;;;;;;;;;;;;;;CAM7B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,sBAG1B;IACD,QAAQ,EAAE,SAAS,CAAC;IACpB,KAAK,CAAC,EAAE,SAAS,CAAC,SAAS,CAAC,CAAC;CAC9B,sBAOA,CAAC"}

package/lib/typescript/ai-components/generative-ui/AIUIErrorBoundary.d.ts

@@ -0,0 +1,26 @@
+import { Component, type ReactNode } from 'react';
+type AIUIErrorBoundaryProps = {
+    children: ReactNode;
+    onError: (error: unknown) => void;
+    /** Tries the children again when it changes, such as when what they show changed. */
+    resetKey?: unknown;
+};
+type AIUIErrorBoundaryState = {
+    hasError: boolean;
+    resetKey: unknown;
+};
+/**
+ * Keeps generated UI that throws while it renders, such as an app's component given what it
+ * didn't expect, from taking what is around it down with it. It shows nothing and says so.
+ */
+export declare class AIUIErrorBoundary extends Component<AIUIErrorBoundaryProps, AIUIErrorBoundaryState> {
+    state: AIUIErrorBoundaryState;
+    static getDerivedStateFromError(): {
+        hasError: boolean;
+    };
+    static getDerivedStateFromProps(props: AIUIErrorBoundaryProps, state: AIUIErrorBoundaryState): Partial<AIUIErrorBoundaryState> | null;
+    componentDidCatch(error: unknown): void;
+    render(): ReactNode;
+}
+export {};
+//# sourceMappingURL=AIUIErrorBoundary.d.ts.map

package/lib/typescript/ai-components/generative-ui/AIUIErrorBoundary.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"AIUIErrorBoundary.d.ts","sourceRoot":"","sources":["../../../../src/ai-components/generative-ui/AIUIErrorBoundary.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAElD,KAAK,sBAAsB,GAAG;IAC5B,QAAQ,EAAE,SAAS,CAAC;IACpB,OAAO,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;IAClC,qFAAqF;IACrF,QAAQ,CAAC,EAAE,OAAO,CAAC;CACpB,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAAE,QAAQ,EAAE,OAAO,CAAC;IAAC,QAAQ,EAAE,OAAO,CAAA;CAAE,CAAC;AAEvE;;;GAGG;AACH,qBAAa,iBAAkB,SAAQ,SAAS,CAAC,sBAAsB,EAAE,sBAAsB,CAAC;IAC9F,KAAK,EAAE,sBAAsB,CAAsD;IAEnF,MAAM,CAAC,wBAAwB;;;IAI/B,MAAM,CAAC,wBAAwB,CAC7B,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,sBAAsB,GAC5B,OAAO,CAAC,sBAAsB,CAAC,GAAG,IAAI;IAMzC,iBAAiB,CAAC,KAAK,EAAE,OAAO;IAIhC,MAAM;CAGP"}