@blocklet/aigne-hub 0.2.7

package/lib/esm/api/call/proxy.js

@@ -0,0 +1,58 @@
+import http from 'http';
+import https from 'https';
+import { getComponentWebEndpoint } from '@blocklet/sdk/lib/component';
+import { getSignData } from '@blocklet/sdk/lib/util/verify-sign';
+import { isNil, pick } from 'lodash';
+import { joinURL, parseURL, stringifyParsedURL, withQuery } from 'ufo';
+import { AI_KIT_BASE_URL } from '../constants';
+import { getRemoteComponentCallHeaders } from '../utils/auth';
+export function proxyToAIKit(path, { useAIKitService, proxyReqHeaders = ['accept', 'content-type'], proxyResHeaders = ['content-type', 'cache-control'], } = {}) {
+    const parseReqBody = path !== '/api/v1/audio/transcriptions';
+    return (req, res, next) => {
+        var _a;
+        const url = parseURL(withQuery(joinURL(useAIKitService ? AI_KIT_BASE_URL : getComponentWebEndpoint('ai-kit'), path), req.query));
+        const userDid = ((_a = req.user) === null || _a === void 0 ? void 0 : _a.did) || (req === null || req === void 0 ? void 0 : req.get('x-app-user-did'));
+        const proxyReq = (url.protocol === 'https:' ? https : http).request(stringifyParsedURL(url), {
+            headers: {
+                ...pick(req.headers, ...proxyReqHeaders),
+                ...(useAIKitService
+                    ? getRemoteComponentCallHeaders(req.body || {}, userDid)
+                    : (() => {
+                        const { iat, exp, sig, version } = getSignData({
+                            data: req.body,
+                            params: req.query,
+                            method: req.method,
+                            url: stringifyParsedURL(url),
+                        });
+                        return {
+                            'x-component-sig': sig,
+                            'x-component-sig-iat': iat,
+                            'x-component-sig-exp': exp,
+                            'x-component-sig-version': version,
+                        };
+                    })()),
+            },
+            method: req.method,
+        }, (proxyRes) => {
+            if (proxyRes.statusCode)
+                res.status(proxyRes.statusCode);
+            res.setHeader('X-Accel-Buffering', 'no');
+            for (const [k, v] of Object.entries(pick(proxyRes.headers, ...proxyResHeaders))) {
+                if (!isNil(v))
+                    res.setHeader(k, v);
+            }
+            proxyRes.pipe(res);
+        });
+        proxyReq.on('error', (e) => next(e));
+        req.on('aborted', () => {
+            proxyReq.destroy();
+        });
+        if (parseReqBody) {
+            proxyReq.write(JSON.stringify(req.body));
+            proxyReq.end();
+        }
+        else {
+            req.pipe(proxyReq);
+        }
+    };
+}

package/lib/esm/api/call/v1.js

