@blocklet/pages-kit 0.2.285 → 0.2.287

package/lib/cjs/builtin/async/ai-runtime/state/index.js

@@ -0,0 +1,423 @@
+"use strict";
+// import { StoreApi, UseBoundStore, create } from 'zustand';
+// import { immer } from 'zustand/middleware/immer';
+// import { EventSourceParserStream } from '../../../stream';
+// import { getComponentMountPoint, joinURL } from '../../../utils';
+// import { Assistant, getAssistant } from '../api/assistant';
+// import {
+//   Dataset,
+//   createDataset,
+//   createDocument,
+//   deleteDataset,
+//   deleteDocument,
+//   getDataset,
+//   getDatasets,
+//   getDocuments,
+//   updateDataset,
+//   updateDocument,
+// } from '../api/dataset';
+// import { deleteMessages, getMessages } from '../api/message';
+// import { Session, createSession, getSessions, updateSession } from '../api/session';
+// import { Subscription, getSubscription } from '../api/subscription';
+// import { AI_STUDIO_DID } from '../constants';
+// import { parseIdentity } from '../utils';
+// const STATES: {
+//   assistant: { [key: string]: UseBoundStore<StoreApi<State>> };
+//   dataset: { [key: string]: ReturnType<typeof createDatasetState> };
+//   datasetDetail: { [key: string]: ReturnType<typeof createDatasetDetailState> };
+// } = { assistant: {}, dataset: {}, datasetDetail: {} };
+// export interface State {
+//   loading: boolean;
+//   loaded: boolean;
+//   assistant?: Assistant;
+//   sessions?: Session[];
+//   subscription?: Subscription;
+//   sessionMap: { [sessionId: string]: { session: Session } };
+//   computed: {
+//     get isChat(): boolean | undefined;
+//     get requireNewSubscription(): boolean | undefined;
+//   };
+// }
+// export const createState = ({
+//   releaseId,
+//   preload: { assistant, sessions, subscription } = {},
+// }: {
+//   releaseId: string;
+//   preload?: {
+//     assistant?: Assistant;
+//     sessions?: Session[];
+//     subscription?: Subscription;
+//   };
+// }) => {
+//   STATES.assistant[releaseId] ??= create<State>()(
+//     immer<State>((set, get) => ({
+//       loading: false,
+//       loaded: false,
+//       assistant,
+//       sessions,
+//       subscription,
+//       sessionMap: Object.fromEntries((sessions ?? []).map((session) => [session.id, { session }])),
+//       computed: {
+//         get isChat() {
+//           const parameters = get().assistant?.parameters;
+//           return parameters?.some((i) => i.key === 'question');
+//         },
+//         get requireNewSubscription() {
+//           // TODO: implement payment
+//           // const { subscription } = get();
+//           // const { paymentEnabled, paymentLinkId } = release;
+//           // return !!paymentEnabled && !!paymentLinkId && !subscription;
+//           return false;
+//         },
+//         get withCollection() {
+//           const parameters = get().assistant?.parameters;
+//           return parameters?.some((i) => i.key === 'datasetId');
+//         },
+//       },
+//       getPaymentLink({ userId }: { userId: string }) {
+//         // TODO: implement
+//         // return withQuery(
+//         //   joinURL('/', getComponentMountPoint(PAYMENT_KIT_DID), '/checkout/pay', release.paymentLinkId),
+//         //   {
+//         //     'metadata.releaseId': release.id,
+//         //     'metadata.userId': userId,
+//         //     redirect: window.location.href,
+//         //   }
+//         // );
+//       },
+//       getAssistant: async () => {
+//         set((state) => {
+//           state.loading = true;
+//         });
+//         try {
+//           const { subscription } = await getSubscription({ releaseId });
+//           const identity = parseIdentity(releaseId, { rejectWhenError: true });
+//           const [assistant, { sessions }] = await Promise.all([getAssistant(identity), getSessions(identity)]);
+//           set((state) => {
+//             state.assistant = assistant;
+//             state.sessions = sessions;
+//             state.subscription = subscription;
+//             state.sessionMap = Object.fromEntries(
+//               (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//             );
+//           });
+//         } finally {
+//           set((state) => {
+//             state.loading = false;
+//             state.loaded = true;
+//           });
+//         }
+//       },
+//       getSessions: async () => {
+//         const identity = parseIdentity(releaseId, { rejectWhenError: true });
+//         const { sessions } = await getSessions(identity);
+//         set((state) => {
+//           state.sessions = sessions;
+//           state.sessionMap = Object.fromEntries(
+//             (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//           );
+//         });
+//       },
+//       reloadMessages: async ({ sessionId }) => {
+//         set((state) => {
+//           const s = state.sessionMap[sessionId];
+//           if (!s) return;
+//           s.loading = true;
+//         });
+//         try {
+//           const { messages, count } = await getMessages({ sessionId });
+//           set((state) => {
+//             const s = state.sessionMap[sessionId];
+//             if (!s) return;
+//             s.messages = messages;
+//             s.messageCount = count;
+//           });
+//         } finally {
+//           set((state) => {
+//             const s = state.sessionMap[sessionId];
+//             if (!s) return;
+//             s.loading = false;
+//           });
+//         }
+//       },
+//       cleanSession: async ({ sessionId }) => {
+//         set((state) => {
+//           const s = state.sessionMap[sessionId];
+//           if (s) s.sessionReseting = true;
+//         });
+//         await deleteMessages({ sessionId });
+//         set((state) => {
+//           const s = state.sessionMap[sessionId];
+//           if (s) {
+//             s.sessionReseting = false;
+//             s.messages = [];
+//           }
+//         });
+//       },
+//       createSession: async ({ name, parameters, entry }) => {
+//         const identity = parseIdentity(releaseId);
+//         const { sessions, created } = await createSession({ ...identity, name, parameters, entry });
+//         set((state) => {
+//           state.sessions = sessions;
+//           state.sessionMap = Object.fromEntries(
+//             (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//           );
+//         });
+//         return created;
+//       },
+//       updateSession: async ({ sessionId, parameters }) => {
+//         set((state) => {
+//           const s = state.sessionMap[sessionId].session;
+//           if (s.parameters) Object.assign(s.parameters, parameters);
+//         });
+//         const { sessions } = await updateSession({ sessionId, parameters });
+//         set((state) => {
+//           state.sessions = sessions;
+//           state.sessionMap = Object.fromEntries(
+//             (sessions ?? []).map((session) => [session.id, { ...state.sessionMap[session.id], session }])
+//           );
+//         });
+//       },
+//       execute: async ({ sessionId, parameters, onResponseStart, assistantIdentity }) => {
+//         const identity = parseIdentity(releaseId);
+//         let message;
+//         const childMessages = [];
+//         const childMessagesMap = {};
+//         set((state) => {
+//           const session = state.sessionMap[sessionId];
+//           if (session) session.executing = true;
+//         });
+//         try {
+//           const res = await fetch(joinURL(getComponentMountPoint(AI_STUDIO_DID), '/api/ai/call'), {
+//             method: 'POST',
+//             headers: {
+//               'Content-Type': 'application/json',
+//               Accept: 'text/event-stream',
+//             },
+//             body: JSON.stringify({
+//               sessionId,
+//               parameters: { ...parameters, $clientTime: new Date().toISOString() },
+//               ...(assistantIdentity || identity),
+//               ref: (assistantIdentity || identity).projectRef,
+//               working: true,
+//             }),
+//           });
+//           if (!(res.status >= 200 && res.status < 300)) {
+//             let json: any;
+//             try {
+//               json = await res.json();
+//             } catch (error) {}
+//             const { message } = json.error;
+//             if (typeof message === 'string') {
+//               throw new Error(message);
+//             }
+//             throw new Error(`Unknown Error: ${res.status}`);
+//           }
+//           const stream = res
+//             .body!.pipeThrough(new TextDecoderStream())
+//             .pipeThrough(new EventSourceParserStream())
+//             .getReader();
+//           let responseStarted = false;
+//           for (;;) {
+//             const { value, done } = await stream.read();
+//             if (!responseStarted) {
+//               responseStarted = true;
+//               onResponseStart?.();
+//             }
+//             if (value?.type === 'CHUNK') {
+//               if (!message) {
+//                 message = {
+//                   taskId: value.taskId,
+//                   parameters,
+//                   loading: true,
+//                   createdAt: new Date().toISOString(),
+//                 };
+//                 set((state) => {
+//                   state.sessionMap[sessionId] ??= {};
+//                   state.sessionMap[sessionId].messages ??= [];
+//                   state.sessionMap[sessionId].messages.push(message);
+//                 });
+//               }
+//               if (message.taskId === value.taskId) {
+//                 set((state) => {
+//                   const msg = state.sessionMap[sessionId]?.messages?.findLast((i) => i.taskId === message.taskId);
+//                   if (!msg) return;
+//                   msg.result ??= {};
+//                   msg.result.content = (msg.result.content || '') + (value.delta.content || '');
+//                   if (value.delta.object) {
+//                     msg.result.objects ??= [];
+//                     msg.result.objects.push(value.delta.object);
+//                     if (value.delta.object.metadata) {
+//                       const session = state.sessionMap[sessionId];
+//                       session.metadata ??= {};
+//                       deepMerge(session.metadata, value.delta.object.metadata);
+//                     }
+//                   }
+//                   if (value.delta?.images?.length) {
+//                     msg.result.images = (msg.result.images ?? []).concat(value.delta.images);
+//                   }
+//                 });
+//               } else if (value.respondAs && value.respondAs !== 'none') {
+//                 let childMessage = childMessagesMap[value.taskId];
+//                 if (!childMessage) {
+//                   childMessage = {
+//                     taskId: value.taskId,
+//                     createdAt: new Date().toISOString(),
+//                     respondAs: value.respondAs,
+//                   };
+//                   childMessagesMap[value.taskId] = childMessage;
+//                   childMessages.push(childMessage);
+//                 }
+//                 childMessage.result ??= {};
+//                 childMessage.result.content = (childMessage.result.content || '') + (value.delta.content || '');
+//                 if (value.delta?.images?.length) {
+//                   childMessage.result.images = (childMessage.result.images ?? []).concat(value.delta.images);
+//                 }
+//                 set((state) => {
+//                   const msg = state.sessionMap[sessionId]?.messages?.findLast((i) => i.taskId === message.taskId);
+//                   if (!msg) return;
+//                   msg.result ??= {};
+//                   msg.result.messages = JSON.parse(JSON.stringify(childMessages));
+//                 });
+//               }
+//             }
+//             if (value?.type === 'ERROR') {
+//               set((state) => {
+//                 const msg = state.sessionMap[sessionId]?.messages?.findLast((i) => i.taskId === message.taskId);
+//                 if (msg) msg.error = value.error;
+//                 else throw new Error(value.error.message);
+//               });
+//             }
+//             if (done) break;
+//           }
+//         } finally {
+//           set((state) => {
+//             const session = state.sessionMap[sessionId];
+//             session.executing = false;
+//             if (session && message) {
+//               const msg = session.messages?.findLast((i) => i.taskId === message.taskId);
+//               if (msg) msg.loading = false;
+//             }
+//           });
+//         }
+//       },
+//     }))
+//   );
+//   return STATES.assistant[releaseId]!;
+// };
+// export function createDatasetState({ releaseId, datasets }: { releaseId: string; datasets?: Dataset[] }) {
+//   STATES.dataset[releaseId] ??= create()(
+//     immer((set) => ({
+//       loading: false,
+//       list: datasets,
+//       error: undefined,
+//       creating: false,
+//       async reload() {
+//         try {
+//           set((state) => {
+//             state.loading = true;
+//           });
+//           const datasets = await getDatasets({ appId: releaseId });
+//           set((state) => {
+//             state.loading = false;
+//             state.list = datasets;
+//             state.error = undefined;
+//           });
+//         } catch (error) {
+//           set((state) => {
+//             state.loading = false;
+//             state.error = error;
+//           });
+//         }
+//       },
+//       async createDataset({ name, description }: { name: string; description?: string }) {
+//         try {
+//           set((state) => {
+//             state.creating = true;
+//           });
+//           const created = await createDataset({ appId: releaseId, name, description });
+//           await this.reload();
+//           return created;
+//         } finally {
+//           set((state) => {
+//             state.creating = false;
+//           });
+//         }
+//       },
+//       async updateDataset(datasetId: string, { name, description }: { name: string; description?: string }) {
+//         const updated = await updateDataset(datasetId, { name, description });
+//         await this.reload();
+//         return updated;
+//       },
+//       async deleteDataset(datasetId: string) {
+//         await deleteDataset(datasetId);
+//         await this.reload();
+//       },
+//     }))
+//   );
+//   return STATES.dataset[releaseId];
+// }
+// export function createDatasetDetailState({ datasetId, list }: { datasetId: string; list?: Document[] }) {
+//   STATES.datasetDetail[datasetId] ??= create()(
+//     immer((set, get) => ({
+//       loading: false,
+//       dataset: undefined,
+//       list,
+//       error: undefined,
+//       creating: false,
+//       async reload() {
+//         if (get().loading) return;
+//         set((state) => {
+//           state.loading = true;
+//         });
+//         try {
+//           const [dataset, { items }] = await Promise.all([getDataset({ datasetId }), getDocuments(datasetId)]);
+//           set((state) => {
+//             state.dataset = dataset;
+//             state.loading = false;
+//             state.list = items;
+//             state.error = undefined;
+//           });
+//         } catch (error) {
+//           set((state) => {
+//             state.loading = false;
+//             state.error = error;
+//           });
+//         }
+//       },
+//       async createDocument(type: 'text' | 'file', input: Parameters<typeof createDocument>[1]) {
+//         try {
+//           set((state) => {
+//             state.creating = true;
+//           });
+//           const created = await createDocument(datasetId, type, input);
+//           await this.reload();
+//           return created;
+//         } finally {
+//           set((state) => {
+//             state.creating = false;
+//           });
+//         }
+//       },
+//       async updateDocument(documentId: string, type: 'text', input: Parameters<typeof updateDocument>[1]) {
+//         try {
+//           set((state) => {
+//             state.updating = true;
+//           });
+//           const updated = await updateDocument(datasetId, documentId, type, input);
+//           await this.reload();
+//           return updated;
+//         } finally {
+//           set((state) => {
+//             state.updating = false;
+//           });
+//         }
+//       },
+//       async deleteDocument(documentId) {
+//         await deleteDocument(datasetId, documentId);
+//         await this.reload();
+//       },
+//     }))
+//   );
+//   return STATES.datasetDetail[datasetId];
+// }

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

