@blocklet/pages-kit 0.2.299 → 0.2.301

package/lib/esm/builtin/async/ai-runtime/{components/runtime/components → runtime-components}/SimpleOutput/index.js

@@ -1,11 +1,13 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { Stack } from '@mui/material';
-import { MessageMetadataRenderer } from '../../../common';
-import MarkdownRenderer from '../../../MarkdownRenderer';
+import MarkdownRenderer from '../../components/MarkdownRenderer';
 import { useCurrentMessage } from '../../contexts/CurrentMessage';
+import MessageErrorView from '../ChatOutput/MessageErrorView';
+import MessageMetadataRenderer from '../ChatOutput/MessageMetadataRenderer';
 export default function SimpleOutput() {
     var _a, _b;
     const { message } = useCurrentMessage();
     const objects = (_a = message.result) === null || _a === void 0 ? void 0 : _a.objects;
-    return (_jsxs(Stack, { gap: 2, boxShadow: 1, borderRadius: 1, p: 2, children: [_jsx(MarkdownRenderer, { children: (_b = message.result) === null || _b === void 0 ? void 0 : _b.content }), objects === null || objects === void 0 ? void 0 : objects.map((item) => _jsx(MessageMetadataRenderer, { object: item.data }))] }));
+    const { error } = message;
+    return (_jsxs(Stack, { gap: 2, boxShadow: 1, borderRadius: 1, p: 2, children: [_jsx(MarkdownRenderer, { children: (_b = message.result) === null || _b === void 0 ? void 0 : _b.content }), error && _jsx(MessageErrorView, { error: error }), objects === null || objects === void 0 ? void 0 : objects.map((item) => _jsx(MessageMetadataRenderer, { object: item.data }))] }));
 }

package/lib/esm/builtin/async/ai-runtime/runtime-components/SimplePage/index.js

@@ -0,0 +1,63 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Stack, ThemeProvider, Typography, createTheme, useTheme } from '@mui/material';
+import { Suspense, useMemo } from 'react';
+import Balancer from 'react-wrap-balancer';
+import CustomComponentRenderer from '../../../../../components/CustomComponentRenderer';
+import SimpleHeader from '../../components/Header/SimpleHeader';
+import SimpleLayout from '../../components/Layout/SimpleLayout';
+import CurrentAgentProvider, { useCurrentAgent } from '../../contexts/CurrentAgent';
+import CurrentMessageProvider from '../../contexts/CurrentMessage';
+import { useRuntimeState } from '../../state/runtime';
+export default function SimplePage({ resultTitle, primaryColor }) {
+    const { childAgentId } = useRuntimeState();
+    const inheritedTheme = useTheme();
+    const theme = useMemo(() => {
+        let { primary } = inheritedTheme.palette;
+        try {
+            if (primaryColor) {
+                primary = inheritedTheme.palette.augmentColor({ color: { main: primaryColor } });
+            }
+        }
+        catch (error) {
+            console.error('augment primary color error', { error });
+        }
+        return createTheme(inheritedTheme, {
+            palette: { primary },
+            shape: {
+                borderRadius: 8,
+            },
+        });
+    }, [inheritedTheme, primaryColor]);
+    return (_jsx(ThemeProvider, { theme: theme, children: _jsxs(SimpleLayout, { children: [_jsx(SimpleHeader, {}), _jsx(CurrentAgentProvider, { agentId: childAgentId, children: _jsx(AgentInputRender, { className: "aigne-inputs aigne-simple-page-inputs" }) }), _jsx(OutputView, { className: "aigne-outputs aigne-simple-page-outputs", resultTitle: resultTitle })] }) }));
+}
+function AgentInputRender(_a) {
+    var props = __rest(_a, []);
+    const { appearanceInput } = useCurrentAgent();
+    if (!(appearanceInput === null || appearanceInput === void 0 ? void 0 : appearanceInput.componentId))
+        return null;
+    return (_jsx(Stack, Object.assign({}, props, { children: _jsx(CustomComponentRenderer, { componentId: appearanceInput.componentId, properties: appearanceInput.componentProps }) })));
+}
+function OutputView(_a) {
+    var _b;
+    var { resultTitle } = _a, props = __rest(_a, ["resultTitle"]);
+    const { sessionState } = useRuntimeState();
+    const lastMessage = (_b = sessionState.messages) === null || _b === void 0 ? void 0 : _b.slice(-1)[0];
+    return (_jsx(Stack, Object.assign({ gap: 2, mt: 4 }, props, { children: lastMessage && (_jsxs(_Fragment, { children: [resultTitle && (_jsx(Typography, { width: "100%", component: "h5", fontSize: 36, fontWeight: 700, textAlign: "center", children: _jsx(Balancer, { children: resultTitle }) })), _jsx(Stack, { children: _jsx(CurrentAgentProvider, { agentId: lastMessage.assistantId, children: _jsx(CurrentMessageProvider, { message: lastMessage, children: _jsx(Suspense, { children: _jsx(OutputItemView, {}) }) }) }) })] })) })));
+}
+function OutputItemView() {
+    const { appearanceOutput } = useCurrentAgent();
+    if (!(appearanceOutput === null || appearanceOutput === void 0 ? void 0 : appearanceOutput.componentId))
+        return null;
+    return (_jsx(CustomComponentRenderer, { componentId: appearanceOutput.componentId, properties: appearanceOutput.componentProps }));
+}

