@blocklet/pages-kit 0.2.286 → 0.2.288

package/lib/esm/builtin/async/ai-runtime/state/session.js

@@ -0,0 +1,209 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { RuntimeOutputVariableNames } from '@blocklet/ai-runtime/types';
+import pick from 'lodash/pick';
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { deleteMessages, getMessages } from '../api/message';
+import { getSession, runAssistant, updateSession } from '../api/session';
+import { deepMerge, parseIdentity } from '../utils';
+const STATES = {};
+export const createSessionState = ({ sessionId, session }) => {
+    var _a;
+    (_a = STATES[sessionId]) !== null && _a !== void 0 ? _a : (STATES[sessionId] = create()(immer((set, get) => ({
+        session,
+        clearSession: (_b) => __awaiter(void 0, [_b], void 0, function* ({ sessionId }) {
+            yield deleteMessages({ sessionId });
+            yield get().load();
+        }),
+        updateSession: (_c) => __awaiter(void 0, [_c], void 0, function* ({ parameters }) {
+            const { updated } = yield updateSession({ sessionId, parameters });
+            set((state) => {
+                state.session = updated;
+            });
+        }),
+        load: () => __awaiter(void 0, void 0, void 0, function* () {
+            set((state) => {
+                state.loading = true;
+            });
+            try {
+                const [{ session }, { messages }] = yield Promise.all([
+                    getSession({ sessionId }),
+                    getMessages({ sessionId }),
+                ]);
+                set((state) => {
+                    state.session = session;
+                    state.messages = messages;
+                });
+            }
+            catch (error) {
+                set((state) => {
+                    state.error = error;
+                });
+                throw error;
+            }
+            finally {
+                set((state) => {
+                    state.loading = false;
+                });
+            }
+        }),
+        execute: (_d) => __awaiter(void 0, [_d], void 0, function* ({ assistantId, parameters, onResponseStart, includeSessionParameters, }) {
+            var _e, e_1, _f, _g;
+            var _h, _j, _k, _l, _m;
+            const identity = parseIdentity(assistantId, { rejectWhenError: true });
+            let message;
+            const childMessages = [];
+            const childMessagesMap = {};
+            set((state) => {
+                state.running = true;
+                state.error = undefined;
+            });
+            let realParameters = Object.assign(Object.assign({}, parameters), { $clientTime: new Date().toISOString() });
+            if (includeSessionParameters) {
+                realParameters = Object.assign(Object.assign({}, (_h = get().session) === null || _h === void 0 ? void 0 : _h.parameters), parameters);
+            }
+            try {
+                const stream = runAssistant({
+                    sessionId,
+                    identity,
+                    parameters: realParameters,
+                });
+                let responseStarted = false;
+                try {
+                    for (var _o = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _e = stream_1_1.done, !_e; _o = true) {
+                        _g = stream_1_1.value;
+                        _o = false;
+                        const value = _g;
+                        if (!responseStarted) {
+                            responseStarted = true;
+                            onResponseStart === null || onResponseStart === void 0 ? void 0 : onResponseStart();
+                        }
+                        if ((value === null || value === void 0 ? void 0 : value.type) === 'CHUNK') {
+                            if (!message) {
+                                message = {
+                                    taskId: value.taskId,
+                                    sessionId,
+                                    parameters,
+                                    createdAt: new Date().toISOString(),
+                                    updatedAt: new Date().toISOString(),
+                                    loading: true,
+                                };
+                                set((state) => {
+                                    var _a;
+                                    (_a = state.messages) !== null && _a !== void 0 ? _a : (state.messages = []);
+                                    state.messages.push(message);
+                                });
+                            }
+                            if (message.taskId === value.taskId) {
+                                set((state) => {
+                                    var _a, _b, _c, _d, _e, _f, _g;
+                                    var _h;
+                                    const msg = (_a = state.messages) === null || _a === void 0 ? void 0 : _a.findLast((i) => i.taskId === message.taskId);
+                                    if (!msg)
+                                        return;
+                                    (_b = msg.result) !== null && _b !== void 0 ? _b : (msg.result = {});
+                                    msg.result.content = (msg.result.content || '') + (value.delta.content || '');
+                                    if ((_d = (_c = value.delta) === null || _c === void 0 ? void 0 : _c.images) === null || _d === void 0 ? void 0 : _d.length) {
+                                        msg.result.images = ((_e = msg.result.images) !== null && _e !== void 0 ? _e : []).concat(value.delta.images);
+                                    }
+                                    if (value.delta.object) {
+                                        (_f = (_h = msg.result).objects) !== null && _f !== void 0 ? _f : (_h.objects = []);
+                                        msg.result.objects.push({ taskId: value.taskId, data: value.delta.object });
+                                        if (value.delta.object) {
+                                            (_g = state.metadata) !== null && _g !== void 0 ? _g : (state.metadata = {});
+                                            deepMerge(state.metadata, pick(value.delta.object, RuntimeOutputVariableNames));
+                                        }
+                                    }
+                                });
+                            }
+                            else if (value.respondAs && value.respondAs !== 'none') {
+                                let childMessage = childMessagesMap[value.taskId];
+                                if (!childMessage) {
+                                    childMessage = {
+                                        taskId: value.taskId,
+                                        respondAs: value.respondAs,
+                                    };
+                                    childMessagesMap[value.taskId] = childMessage;
+                                    childMessages.push(childMessage);
+                                }
+                                (_j = childMessage.result) !== null && _j !== void 0 ? _j : (childMessage.result = {});
+                                childMessage.result.content = (childMessage.result.content || '') + (value.delta.content || '');
+                                if ((_l = (_k = value.delta) === null || _k === void 0 ? void 0 : _k.images) === null || _l === void 0 ? void 0 : _l.length) {
+                                    childMessage.result.images = ((_m = childMessage.result.images) !== null && _m !== void 0 ? _m : []).concat(value.delta.images);
+                                }
+                                set((state) => {
+                                    var _a, _b;
+                                    const msg = (_a = state.messages) === null || _a === void 0 ? void 0 : _a.findLast((i) => i.taskId === message.taskId);
+                                    if (!msg)
+                                        return;
+                                    (_b = msg.result) !== null && _b !== void 0 ? _b : (msg.result = {});
+                                    msg.result.messages = JSON.parse(JSON.stringify(childMessages));
+                                });
+                            }
+                        }
+                        if ((value === null || value === void 0 ? void 0 : value.type) === 'ERROR') {
+                            set((state) => {
+                                var _a;
+                                const msg = (_a = state.messages) === null || _a === void 0 ? void 0 : _a.findLast((i) => i.taskId === message.taskId);
+                                if (msg)
+                                    msg.error = value.error;
+                                else
+                                    throw new Error(value.error.message);
+                            });
+                        }
+                    }
+                }
+                catch (e_1_1) { e_1 = { error: e_1_1 }; }
+                finally {
+                    try {
+                        if (!_o && !_e && (_f = stream_1.return)) yield _f.call(stream_1);
+                    }
+                    finally { if (e_1) throw e_1.error; }
+                }
+            }
+            catch (error) {
+                set((state) => {
+                    state.error = error;
+                });
+            }
+            finally {
+                set((state) => {
+                    var _a;
+                    state.running = false;
+                    if (message) {
+                        const msg = (_a = state.messages) === null || _a === void 0 ? void 0 : _a.findLast((i) => i.taskId === message.taskId);
+                        if (msg)
+                            msg.loading = false;
+                    }
+                });
+            }
+        }),
+    }))));
+    return STATES[sessionId];
+};
+const LOADING_TASKS = {};
+export function useSessionState({ sessionId, required }) {
+    var _a;
+    const state = createSessionState({ sessionId })();
+    if (!state.session) {
+        (_a = LOADING_TASKS[sessionId]) !== null && _a !== void 0 ? _a : (LOADING_TASKS[sessionId] = state.load());
+        if (required)
+            throw LOADING_TASKS[sessionId];
+    }
+    return [state.session, state];
+}