@@ -0,0 +1,155 @@
+import { ReadableStream, TextDecoderStream } from 'stream/web';
+import { call, getComponentWebEndpoint } from '@blocklet/sdk/lib/component';
+import { getSignData } from '@blocklet/sdk/lib/util/verify-sign';
+import axios from 'axios';
+import FormData from 'form-data';
+import stringify from 'json-stable-stringify';
+import { joinURL } from 'ufo';
+import { isChatCompletionError, } from '../types';
+import { getRemoteComponentCallHeaders } from '../utils/auth';
+import { EventSourceParserStream, readableToWeb } from '../utils/event-stream';
+import { aiKitApi, catchAndRethrowUpstreamError } from './api';
+export async function status({ useAIKitService, ...options } = {}) {
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi
+            .get('/api/v1/status', {
+            responseType: options.responseType,
+            headers: { ...getRemoteComponentCallHeaders({}) },
+        })
+            .then((res) => res.data)
+        : call({ name: 'ai-kit', method: 'GET', path: '/api/v1/status', responseType: options === null || options === void 0 ? void 0 : options.responseType }).then((res) => res.data));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return response.data;
+}
+export async function chatCompletions(input, { useAIKitService, ...options } = {}) {
+    const response = catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi('/api/v1/chat/completions', {
+            responseType: 'stream',
+            method: 'POST',
+            data: stringify(input),
+            headers: {
+                ...getRemoteComponentCallHeaders(input),
+                Accept: 'text/event-stream',
+                'Content-Type': 'application/json',
+            },
+        })
+        : call({
+            name: 'ai-kit',
+            path: 'api/v1/chat/completions',
+            data: input,
+            responseType: 'stream',
+            headers: { Accept: 'text/event-stream' },
+        }));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                const stream = readableToWeb((await response).data)
+                    .pipeThrough(new TextDecoderStream())
+                    .pipeThrough(new EventSourceParserStream());
+                for await (const chunk of stream) {
+                    if (isChatCompletionError(chunk)) {
+                        if (chunk.error.type) {
+                            const error = new Error(chunk.error.message);
+                            error.type = chunk.error.type;
+                            error.timestamp = chunk.error.timestamp;
+                            controller.error(error);
+                        }
+                        else {
+                            controller.error(new Error(chunk.error.message));
+                        }
+                        break;
+                    }
+                    controller.enqueue(chunk);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}
+export async function imageGenerations(input, { useAIKitService, ...options } = {}) {
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi.post('/api/v1/image/generations', input, {
+            responseType: options.responseType,
+            headers: { ...getRemoteComponentCallHeaders(input) },
+        })
+        : // @ts-ignore
+            call({
+                name: 'ai-kit',
+                path: '/api/v1/image/generations',
+                data: input,
+                responseType: options === null || options === void 0 ? void 0 : options.responseType,
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+            }));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return response.data;
+}
+export async function embeddings(input, { useAIKitService, ...options } = {}) {
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi.post('/api/v1/embeddings', input, {
+            responseType: options.responseType,
+            headers: { ...getRemoteComponentCallHeaders(input) },
+        })
+        : call({
+            name: 'ai-kit',
+            path: '/api/v1/embeddings',
+            data: input,
+            responseType: options === null || options === void 0 ? void 0 : options.responseType,
+        }));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return response.data;
+}
+export async function audioTranscriptions(input, { useAIKitService, ...options } = {}) {
+    const form = new FormData();
+    for (const [key, val] of Object.entries(input)) {
+        form.append(key, val);
+    }
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi.post('/api/v1/audio/transcriptions', form, {
+            responseType: options.responseType,
+            headers: { ...getRemoteComponentCallHeaders({}) },
+        })
+        : (() => {
+            const { iat, exp, sig, version } = getSignData({
+                data: {},
+                params: {},
+                method: 'post',
+                url: '/api/v1/audio/transcriptions',
+            });
+            return axios.post(joinURL(getComponentWebEndpoint('ai-kit'), '/api/v1/audio/transcriptions'), form, {
+                headers: {
+                    'x-component-sig': sig,
+                    'x-component-sig-iat': iat,
+                    'x-component-sig-exp': exp,
+                    'x-component-sig-version': version,
+                },
+                responseType: options === null || options === void 0 ? void 0 : options.responseType,
+            });
+        })());
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return response.data;
+}
+export async function audioSpeech(input, { useAIKitService } = {}) {
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi.post('/api/v1/audio/speech', input, {
+            responseType: 'stream',
+            headers: { ...getRemoteComponentCallHeaders(input) },
+        })
+        : call({
+            name: 'ai-kit',
+            path: '/api/v1/audio/speech',
+            data: input,
+            responseType: 'stream',
+        }));
+    return response;
+}

package/lib/esm/api/call/v2.js