@@ -0,0 +1,217 @@
+"use strict";
+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); }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSessionState = exports.createSessionState = void 0;
+const types_1 = require("@blocklet/ai-runtime/types");
+const pick_1 = __importDefault(require("lodash/pick"));
+const zustand_1 = require("zustand");
+const immer_1 = require("zustand/middleware/immer");
+const message_1 = require("../api/message");
+const session_1 = require("../api/session");
+const utils_1 = require("../utils");
+const STATES = {};
+const createSessionState = ({ sessionId, session }) => {
+    var _a;
+    (_a = STATES[sessionId]) !== null && _a !== void 0 ? _a : (STATES[sessionId] = (0, zustand_1.create)()((0, immer_1.immer)((set, get) => ({
+        session,
+        clearSession: (_b) => __awaiter(void 0, [_b], void 0, function* ({ sessionId }) {
+            yield (0, message_1.deleteMessages)({ sessionId });
+            get().load();
+        }),
+        updateSession: (_c) => __awaiter(void 0, [_c], void 0, function* ({ parameters }) {
+            const { updated } = yield (0, session_1.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([
+                    (0, session_1.getSession)({ sessionId }),
+                    (0, message_1.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 = (0, utils_1.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 = (0, session_1.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 = {});
+                                            (0, utils_1.deepMerge)(state.metadata, (0, pick_1.default)(value.delta.object, types_1.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];
+};
+exports.createSessionState = createSessionState;
+const LOADING_TASKS = {};
+function useSessionState({ sessionId, required }) {
+    var _a;
+    const state = (0, exports.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];
+}
+exports.useSessionState = useSessionState;