package/lib/esm/builtin/async/ai-runtime/state/subscription.js

@@ -0,0 +1,47 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { create } from 'zustand';
+import { immer } from 'zustand/middleware/immer';
+import { getRelease, getSubscription } from '../api/subscription';
+const STATES = {};
+export const createAssistantState = ({ aid }) => {
+    var _a;
+    (_a = STATES[aid]) !== null && _a !== void 0 ? _a : (STATES[aid] = create()(immer((set) => ({
+        load: () => __awaiter(void 0, void 0, void 0, function* () {
+            set((state) => {
+                state.loading = true;
+            });
+            try {
+                const [{ subscription }, release] = yield Promise.all([getSubscription({ aid }), getRelease({ aid })]);
+                set((state) => {
+                    state.subscription = subscription;
+                    state.release = release;
+                });
+            }
+            finally {
+                set((state) => {
+                    state.loading = false;
+                    state.loaded = true;
+                });
+            }
+        }),
+    }))));
+    return STATES[aid];
+};
+const LOADING_TASKS = {};
+export function useSubscriptionState({ aid }) {
+    var _a;
+    const state = createAssistantState({ aid })();
+    if (!state.loaded && !state.subscription) {
+        (_a = LOADING_TASKS[aid]) !== null && _a !== void 0 ? _a : (LOADING_TASKS[aid] = state.load());
+        throw LOADING_TASKS[aid];
+    }
+    return [state.subscription, state];
+}