@@ -0,0 +1,93 @@
+import { ReadableStream, TextDecoderStream } from 'stream/web';
+import { call } from '@blocklet/sdk/lib/component';
+import stringify from 'json-stable-stringify';
+import { isChatCompletionError, } from '../types';
+import { getRemoteComponentCallHeaders } from '../utils/auth';
+import { EventSourceParserStream, readableToWeb } from '../utils/event-stream';
+import { aiKitApi, catchAndRethrowUpstreamError } from './api';
+export async function chatCompletionsV2(input, { useAIKitService, ...options } = {}) {
+    const response = catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi('/api/v2/chat/completions', {
+            responseType: 'stream',
+            method: 'POST',
+            data: stringify(input),
+            headers: {
+                ...getRemoteComponentCallHeaders(input, options.userDid),
+                Accept: 'text/event-stream',
+                'Content-Type': 'application/json',
+            },
+        })
+        : call({
+            name: 'ai-kit',
+            path: 'api/v2/chat/completions',
+            data: input,
+            responseType: 'stream',
+            headers: { Accept: 'text/event-stream' },
+        }));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return new ReadableStream({
+        async start(controller) {
+            try {
+                const stream = readableToWeb((await response).data)
+                    .pipeThrough(new TextDecoderStream())
+                    .pipeThrough(new EventSourceParserStream());
+                for await (const chunk of stream) {
+                    if (isChatCompletionError(chunk)) {
+                        if (chunk.error.type) {
+                            const error = new Error(chunk.error.message);
+                            error.type = chunk.error.type;
+                            error.timestamp = chunk.error.timestamp;
+                            controller.error(error);
+                        }
+                        else {
+                            controller.error(new Error(chunk.error.message));
+                        }
+                        break;
+                    }
+                    controller.enqueue(chunk);
+                }
+            }
+            catch (error) {
+                controller.error(error);
+            }
+            finally {
+                controller.close();
+            }
+        },
+    });
+}
+export async function imageGenerationsV2(input, { useAIKitService, ...options } = {}) {
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi.post('/api/v2/image/generations', input, {
+            responseType: options.responseType,
+            headers: { ...getRemoteComponentCallHeaders(input, options.userDid) },
+        })
+        : // @ts-ignore
+            call({
+                name: 'ai-kit',
+                path: '/api/v2/image/generations',
+                data: input,
+                responseType: options === null || options === void 0 ? void 0 : options.responseType,
+                timeout: options === null || options === void 0 ? void 0 : options.timeout,
+            }));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return response.data;
+}
+export async function embeddingsV2(input, { useAIKitService, ...options } = {}) {
+    const response = await catchAndRethrowUpstreamError(useAIKitService
+        ? aiKitApi.post('/api/v2/embeddings', input, {
+            responseType: options.responseType,
+            headers: { ...getRemoteComponentCallHeaders(input, options.userDid) },
+        })
+        : call({
+            name: 'ai-kit',
+            path: '/api/v2/embeddings',
+            data: input,
+            responseType: options === null || options === void 0 ? void 0 : options.responseType,
+        }));
+    if ((options === null || options === void 0 ? void 0 : options.responseType) === 'stream')
+        return response;
+    return response.data;
+}

package/lib/esm/api/config.js

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+import { existsSync, writeFileSync } from 'fs';
+import { readFile, writeFile } from 'fs/promises';
+import { join } from 'path';
+import config from '@blocklet/sdk/lib/config';
+import { parse, stringify } from 'yaml';
+import logger from '../libs/logger';
+class Config extends EventEmitter {
+    constructor() {
+        super();
+        this.reloadConfigFile = async () => {
+            try {
+                this.config = parse((await readFile(Config.CONFIG_FILE_PATH)).toString());
+            }
+            catch (error) {
+                logger.error(`Parse ${Config.CONFIG_FILE_PATH} error`, { error });
+            }
+        };
+        if (!existsSync(Config.CONFIG_FILE_PATH)) {
+            writeFileSync(Config.CONFIG_FILE_PATH, '');
+        }
+        this.reloadConfigFile();
+    }
+    get useAIKitService() {
+        var _a;
+        return (_a = this.config) === null || _a === void 0 ? void 0 : _a.useAIKitService;
+    }
+    set useAIKitService(value) {
+        var _a;
+        (_a = this.config) !== null && _a !== void 0 ? _a : (this.config = {});
+        this.config.useAIKitService = value;
+        this.save();
+        this.emit('change', this.config);
+    }
+    async save() {
+        await writeFile(Config.CONFIG_FILE_PATH, stringify(this.config));
+    }
+}
+Config.CONFIG_FILE_PATH = join(config.env.dataDir, 'ai-kit-service.config.yaml');
+const AIKitConfig = new Config();
+export default AIKitConfig;

package/lib/esm/api/constants.js

@@ -0,0 +1 @@
+export const AI_KIT_BASE_URL = process.env.AI_KIT_BASE_URL || 'https://www.aikit.rocks/ai-kit';

package/lib/esm/api/error.js