package/lib/esm/builtin/async/ai-runtime/{components/runtime/state/assistant.js → state/agent.js}

@@ -9,21 +9,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
-import { getAssistant } from '../../../api/assistant';
+import { getAgent } from '../api/agent';
 const STATES = {};
-export const createAssistantState = ({ aid, working, assistant, }) => {
+export const createAgentState = ({ aid, working, agent }) => {
     var _a;
     const key = working ? `${aid}-working` : aid;
     (_a = STATES[key]) !== null && _a !== void 0 ? _a : (STATES[key] = create()(immer((set) => ({
-        assistant,
+        agent,
         load: () => __awaiter(void 0, void 0, void 0, function* () {
             set((state) => {
                 state.loading = true;
             });
             try {
-                const assistant = yield getAssistant({ assistantId: aid, working });
+                const agent = yield getAgent({ aid, working });
                 set((state) => {
-                    state.assistant = assistant;
+                    state.agent = agent;
                 });
             }
             catch (error) {
@@ -42,15 +42,15 @@ export const createAssistantState = ({ aid, working, assistant, }) => {
     return STATES[key];
 };
 const LOADING_TASKS = {};
-export function useAssistantState({ aid, working }) {
+export function useAgentState({ aid, working }) {
     var _a;
-    const state = createAssistantState({ aid, working })();
-    if (!state.assistant) {
+    const state = createAgentState({ aid, working })();
+    if (!state.agent) {
         if (state.error)
             throw state.error;
         const key = working ? `${aid}-working` : aid;
         (_a = LOADING_TASKS[key]) !== null && _a !== void 0 ? _a : (LOADING_TASKS[key] = state.load());
         throw LOADING_TASKS[key];
     }
-    return [state.assistant, state];
+    return [state.agent, state];
 }

package/lib/esm/builtin/async/ai-runtime/{components/runtime/state → state}/runtime.js

@@ -9,19 +9,14 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { RuntimeOutputVariable } from '@blocklet/ai-runtime/types';
 import { useCallback, useEffect, useMemo } from 'react';
-import { useSearchParams } from 'react-router-dom';
-import { useSessionContext } from '../../../../../session';
-import { CustomError } from '../../../error';
-import { useAssistantState } from './assistant';
+import { useSessionContext } from '../../../session';
+import { useRuntimeContext } from '../contexts/Runtime';
+import { useAgentState } from './agent';
 import { createSessionState } from './session';
 export function useRuntimeState() {
     var _a;
-    const [query] = useSearchParams();
-    const aid = query.get('aid');
-    if (!aid)
-        throw new CustomError(404, 'Missing required query parameters `aid`');
-    const working = query.get('working') === 'true';
-    const [agent] = useAssistantState({ aid, working });
+    const { aid, working } = useRuntimeContext();
+    const [agent] = useAgentState({ aid, working });
     const sessionState = createSessionState({ aid })();
     const { session: authSession } = useSessionContext();
     // reset state after logged out

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

@@ -14,36 +14,46 @@ var __asyncValues = (this && this.__asyncValues) || function (o) {
     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 { RuntimeOutputVariable } from '@blocklet/ai-runtime/types';
-import pick from 'lodash/pick';
+import { parseIdentity } from '@blocklet/ai-runtime/common/aid';
 import { create } from 'zustand';
 import { immer } from 'zustand/middleware/immer';
 import { getMessages } from '../api/message';
-import { getSession, runAssistant, updateSession } from '../api/session';
-import { deepMerge, parseIdentity } from '../utils';
+import { createSession, getSessions, runAgent } from '../api/session';
 const STATES = {};
-export const createSessionState = ({ sessionId, session }) => {
+const GET_MESSAGES_LIMIT = 100;
+const GET_MESSAGES_ORDER_DIRECTION = 'desc';
+export const createSessionState = ({ aid }) => {
     var _a;
-    (_a = STATES[sessionId]) !== null && _a !== void 0 ? _a : (STATES[sessionId] = create()(immer((set, get) => ({
-        session,
-        updateSession: (_b) => __awaiter(void 0, [_b], void 0, function* ({ parameters }) {
-            const { updated } = yield updateSession({ sessionId, parameters });
+    (_a = STATES[aid]) !== null && _a !== void 0 ? _a : (STATES[aid] = create()(immer((set, get) => ({
+        reset: () => {
             set((state) => {
-                state.session = updated;
+                state.loading = undefined;
+                state.loaded = undefined;
+                state.running = undefined;
+                state.session = undefined;
+                state.messages = undefined;
+                state.noMoreMessage = undefined;
+                state.messageLoading = undefined;
+                state.error = undefined;
             });
-        }),
+        },
         load: () => __awaiter(void 0, void 0, void 0, function* () {
+            var _b;
             set((state) => {
                 state.loading = true;
             });
             try {
-                const [{ session }, { messages }] = yield Promise.all([
-                    getSession({ sessionId }),
-                    getMessages({ sessionId }),
-                ]);
+                const { sessions } = yield getSessions({ aid });
+                const session = (_b = sessions[0]) !== null && _b !== void 0 ? _b : (yield createSession({ aid })).created;
+                const { messages } = yield getMessages({
+                    sessionId: session.id,
+                    orderDirection: GET_MESSAGES_ORDER_DIRECTION,
+                    limit: GET_MESSAGES_LIMIT,
+                });
                 set((state) => {
                     state.session = session;
-                    state.messages = messages;
+                    state.messages = messages.toReversed();
+                    state.noMoreMessage = messages.length < GET_MESSAGES_LIMIT;
                 });
             }
             catch (error) {
@@ -54,37 +64,67 @@ export const createSessionState = ({ sessionId, session }) => {
             }
             finally {
                 set((state) => {
+                    state.loaded = true;
                     state.loading = false;
                 });
             }
         }),
-        execute: (_c) => __awaiter(void 0, [_c], void 0, function* ({ assistantId, parameters, onResponseStart, includeSessionParameters, }) {
-            var _d, e_1, _e, _f;
-            var _g, _h, _j, _k, _l;
-            const identity = parseIdentity(assistantId, { rejectWhenError: true });
+        loadMoreMessages: () => __awaiter(void 0, void 0, void 0, function* () {
+            var _c;
+            set((state) => {
+                state.messageLoading = true;
+            });
+            const { session, messages } = get();
+            if (!session)
+                return;
+            try {
+                const result = yield getMessages({
+                    sessionId: session.id,
+                    before: (_c = messages === null || messages === void 0 ? void 0 : messages.slice(-1)[0]) === null || _c === void 0 ? void 0 : _c.id,
+                    orderDirection: GET_MESSAGES_ORDER_DIRECTION,
+                    limit: GET_MESSAGES_LIMIT,
+                });
+                set((state) => {
+                    var _a;
+                    state.messages = ((_a = state.messages) !== null && _a !== void 0 ? _a : []).concat(result.messages.toReversed());
+                    state.noMoreMessage = result.messages.length < GET_MESSAGES_LIMIT;
+                });
+            }
+            finally {
+                set((state) => {
+                    state.messageLoading = false;
+                });
+            }
+        }),
+        execute: (_d) => __awaiter(void 0, [_d], void 0, function* ({ aid, working, parameters, onResponseStart, }) {
+            var _e, e_1, _f, _g;
+            let { session } = get();
+            if (!session) {
+                yield get().load();
+                session = get().session;
+            }
+            if (!session)
+                throw new Error('This session is not initialized');
+            const { id: sessionId } = session;
+            const identity = parseIdentity(aid, { 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({}, (_g = get().session) === null || _g === void 0 ? void 0 : _g.parameters), parameters);
-            }
             try {
-                const stream = runAssistant({
+                const stream = runAgent({
+                    aid,
                     sessionId,
-                    identity,
-                    parameters: realParameters,
+                    working,
+                    parameters: Object.assign(Object.assign({}, parameters), { $clientTime: new Date().toISOString() }),
                 });
                 let responseStarted = false;
                 try {
-                    for (var _m = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _d = stream_1_1.done, !_d; _m = true) {
-                        _f = stream_1_1.value;
-                        _m = false;
-                        const value = _f;
+                    for (var _h = true, stream_1 = __asyncValues(stream), stream_1_1; stream_1_1 = yield stream_1.next(), _e = stream_1_1.done, !_e; _h = true) {
+                        _g = stream_1_1.value;
+                        _h = false;
+                        const value = _g;
                         if (!responseStarted) {
                             responseStarted = true;
                             onResponseStart === null || onResponseStart === void 0 ? void 0 : onResponseStart();
@@ -93,8 +133,8 @@ export const createSessionState = ({ sessionId, session }) => {
                             if (!message) {
                                 message = {
                                     taskId: value.taskId,
-                                    sessionId,
                                     assistantId: identity.assistantId,
+                                    sessionId,
                                     parameters,
                                     createdAt: new Date().toISOString(),
                                     updatedAt: new Date().toISOString(),
@@ -107,49 +147,23 @@ export const createSessionState = ({ sessionId, session }) => {
                                 });
                             }
                             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 });
+                                requestAnimationFrame(() => {
+                                    set((state) => {
+                                        var _a, _b, _c, _d, _e, _f;
+                                        var _g;
+                                        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) {
-                                            (_g = state.metadata) !== null && _g !== void 0 ? _g : (state.metadata = {});
-                                            deepMerge(state.metadata, pick(value.delta.object, Object.values(RuntimeOutputVariable)));
+                                            (_f = (_g = msg.result).objects) !== null && _f !== void 0 ? _f : (_g.objects = []);
+                                            msg.result.objects.push({ taskId: value.taskId, data: value.delta.object });
                                         }
-                                    }
-                                });
-                            }
-                            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);
-                                }
-                                (_h = childMessage.result) !== null && _h !== void 0 ? _h : (childMessage.result = {});
-                                childMessage.result.content = (childMessage.result.content || '') + (value.delta.content || '');
-                                if ((_k = (_j = value.delta) === null || _j === void 0 ? void 0 : _j.images) === null || _k === void 0 ? void 0 : _k.length) {
-                                    childMessage.result.images = ((_l = childMessage.result.images) !== null && _l !== void 0 ? _l : []).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));
+                                    });
                                 });
                             }
                         }
@@ -168,7 +182,7 @@ export const createSessionState = ({ sessionId, session }) => {
                 catch (e_1_1) { e_1 = { error: e_1_1 }; }
                 finally {
                     try {
-                        if (!_m && !_d && (_e = stream_1.return)) yield _e.call(stream_1);
+                        if (!_h && !_e && (_f = stream_1.return)) yield _f.call(stream_1);
                     }
                     finally { if (e_1) throw e_1.error; }
                 }
@@ -191,16 +205,5 @@ export const createSessionState = ({ sessionId, session }) => {
             }
         }),
     }))));
-    return STATES[sessionId];
+    return STATES[aid];
 };
-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/types/builtin/async/ai-runtime/api/{assistant.d.ts → agent.d.ts}

@@ -1,5 +1,5 @@
 import { AssistantBase, OutputVariable, Parameter } from '@blocklet/ai-runtime/types';
-export interface Assistant {
+export interface Agent {
     id: string;
     name?: string;
     description?: string;
@@ -15,7 +15,7 @@ export interface Assistant {
     release?: AssistantBase['release'];
     createdBy?: string;
 }
-export declare function getAssistant({ assistantId: id, working, }: {
-    assistantId: string;
+export declare function getAgent({ aid, working }: {
+    aid: string;
     working?: boolean;
-}): Promise<Assistant>;
+}): Promise<Agent>;

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

@@ -1,5 +1,4 @@
 import { RunAssistantResponse } from '@blocklet/ai-runtime/types';
-import { Identity } from '../utils';
 export interface Session {
     id: string;
     userId: string;
@@ -12,10 +11,8 @@ export interface Session {
         title?: string;
     };
 }
-export declare function getSessions({ projectId, projectRef, assistantId, }: {
-    projectId: string;
-    projectRef: string;
-    assistantId: string;
+export declare function getSessions({ aid }: {
+    aid: string;
 }): Promise<{
     sessions: Session[];
 }>;
@@ -24,19 +21,16 @@ export declare function getSession({ sessionId }: {
 }): Promise<{
     session: Session;
 }>;
-export declare function createSession({ assistantId, name, parameters, entry, }: {
-    assistantId: string;
+export declare function createSession({ aid, name, }: {
+    aid: string;
     name?: string;
-    parameters?: any;
-    entry?: any;
 }): Promise<{
     created: Session;
     sessions: Session[];
 }>;
-export declare function updateSession({ sessionId, name, parameters, }: {
+export declare function updateSession({ sessionId, name, }: {
     sessionId: string;
     name?: string;
-    parameters?: any;
 }): Promise<{
     updated: Session;
     sessions: Session[];
@@ -47,9 +41,9 @@ export declare function deleteSession({ sessionId, }: {
     deleted: Session;
     sessions: Session[];
 }>;
-export declare function runAssistant({ sessionId, identity, working, parameters, }: {
+export declare function runAgent({ aid, sessionId, working, parameters, }: {
+    aid: string;
     sessionId: string;
-    identity: Identity;
     working?: boolean;
     parameters: any;
 }): AsyncGenerator<RunAssistantResponse, void, unknown>;

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

@@ -1,6 +1,6 @@
 import { LoadingButtonProps } from '@mui/lab';
 import { ReactNode } from 'react';
-export declare function ActionButton({ tip, tipSucceed, title, titleSucceed, icon, iconSucceed, autoReset, placement, ...props }: {
+export default function ActionButton({ tip, tipSucceed, title, titleSucceed, icon, iconSucceed, autoReset, placement, ...props }: {
     tip?: ReactNode;
     tipSucceed?: ReactNode;
     title?: ReactNode;

package/lib/types/builtin/async/ai-runtime/components/{parameters → AgentInputField}/index.d.ts

@@ -1,6 +1,6 @@
 import { Parameter } from '@blocklet/ai-runtime/types';
 import { TextFieldProps } from '@mui/material';
-export default function ParameterField({ parameter, ...props }: {
+export default function AgentInputField({ parameter, ...props }: {
     readOnly?: boolean;
     parameter: Parameter;
     onChange: (value: string | number | undefined) => void;

package/lib/types/builtin/async/ai-runtime/components/{GlobalLoading.d.ts → GlobalLoading/index.d.ts}

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

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

@@ -0,0 +1,5 @@
+import { StackProps, TypographyProps } from '@mui/material';
+export default function SimpleHeader({ TitleProps, DescriptionProps, ...props }: {
+    TitleProps?: TypographyProps;
+    DescriptionProps?: TypographyProps;
+} & StackProps): import("react/jsx-runtime").JSX.Element;

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

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

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

@@ -1,3 +1,4 @@
 /// <reference types="react" />
-declare const LoadingButton: import("react").ForwardRefExoticComponent<Omit<any, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
+import { LoadingButtonProps } from '@mui/lab';
+declare const LoadingButton: import("react").ForwardRefExoticComponent<Omit<Partial<LoadingButtonProps>, "ref"> & import("react").RefAttributes<HTMLButtonElement>>;
 export default LoadingButton;

package/lib/types/builtin/async/ai-runtime/components/{RuntimeProvider.d.ts → RuntimeCommonProvider.d.ts}

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

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

@@ -1,61 +1,10 @@
 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;
+import * as scrollToBottom from 'react-scroll-to-bottom';
+declare const Composer: typeof scrollToBottom.default;
+export default function ScrollView({ disabled, children, scroll, component, initialScrollBehavior, ...props }: BoxProps & {
+    disabled?: boolean;
+    scroll?: 'window';
+    initialScrollBehavior?: ComponentProps<typeof Composer>['initialScrollBehavior'];
+}): string | number | boolean | Iterable<import("react").ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+export {};

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

@@ -1,2 +1,5 @@
 export declare const AI_STUDIO_DID = "z8iZpog7mcgcgBZzTiXJCWESvmnRrQmnd3XBB";
 export declare const PAYMENT_KIT_DID = "z2qaCNvKMv5GjouKdcDWexv6WqtHbpNPQDnAk";
+export declare const DEFAULT_PAGE_COMPONENT_ID = "ctnxha29uu8cx4xv";
+export declare const DEFAULT_INPUT_COMPONENT_ID = "1wwtemqcdio6nqf0";
+export declare const DEFAULT_OUTPUT_COMPONENT_ID = "q0ckknkxph4hfwas";

package/lib/types/builtin/async/ai-runtime/{components/runtime/contexts → contexts}/CurrentAgent.d.ts

@@ -8,7 +8,7 @@ export default function CurrentAgentProvider({ agentId, children }: {
     children?: ReactNode;
 }): import("react/jsx-runtime").JSX.Element;
 export declare function useCurrentAgent(): {
-    agent: import("../../../api/assistant").Assistant;
+    agent: import("../api/agent").Agent;
     appearanceInput: RuntimeOutputAppearance;
     appearanceOutput: RuntimeOutputAppearance;
     aid: string;

package/lib/types/builtin/async/ai-runtime/contexts/Runtime.d.ts

@@ -0,0 +1,14 @@
+import { ReactNode } from 'react';
+export interface RuntimeContext {
+    aid: string;
+    working?: boolean;
+}
+export declare function useRuntimeContext(): RuntimeContext;
+export default function RuntimeProvider({ aid, working, children, }: {
+    aid: string;
+    working?: boolean;
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function RuntimeProviderFromUrl({ children }: {
+    children?: ReactNode;
+}): import("react/jsx-runtime").JSX.Element;