package/lib/esm/builtin/async/ai-runtime/utils.js

@@ -0,0 +1,42 @@
+import { Base64 } from 'js-base64';
+export function parseIdentity(aid, options) {
+    let projectId;
+    let projectRef;
+    let assistantId;
+    try {
+        const s = Base64.decode(aid).split('/');
+        [projectId, projectRef, assistantId] = s.length === 3 ? s : s.length === 2 ? [s[0], 'main', s[1]] : [];
+    }
+    catch (error) {
+        console.error('parse assistantId error', { error });
+    }
+    if (projectId && projectRef && assistantId)
+        return { projectId, projectRef, assistantId };
+    if (options === null || options === void 0 ? void 0 : options.rejectWhenError)
+        throw new Error(`Invalid assistant identity ${aid}`);
+    return undefined;
+}
+export function stringifyIdentity({ projectId, projectRef, assistantId, }) {
+    return Base64.encodeURI([projectId, projectRef, assistantId].join('/'));
+}
+function isObject(obj) {
+    return typeof obj === 'object' && !Array.isArray(obj);
+}
+export function deepMerge(target, source) {
+    if (isObject(target) && isObject(source)) {
+        for (const key of Object.keys(source)) {
+            if (isObject(source[key])) {
+                if (!target[key] || !isObject(target[key]))
+                    target[key] = source[key];
+                deepMerge(target[key], source[key]);
+            }
+            else {
+                target[key] = source[key];
+            }
+        }
+    }
+}
+export const mergeSx = (initial, sx) => {
+    const mergedSx = [initial, ...(Array.isArray(sx) ? sx : [sx])];
+    return mergedSx;
+};

package/lib/esm/builtin/async/react-scroll-to-bottom.js

@@ -5,4 +5,4 @@ export default () => Promise.all([
             import('react-scroll-to-bottom/lib/esm/hooks/internal/useInternalContext')
         : // @ts-ignore
             import('react-scroll-to-bottom/lib/hooks/internal/useInternalContext'),
-]).then(([mod, { default: useInternalContext }]) => (Object.assign(Object.assign({}, mod), { useInternalContext })));
+]).then(([mod, { default: useInternalContext }]) => (Object.assign(Object.assign({}, mod), { Composer: mod.Composer, useInternalContext })));

package/lib/esm/utils/builtin.js

@@ -43,4 +43,5 @@ export const BuiltinModules = {
     '@blocklet/pages-kit/builtin/async/react-markdown': {},
     '@blocklet/pages-kit/builtin/async/react-syntax-highlighter': {},
     '@blocklet/pages-kit/builtin/async/image-preview': {},
+    '@blocklet/pages-kit/builtin/async/ai-runtime': {},
 };

package/lib/esm/utils/inject-global-components.js

@@ -1,4 +1,5 @@
 import * as arcblockUx from '../builtin/arcblock/ux';
+import * as aiRuntime from '../builtin/async/ai-runtime';
 import * as imagePreview from '../builtin/async/image-preview';
 import * as reactMarkdown from '../builtin/async/react-markdown';
 import * as reactScrollToBottom from '../builtin/async/react-scroll-to-bottom';