@@ -0,0 +1,37 @@
+export var SubscriptionErrorType;
+(function (SubscriptionErrorType) {
+    SubscriptionErrorType["UNSUBSCRIBED"] = "UNSUBSCRIBED";
+    SubscriptionErrorType["UNKNOWN"] = "UNKNOWN";
+})(SubscriptionErrorType || (SubscriptionErrorType = {}));
+export var CreditErrorType;
+(function (CreditErrorType) {
+    CreditErrorType["NOT_ENOUGH"] = "NOT_ENOUGH";
+    CreditErrorType["UNKNOWN"] = "UNKNOWN";
+})(CreditErrorType || (CreditErrorType = {}));
+const SubscriptionErrors = {
+    [SubscriptionErrorType.UNSUBSCRIBED]: 'Hello, in order to continue chatting, please first subscribe to AI-KIT service',
+    [SubscriptionErrorType.UNKNOWN]: 'An unknown error occurred',
+};
+export class SubscriptionError extends Error {
+    constructor(type) {
+        const message = SubscriptionErrors[type] || SubscriptionErrors[SubscriptionErrorType.UNKNOWN];
+        super(message);
+        this.timestamp = new Date().toISOString();
+        this.type = type;
+    }
+}
+const CreditErrors = {
+    [CreditErrorType.NOT_ENOUGH]: 'Hello, in order to continue chatting, please first buy some credits in the link below.',
+    [CreditErrorType.UNKNOWN]: 'An unknown error occurred',
+};
+export class CreditError extends Error {
+    constructor(type, link) {
+        let message = CreditErrors[type] || CreditErrors[CreditErrorType.UNKNOWN];
+        if (type === CreditErrorType.NOT_ENOUGH && link) {
+            message += `\n\n${link}`;
+        }
+        super(message);
+        this.timestamp = new Date().toISOString();
+        this.type = type;
+    }
+}

package/lib/esm/api/index.js

@@ -0,0 +1,3 @@
+export * from './ai-kit';
+export * from './error';
+export * from './app';

package/lib/esm/api/types/audio.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/api/types/chat.js

@@ -0,0 +1,9 @@
+export function isChatCompletionChunk(data) {
+    return typeof data.delta === 'object';
+}
+export function isChatCompletionUsage(data) {
+    return typeof data.usage === 'object';
+}
+export function isChatCompletionError(data) {
+    return typeof data.error === 'object';
+}

package/lib/esm/api/types/embedding.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/api/types/image.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/api/types/index.js

@@ -0,0 +1,3 @@
+export * from './chat';
+export * from './image';
+export * from './embedding';

package/lib/esm/api/types/status.js

@@ -0,0 +1 @@
+export {};

package/lib/esm/api/utils/auth.js

