@kapeta/local-cluster-service 0.61.2 → 0.62.1

package/src/storm/routes.ts

@@ -12,8 +12,17 @@ import { corsHandler } from '../middleware/cors';
 import { stringBody } from '../middleware/stringBody';
 import { KapetaBodyRequest } from '../types';
 import { StormCodegenRequest, StormContextRequest, StormCreateBlockRequest, StormStream } from './stream';
-import { ConversationIdHeader, stormClient, UIPagePrompt, UIPageEditPrompt, UIPageEditRequest } from './stormClient';
+
+import {
+    ConversationIdHeader,
+    stormClient,
+    UIPagePrompt,
+    UIPageEditPrompt,
+    UIPageEditRequest,
+    UIPageSamplePrompt,
+} from './stormClient';
 import { Page, StormEvent, StormEventPage, StormEventPhaseType, UIShell, UserJourneyScreen } from './events';
+
 import {
     createPhaseEndEvent,
     createPhaseStartEvent,
@@ -25,8 +34,17 @@ import { StormCodegen } from './codegen';
 import { assetManager } from '../assetManager';
 import uuid from 'node-uuid';
 import { PromiseQueue } from './PromiseQueue';
-import { readPageFromDisk, readPageFromDiskAsString, SystemIdHeader, writePageToDisk } from './page-utils';
+import {
+    readConversationFromFile,
+    readPageFromDisk,
+    readPageFromDiskAsString,
+    SystemIdHeader,
+    writeConversationToFile,
+    writePageToDisk,
+} from './page-utils';
 import { UIServer } from './UIServer';
+import { PageQueue } from './PageGenerator';
+import FSExtra from 'fs-extra';
 
 const UI_SERVERS: { [key: string]: UIServer } = {};
 const router = Router();
@@ -34,6 +52,8 @@ const router = Router();
 router.use('/', corsHandler);
 router.use('/', stringBody);
 
+const samplesBaseDir = Path.join(__dirname, 'samples');
+
 function convertPageEvent(screenData: StormEvent, innerConversationId: string, mainConversationId: string): StormEvent {
     if (screenData.type === 'PAGE') {
         const server: UIServer | undefined = UI_SERVERS[mainConversationId];
@@ -75,22 +95,25 @@ router.post('/ui/screen', async (req: KapetaBodyRequest, res: Response) => {
         const aiRequest: UIPagePrompt = JSON.parse(req.stringBody ?? '{}');
         aiRequest.storage_prefix = systemId ? systemId + '_' : 'mock_';
 
-        const screenStream = await stormClient.createUIPage(aiRequest, conversationId);
+        res.set('Content-Type', 'application/x-ndjson');
+        res.set('Access-Control-Expose-Headers', ConversationIdHeader);
+        res.set(ConversationIdHeader, conversationId);
+
+        const parentConversationId = systemId ?? '';
 
+        const queue = new PageQueue(parentConversationId, 5);
         onRequestAborted(req, res, () => {
-            screenStream.abort();
+            queue.cancel();
         });
 
-        res.set('Content-Type', 'application/x-ndjson');
-        res.set('Access-Control-Expose-Headers', ConversationIdHeader);
-        res.set(ConversationIdHeader, screenStream.getConversationId());
+        await queue.addPrompt(aiRequest);
 
         const promises: Promise<void>[] = [];
-        screenStream.on('data', (data: StormEvent) => {
+        queue.on('page', (data) => {
             switch (data.type) {
                 case 'PAGE':
                     console.log('Processing page event', data);
-                    data.payload.conversationId = screenStream.getConversationId();
+
                     if (systemId) {
                         promises.push(sendPageEvent(systemId, data, res));
                     }
@@ -99,7 +122,7 @@ router.post('/ui/screen', async (req: KapetaBodyRequest, res: Response) => {
             sendEvent(res, data);
         });
 
-        await waitForStormStream(screenStream);
+        await queue.wait();
         await Promise.allSettled(promises);
 
         sendDone(res);
@@ -125,6 +148,93 @@ router.delete('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
     }
 });
 
+router.post('/:handle/ui/iterative', async (req: KapetaBodyRequest, res: Response) => {
+    const handle = req.params.handle as string;
+    try {
+        const conversationId = req.headers[ConversationIdHeader.toLowerCase()] as string | undefined;
+
+        const aiRequest: StormContextRequest = JSON.parse(req.stringBody ?? '{}');
+
+        const landingPagesStream = await stormClient.createUILandingPages(aiRequest.prompt, conversationId);
+
+        onRequestAborted(req, res, () => {
+            landingPagesStream.abort();
+        });
+
+        res.set('Content-Type', 'application/x-ndjson');
+        res.set('Access-Control-Expose-Headers', ConversationIdHeader);
+
+        res.set(ConversationIdHeader, landingPagesStream.getConversationId());
+
+        const promises: { [key: string]: Promise<void> } = {};
+        const pageEventPromises: Promise<void>[] = [];
+        const systemId = landingPagesStream.getConversationId();
+        const pageQueue = new PageQueue(systemId, 5);
+
+        landingPagesStream.on('data', async (data: StormEvent) => {
+            try {
+                sendEvent(res, data);
+                if (data.type !== 'LANDING_PAGE') {
+                    return;
+                }
+
+                if (landingPagesStream.isAborted()) {
+                    return;
+                }
+                const landingPage = data.payload;
+                if (landingPage.name in promises) {
+                    return;
+                }
+
+                // We add the landing pages to the prompt queue.
+                // These will then be analysed - creating further pages as needed
+                promises[landingPage.name] = pageQueue.addPrompt({
+                    prompt: landingPage.create_prompt,
+                    method: 'GET',
+                    path: landingPage.path,
+                    description: landingPage.create_prompt,
+                    name: landingPage.name,
+                    title: landingPage.title,
+                    filename: landingPage.filename,
+                    storage_prefix: systemId + '_',
+                });
+            } catch (e) {
+                console.error('Failed to process event', e);
+            }
+        });
+
+        UI_SERVERS[systemId] = new UIServer(systemId);
+        await UI_SERVERS[systemId].start();
+
+        onRequestAborted(req, res, () => {
+            pageQueue.cancel();
+        });
+
+        pageQueue.on('page', (screenData: StormEventPage) => {
+            pageEventPromises.push(sendPageEvent(landingPagesStream.getConversationId(), screenData, res));
+        });
+
+        pageQueue.on('event', (screenData: StormEvent) => {
+            sendEvent(res, screenData);
+        });
+
+        await waitForStormStream(landingPagesStream);
+        await pageQueue.wait();
+        await Promise.allSettled(pageEventPromises);
+
+        if (landingPagesStream.isAborted()) {
+            return;
+        }
+
+        sendDone(res);
+    } catch (err) {
+        sendError(err as Error, res);
+        if (!res.closed) {
+            res.end();
+        }
+    }
+});
+
 router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
     const handle = req.params.handle as string;
     try {
@@ -223,75 +333,40 @@ router.post('/:handle/ui', async (req: KapetaBodyRequest, res: Response) => {
         await UI_SERVERS[outerConversationId].start();
 
         // Get the pages (5 at a time)
-        const queue = new PromiseQueue(5);
-
+        const queue = new PageQueue(outerConversationId, 5);
+        const pagePromises: Promise<void>[] = [];
         onRequestAborted(req, res, () => {
             queue.cancel();
         });
 
+        const pageEventPromises: Promise<void>[] = [];
+        queue.on('page', (screenData: StormEventPage) => {
+            pageEventPromises.push(sendPageEvent(outerConversationId, screenData, res));
+        });
+
+        queue.on('event', (screenData: StormEvent) => {
+            sendEvent(res, screenData);
+        });
+
         for (const screen of Object.values(uniqueUserJourneyScreens)) {
-            void queue.add(
-                () =>
-                    new Promise(async (resolve, reject) => {
-                        try {
-                            const innerConversationId = uuid.v4();
-                            const screenStream = await stormClient.createUIPage(
-                                {
-                                    prompt: screen.requirements,
-                                    method: screen.method,
-                                    path: screen.path,
-                                    description: screen.requirements,
-                                    name: screen.name,
-                                    title: screen.title,
-                                    filename: screen.filename,
-                                    storage_prefix: outerConversationId + '_',
-                                    shell_page: uiShells.find((shell) => shell.screens.includes(screen.name))?.content,
-                                },
-                                innerConversationId
-                            );
-
-                            const promiseList: Promise<void>[] = [];
-                            screenStream.on('data', (screenData: StormEvent) => {
-                                if (screenData.type === 'PAGE') {
-                                    promiseList.push(
-                                        sendPageEvent(
-                                            outerConversationId,
-                                            {
-                                                ...screenData,
-                                                payload: {
-                                                    ...screenData.payload,
-                                                    conversationId: innerConversationId,
-                                                },
-                                            },
-                                            res
-                                        )
-                                    );
-                                } else {
-                                    sendEvent(res, screenData);
-                                }
-                            });
-
-                            screenStream.on('end', async () => {
-                                try {
-                                    await Promise.allSettled(promiseList).finally(() => resolve(true));
-                                } catch (error) {
-                                    console.error('Failed to process screen', error);
-                                }
-                            });
-
-                            screenStream.on('error', (error) => {
-                                console.error('Error on screenStream', error);
-                                screenStream.abort();
-                            });
-                        } catch (e) {
-                            console.error('Failed to process screen', e);
-                            reject(e);
-                        }
-                    })
+            pagePromises.push(
+                queue.addPrompt({
+                    prompt: screen.requirements,
+                    method: screen.method,
+                    path: screen.path,
+                    description: screen.requirements,
+                    name: screen.name,
+                    title: screen.title,
+                    filename: screen.filename,
+                    storage_prefix: outerConversationId + '_',
+                    shell_page: uiShells.find((shell) => shell.screens.includes(screen.name))?.content,
+                })
             );
         }
 
         await queue.wait();
+        await Promise.allSettled(pagePromises);
+        await Promise.allSettled(pageEventPromises);
 
         if (userJourneysStream.isAborted()) {
             return;
@@ -408,6 +483,7 @@ router.post('/:handle/all', async (req: KapetaBodyRequest, res: Response) => {
                 const result = await eventParser.processEvent(handle, data);
 
                 switch (data.type) {
+                    case 'API_STREAM_START':
                     case 'CREATE_API':
                     case 'CREATE_MODEL':
                     case 'CREATE_TYPE':
@@ -581,6 +657,7 @@ function sendError(err: Error, res: Response) {
         res.status(400).send({ error: err.message });
     }
 }
+
 function waitForStormStream(result: StormStream) {
     return result.waitForDone();
 }

package/src/storm/stormClient.ts

@@ -44,6 +44,10 @@ export interface UIPagePrompt {
     shell_page?: string;
 }
 
+export interface UIPageSamplePrompt extends UIPagePrompt {
+    variantId: string;
+}
+
 export interface UIPageEditPrompt {
     planDescription: string;
     blockDescription: string;
@@ -168,14 +172,28 @@ class StormClient {
     public createUIShells(prompt: UIShellsPrompt, conversationId?: string) {
         return this.send('/v2/ui/shells', {
             prompt: JSON.stringify(prompt),
+        });
+    }
+
+    public createUILandingPages(prompt: string, conversationId?: string) {
+        return this.send('/v2/ui/landing-pages', {
+            prompt: prompt,
             conversationId,
         });
     }
 
-    public createUIPage(prompt: UIPagePrompt, conversationId?: string) {
+    public createUIPage(prompt: UIPagePrompt, conversationId?: string, history?: ConversationItem[]) {
         return this.send('/v2/ui/page', {
             prompt: prompt,
             conversationId,
+            history,
+        });
+    }
+
+    public classifyUIReferences(prompt: string, conversationId?: string) {
+        return this.send('/v2/ui/references', {
+            prompt: prompt,
+            conversationId,
         });
     }
 
@@ -234,6 +252,20 @@ class StormClient {
             conversationId: conversationId,
         });
     }
+
+    async deleteUIPageConversation(conversationId: string) {
+        const options = await this.createOptions('/v2/ui/page', 'DELETE', {
+            prompt: '',
+            conversationId: conversationId,
+        });
+
+        const response = await fetch(options.url, {
+            method: options.method,
+            headers: options.headers,
+        });
+
+        return response.text();
+    }
 }
 
 export const stormClient = new StormClient();

package/src/storm/stream.ts

@@ -37,6 +37,7 @@ export class StormStream extends EventEmitter {
             this.emit('data', event);
         } catch (e: any) {
             this.emit('error', e);
+            console.warn('Failed to parse JSON line', e, line);
         }
     }
 
@@ -98,6 +99,7 @@ export interface ConversationItem {
 
 export interface StormContextRequest<T = string> {
     conversationId?: string;
+    history?: ConversationItem[];
     prompt: T;
 }