@@ -50,6 +51,7 @@ function injectGlobalComponents() {
             '@blocklet/pages-kit/builtin/async/react-markdown': reactMarkdown,
             '@blocklet/pages-kit/builtin/async/react-syntax-highlighter': reactSyntaxHighlighter,
             '@blocklet/pages-kit/builtin/async/image-preview': imagePreview,
+            '@blocklet/pages-kit/builtin/async/ai-runtime': aiRuntime,
         },
         require(module) {
             return win[BuiltinModulesGlobalVariableName].modules[module];

package/lib/types/builtin/async/ai-runtime/api/assistant.d.ts

@@ -0,0 +1,18 @@
+import { AssistantBase, Parameter } from '@blocklet/ai-runtime/types';
+export interface Assistant {
+    id: string;
+    name?: string;
+    description?: string;
+    parameters?: Parameter[];
+    entries?: {
+        id: string;
+        title?: string;
+        parameters?: {
+            [key: string]: any;
+        };
+    }[];
+    release?: AssistantBase['release'];
+}
+export declare function getAssistant({ assistantId: id }: {
+    assistantId: string;
+}): Promise<Assistant>;

package/lib/types/builtin/async/ai-runtime/api/dataset.d.ts

@@ -0,0 +1,39 @@
+export interface Dataset {
+    id: string;
+    name?: string;
+    description?: string;
+}
+export declare function getDataset({ datasetId }: {
+    datasetId: string;
+}): Promise<Dataset>;
+export declare function getDatasets({ appId }: {
+    appId: string;
+}): Promise<Array<Dataset>>;
+export declare function createDataset({ appId, name, description, }: {
+    appId: string;
+    name: string;
+    description?: string;
+}): Promise<unknown>;
+export declare function updateDataset(datasetId: string, input: Pick<Dataset, 'name' | 'description'>): Promise<Dataset>;
+export declare function deleteDataset(datasetId: string): Promise<void>;
+export interface Document {
+    id: string;
+    name?: string;
+}
+export declare function deleteDocument(datasetId: string, documentId: string): Promise<void>;
+export declare function getDocuments(datasetId: string): Promise<{
+    items: Array<Document>;
+    total: number;
+}>;
+export declare function getDocument(datasetId: string, documentId: string): Promise<{
+    document: Document;
+}>;
+export declare function createDocument(datasetId: string, type: 'text' | 'file', input: {
+    name: string;
+    content: string;
+} | File): Promise<any>;
+export declare function createDocumentFile(datasetId: string, file: File): Promise<any>;
+export declare function updateDocument(datasetId: string, documentId: string, type: 'text', input: {
+    name: string;
+    content: string;
+}): Promise<unknown>;

package/lib/types/builtin/async/ai-runtime/api/message.d.ts

@@ -0,0 +1,39 @@
+import { ExecuteBlock, RuntimeOutputVariablesSchema } from '@blocklet/ai-runtime/types';
+export interface Message {
+    id: string;
+    taskId: string;
+    sessionId: string;
+    createdAt: string;
+    updatedAt: string;
+    parameters?: {
+        [key: string]: any;
+    };
+    result?: {
+        content?: string;
+        images?: {
+            url: string;
+        }[];
+        messages?: {
+            taskId: string;
+            respondAs?: ExecuteBlock['respondAs'];
+            result?: Pick<NonNullable<Message['result']>, 'content' | 'images'>;
+        }[];
+        objects?: {
+            taskId: string;
+            data: RuntimeOutputVariablesSchema;
+        }[];
+    } | null;
+    error?: {
+        type?: string;
+        message: string;
+    };
+}
+export declare function getMessages({ sessionId, }: {
+    sessionId: string;
+}): Promise<{
+    messages: Message[];
+    count: number;
+}>;
+export declare function deleteMessages({ sessionId }: {
+    sessionId: string;
+}): Promise<void>;

package/lib/types/builtin/async/ai-runtime/api/request.d.ts

@@ -0,0 +1,5 @@
+export declare const fetch: (input: string | URL | Request, options?: RequestInit | undefined) => Promise<Response>;
+export declare function request<T>({ url, body, ...init }: {
+    url: string;
+    body?: any;
+} & Omit<RequestInit, 'body'>): Promise<T>;

package/lib/types/builtin/async/ai-runtime/api/session.d.ts

@@ -0,0 +1,54 @@
+import { RunAssistantResponse } from '@blocklet/ai-runtime/types';
+import { Identity } from '../utils';
+export interface Session {
+    id: string;
+    userId: string;
+    projectId: string;
+    projectRef: string;
+    assistantId: string;
+    createdAt: string;
+    parameters?: any;
+    entry?: {
+        title?: string;
+    };
+}
+export declare function getSessions({ projectId, projectRef, assistantId, }: {
+    projectId: string;
+    projectRef: string;
+    assistantId: string;
+}): Promise<{
+    sessions: Session[];
+}>;
+export declare function getSession({ sessionId }: {
+    sessionId: string;
+}): Promise<{
+    session: Session;
+}>;
+export declare function createSession({ assistantId, name, parameters, entry, }: {
+    assistantId: string;
+    name?: string;
+    parameters?: any;
+    entry?: any;
+}): Promise<{
+    created: Session;
+    sessions: Session[];
+}>;
+export declare function updateSession({ sessionId, name, parameters, }: {
+    sessionId: string;
+    name?: string;
+    parameters?: any;
+}): Promise<{
+    updated: Session;
+    sessions: Session[];
+}>;
+export declare function deleteSession({ sessionId, }: {
+    sessionId: string;
+}): Promise<{
+    deleted: Session;
+    sessions: Session[];
+}>;
+export declare function runAssistant({ sessionId, identity, parameters, }: {
+    sessionId: string;
+    identity: Identity;
+    parameters: any;
+}): AsyncGenerator<RunAssistantResponse, void, unknown>;

package/lib/types/builtin/async/ai-runtime/api/subscription.d.ts

@@ -0,0 +1,15 @@
+export interface Subscription {
+}
+export declare function getSubscription({ aid }: {
+    aid: string;
+}): Promise<{
+    subscription?: Subscription;
+}>;
+export interface Release {
+    paymentProductId?: string;
+    paymentLinkId?: string;
+    paymentUnitAmount?: string;
+}
+export declare function getRelease({ aid }: {
+    aid: string;
+}): Promise<Release>;

package/lib/types/builtin/async/ai-runtime/components/ActionButton.d.ts

@@ -0,0 +1,11 @@
+import { LoadingButtonProps } from '@mui/lab';
+import { ReactNode } from 'react';
+export declare function ActionButton({ tip, tipSucceed, title, titleSucceed, icon, iconSucceed, autoReset, ...props }: {
+    tip?: ReactNode;
+    tipSucceed?: ReactNode;
+    title?: ReactNode;
+    titleSucceed?: ReactNode;
+    icon?: ReactNode;
+    iconSucceed?: ReactNode;
+    autoReset?: boolean;
+} & Omit<Partial<LoadingButtonProps>, 'title'>): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/GlobalLoading.d.ts

@@ -0,0 +1,2 @@
+import { LinearProgressProps } from '@mui/material';
+export default function GlobalLoading({ ...props }: LinearProgressProps): import("react/jsx-runtime").JSX.Element | null;

package/lib/types/builtin/async/ai-runtime/components/LoadingButton.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="react" />
+declare const LoadingButton: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+export default LoadingButton;

package/lib/types/builtin/async/ai-runtime/components/LoadingListItemButton.d.ts

@@ -0,0 +1,5 @@
+import { ListItemButtonProps } from '@mui/material';
+import { ReactNode } from 'react';
+export default function LoadingListItemButton({ children, confirmation, ...props }: ListItemButtonProps & {
+    confirmation?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/MarkdownRenderer.d.ts

@@ -0,0 +1,2 @@
+declare const MarkdownRenderer: import("@emotion/styled").StyledComponent<Readonly<import("react-markdown/lib").Options> & import("@mui/system").MUIStyledCommonProps<import("@mui/material").Theme>, {}, {}>;
+export default MarkdownRenderer;

package/lib/types/builtin/async/ai-runtime/components/MenuButton.d.ts

@@ -0,0 +1,9 @@
+import { BoxProps } from '@mui/material';
+import React from 'react';
+interface Props {
+    sx?: BoxProps;
+    menus?: React.ReactNode | (() => React.ReactNode);
+    children?: React.ReactNode;
+}
+export default function MenuButton({ sx, menus, children }: Props): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/builtin/async/ai-runtime/components/PoweredBy.d.ts

@@ -0,0 +1,4 @@
+import { StackProps } from '@mui/material';
+export default function PoweredBy({ assistantId, ...props }: {
+    assistantId: string;
+} & StackProps): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/RuntimeProvider.d.ts

@@ -0,0 +1,4 @@
+import { ReactNode } from 'react';
+export default function RuntimeProvider({ children }: {
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/ScrollView.d.ts

@@ -0,0 +1,61 @@
+import { BoxProps } from '@mui/material';
+import { ComponentProps } from 'react';
+export declare function useScrollToBottomModule(): {
+    Composer: typeof import("react-scroll-to-bottom").default;
+    useInternalContext: any;
+    default(props: import("react").PropsWithChildren<{
+        checkInterval?: number | undefined;
+        className?: string | undefined;
+        debounce?: number | undefined;
+        debug?: boolean | undefined;
+        followButtonClassName?: string | undefined;
+        initialScrollBehavior?: "auto" | "smooth" | undefined;
+        mode?: "bottom" | "top" | undefined;
+        nonce?: string | undefined;
+        scroller?: ((values: {
+            maxValue: number;
+            minValue: number;
+            offsetHeight: number;
+            scrollHeight: number;
+            scrollTop: number;
+        }) => number) | undefined;
+        scrollViewClassName?: string | undefined;
+    }>): null;
+    useScrollTo(): (scrollTop: number | "100%") => void;
+    useScrollToBottom(): (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+    useScrollToEnd(): (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+    useScrollToStart(): (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+    useScrollToTop(): (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+    useObserveScrollPosition(observer: false | (({ scrollTop }: {
+        scrollTop: number;
+    }) => void)): void;
+    useAnimating(): [boolean];
+    useAnimatingToEnd(): [boolean];
+    useAtBottom(): [boolean];
+    useAtEnd(): [boolean];
+    useAtStart(): [boolean];
+    useAtTop(): [boolean];
+    useMode(): ["bottom" | "top"];
+    useSticky(): [boolean];
+    FunctionContext: import("react").Context<{
+        scrollTo: (scrollTop: number | "100%") => void;
+        scrollToBottom: (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+        scrollToEnd: (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+        scrollToStart: (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+        scrollToTop: (option?: import("react-scroll-to-bottom").ScrollOption | undefined) => void;
+    }>;
+    StateContext: import("react").Context<{
+        animating: boolean;
+        animatingToEnd: boolean;
+        atBottom: boolean;
+        atEnd: boolean;
+        atStart: boolean;
+        atTop: boolean;
+        mode: string;
+        sticky: boolean;
+    }>;
+};
+export default function ScrollView({ children, initialScrollBehavior, ...props }: BoxProps & {
+    scroller?: 'window';
+    initialScrollBehavior?: ComponentProps<(typeof import('react-scroll-to-bottom'))['default']>['initialScrollBehavior'];
+}): import("react/jsx-runtime").JSX.Element;

package/lib/types/builtin/async/ai-runtime/components/SocialShare.d.ts

@@ -0,0 +1,17 @@
+import { BoxProps } from '@mui/material';
+interface SocialShareMenuProps extends BoxProps {
+    url?: string;
+    content: string;
+}
+interface SocialShareButtonsProps extends SocialShareMenuProps {
+    itemSx?: BoxProps['sx'];
+    onClick?: () => void;
+    bgFill?: string;
+    iconFill?: string;
+}
+export default function SocialShare(props: SocialShareMenuProps & SocialShareButtonsProps & {
+    type?: 'menu' | 'buttons';
+}): import("react/jsx-runtime").JSX.Element;
+export declare function SocialShareMenu({ url, content, ...restProps }: SocialShareMenuProps): import("react/jsx-runtime").JSX.Element;
+export declare function SocialShareButtons({ url, content, sx, itemSx, onClick, bgFill, iconFill, ...rest }: SocialShareButtonsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/lib/types/builtin/async/ai-runtime/components/ThemeProvider.d.ts

@@ -0,0 +1,6 @@
+import { ReactNode } from 'react';
+export default function ThemeProvider({ children, template, transparentHeaderBg, }: {
+    children?: ReactNode;
+    template?: string;
+    transparentHeaderBg?: boolean;
+}): import("react/jsx-runtime").JSX.Element;