@@ -0,0 +1,79 @@
+/// <reference path="./auth.type.d.ts" />
+import { DidType, fromPublicKey } from '@arcblock/did';
+import { auth } from '@blocklet/sdk/lib/middlewares';
+import getWallet from '@blocklet/sdk/lib/wallet';
+import { getHasher, getSigner, types } from '@ocap/mcrypto';
+import stringify from 'json-stable-stringify';
+const TOKEN_EXPIRES_IN_SECONDS = 60 * 10;
+export const wallet = getWallet();
+const ADMIN_ROLES = ['owner', 'admin'];
+export const ensureAdmin = auth({ roles: ADMIN_ROLES });
+const signer = getSigner(DidType('default').pk);
+function hashData({ appId, timestamp, data, userDid, }) {
+    const hasher = getHasher(DidType('default').hash);
+    return hasher(stringify({ appId, timestamp, data: data || {}, userDid }), 1);
+}
+export function appIdFromPublicKey(publicKey) {
+    return fromPublicKey(publicKey, DidType({ role: types.RoleType.ROLE_APPLICATION, pk: types.KeyType.ED25519, hash: types.HashType.SHA3 }));
+}
+export function verifyRemoteComponentCall({ appId, timestamp, data, sig, pk, userDid, expiresIn = TOKEN_EXPIRES_IN_SECONDS, }) {
+    if (Math.abs(Date.now() / 1000 - timestamp) > expiresIn)
+        throw new Error('signature expired');
+    return signer.verify(hashData({ appId, timestamp, data, userDid }), sig, pk);
+}
+export function signRemoteComponentCall({ data, userDid }) {
+    const appId = wallet.address;
+    const timestamp = Math.round(Date.now() / 1000);
+    return {
+        appId,
+        timestamp,
+        userDid,
+        sig: signer.sign(hashData({ appId, timestamp, data, userDid }), wallet.secretKey),
+    };
+}
+export function getRemoteComponentCallHeaders(data, userDid) {
+    const { appId, timestamp, sig } = signRemoteComponentCall({ data, userDid });
+    return {
+        'x-app-id': appId,
+        'x-timestamp': timestamp.toString(),
+        'x-component-sig': sig,
+        'x-app-user-did': userDid || '',
+    };
+}
+export function ensureRemoteComponentCall(getPublicKey, fallback) {
+    return async (req, res, next) => {
+        try {
+            const sig = req.get('x-component-sig');
+            const appId = req.get('x-app-id');
+            const timestamp = req.get('x-timestamp');
+            const userDid = req.get('x-app-user-did'); // Get user did
+            if (!sig || !appId || !timestamp) {
+                throw new Error('Missing required headers x-component-sig/x-app-id/x-timestamp');
+            }
+            const pk = await getPublicKey(appId);
+            if (appIdFromPublicKey(pk) !== appId)
+                throw new Error('appId and public key not match');
+            if (!verifyRemoteComponentCall({
+                appId,
+                sig,
+                timestamp: parseInt(timestamp, 10),
+                data: req.body,
+                pk,
+                userDid,
+            })) {
+                throw new Error('Validate signature error');
+            }
+            req.appClient = {
+                appId,
+                userDid,
+            };
+        }
+        catch (error) {
+            if (!fallback)
+                throw error;
+            fallback(req, res, next);
+            return;
+        }
+        next();
+    };
+}

package/lib/esm/api/utils/event-stream.js

@@ -0,0 +1,50 @@
+import { ReadableStream, TextDecoderStream, TransformStream } from 'stream/web';
+import { createParser } from 'eventsource-parser';
+import logger from '../../libs/logger';
+export function readableToWeb(readable) {
+    return new ReadableStream({
+        async start(controller) {
+            for await (const chunk of readable) {
+                controller.enqueue(chunk);
+            }
+            controller.close();
+        },
+    });
+}
+export class EventSourceParserStream extends TransformStream {
+    constructor() {
+        let parser;
+        super({
+            start(controller) {
+                parser = createParser((event) => {
+                    if (event.type === 'event') {
+                        try {
+                            const json = JSON.parse(event.data);
+                            controller.enqueue(json);
+                        }
+                        catch (error) {
+                            logger.error('parse chunk error', { error, data: event.data });
+                        }
+                    }
+                });
+            },
+            transform(chunk) {
+                parser === null || parser === void 0 ? void 0 : parser.feed(chunk);
+            },
+        });
+    }
+}
+export async function tryParseJsonFromResponseStream(data) {
+    let text = '';
+    let json;
+    try {
+        for await (const chunk of readableToWeb(data).pipeThrough(new TextDecoderStream())) {
+            text += chunk;
+        }
+        json = JSON.parse(text);
+    }
+    catch (error) {
+        logger.error('parse json from response error', { text, error });
+    }
+    return json;
+}

package/lib/esm/components/conversation/conversation.js

@@ -0,0 +1,65 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Avatar, Box, CircularProgress } from '@mui/material';
+import isNil from 'lodash/isNil';
+import { useCallback, useEffect, useImperativeHandle, useRef } from 'react';
+import ImagePreview from '../image-preview';
+import SubscribeErrorAlert from '../subscribe/alert';
+import Message from './message';
+import Prompt from './prompt';
+export default function Conversation({ ref, messages, onSubmit, customActions = () => [], renderAvatar = undefined, maxWidth = 1000, scrollContainer = undefined, promptProps = {}, ...props }) {
+    const scroller = useRef(scrollContainer !== null && scrollContainer !== void 0 ? scrollContainer : null);
+    const { element, scrollToBottom } = useAutoScrollToBottom({ scroller });
+    useImperativeHandle(ref, () => ({
+        scrollToBottom,
+    }), [scrollToBottom]);
+    return (_jsx(Box, { ...props, ref: scrollContainer ? undefined : scroller, sx: {
+            flexGrow: 1,
+            display: 'flex',
+            flexDirection: 'column',
+            overflow: 'auto',
+            ...props.sx,
+        }, children: _jsxs(Box, { sx: { mt: 2, mx: 2, flexGrow: 1, display: 'flex', flexDirection: 'column' }, children: [_jsxs(Box, { sx: { flexGrow: 1, width: '100%', mx: 'auto', maxWidth }, children: [messages.map((msg) => {
+                            var _a, _b;
+                            const actions = customActions === null || customActions === void 0 ? void 0 : customActions(msg);
+                            return (_jsxs(Box, { id: `conversation-${msg.id}`, children: [!isNil(msg.prompt) && (_jsx(Message, { avatar: (_a = renderAvatar === null || renderAvatar === void 0 ? void 0 : renderAvatar(msg, false)) !== null && _a !== void 0 ? _a : _jsx(Avatar, { sx: { bgcolor: 'secondary.main' }, children: "\uD83E\uDDD1" }), message: msg.prompt, actions: actions === null || actions === void 0 ? void 0 : actions[0] })), (!isNil(msg.response) || !isNil(msg.loading) || !isNil(msg.error)) && (_jsxs(Message, { my: 1, id: `response-${msg.id}`, loading: msg.loading && !!msg.response, message: typeof msg.response === 'string' ? msg.response : undefined, avatar: (_b = renderAvatar === null || renderAvatar === void 0 ? void 0 : renderAvatar(msg, true)) !== null && _b !== void 0 ? _b : _jsx(Avatar, { sx: { bgcolor: 'primary.main' }, children: "\uD83E\uDD16\uFE0F" }), actions: actions === null || actions === void 0 ? void 0 : actions[1], children: [Array.isArray(msg.response) && (_jsx(ImagePreview, { itemWidth: 100, dataSource: msg.response.map(({ url }) => {
+                                                    return {
+                                                        src: url,
+                                                        onLoad: () => scrollToBottom(),
+                                                    };
+                                                }) })), msg.error ? (_jsx(SubscribeErrorAlert, { error: msg.error })) : (msg.loading &&
+                                                !msg.response && (_jsx(Box, { sx: {
+                                                    minHeight: 24,
+                                                    display: 'flex',
+                                                    alignItems: 'center',
+                                                }, children: _jsx(CircularProgress, { size: 16 }) })))] }))] }, msg.id));
+                        }), element] }), _jsxs(Box, { sx: { mx: 'auto', width: '100%', maxWidth, position: 'sticky', bottom: 0 }, children: [_jsx(Box, { sx: {
+                                height: 16,
+                                pointerEvents: 'none',
+                                background: (theme) => `linear-gradient(transparent, ${theme.palette.background.paper})`,
+                            } }), _jsx(Box, { sx: {
+                                pb: 2,
+                                bgcolor: 'background.paper',
+                            }, children: _jsx(Prompt, { onSubmit: onSubmit, ...promptProps }) })] })] }) }));
+}
+const STICKY_SCROLL_BOTTOM_GAP = 5;
+const useAutoScrollToBottom = ({ scroller }) => {
+    const element = useRef(null);
+    const enableAutoScrollBottom = useRef(true);
+    useEffect(() => {
+        const e = scroller.current;
+        if (!e) {
+            return () => { };
+        }
+        const listener = () => {
+            enableAutoScrollBottom.current = e.clientHeight + e.scrollTop >= e.scrollHeight - STICKY_SCROLL_BOTTOM_GAP;
+        };
+        e.addEventListener('scroll', listener);
+        return () => e.removeEventListener('scroll', listener);
+    }, [scroller]);
+    const scrollToBottom = useCallback(({ force } = {}) => {
+        if (force || enableAutoScrollBottom.current) {
+            setTimeout(() => { var _a, _b; return (_b = (_a = element.current) === null || _a === void 0 ? void 0 : _a.scrollIntoViewIfNeeded) === null || _b === void 0 ? void 0 : _b.call(_a); });
+        }
+    }, []);
+    return { element: _jsx("div", { ref: element }), scrollToBottom };
+};

package/lib/esm/components/conversation/index.js

@@ -0,0 +1,4 @@
+import Conversation from './conversation';
+export default Conversation;
+export * from './conversation';
+export { default as useConversation } from './use-conversation';