@kapeta/local-cluster-service 0.61.1 → 0.62.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.62.0](https://github.com/kapetacom/local-cluster-service/compare/v0.61.2...v0.62.0) (2024-08-13)
+
+
+### Features
+
+* Add iterative reference resolving ([#215](https://github.com/kapetacom/local-cluster-service/issues/215)) ([8bf5e23](https://github.com/kapetacom/local-cluster-service/commit/8bf5e23ce36031ca10df6c407a8a3e73a3e1ac46))
+
+## [0.61.2](https://github.com/kapetacom/local-cluster-service/compare/v0.61.1...v0.61.2) (2024-08-13)
+
+
+### Bug Fixes
+
+* silence codegen internal errors for demo purposes ([3892ed3](https://github.com/kapetacom/local-cluster-service/commit/3892ed3817a73c5ac4564dcad05f50ffd86d221f))
+
 ## [0.61.1](https://github.com/kapetacom/local-cluster-service/compare/v0.61.0...v0.61.1) (2024-08-09)
 
 

package/dist/cjs/src/storm/PageGenerator.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+/// <reference types="node" />
+import { UIPagePrompt } from './stormClient';
+import { ReferenceClassification, StormEvent, StormEventPage } from './events';
+import { EventEmitter } from 'node:events';
+export declare class PageQueue extends EventEmitter {
+    private readonly queue;
+    private readonly systemId;
+    private readonly references;
+    constructor(systemId: string, concurrency?: number);
+    on(event: 'event', listener: (data: StormEvent) => void): this;
+    on(event: 'page', listener: (data: StormEventPage) => void): this;
+    emit(type: 'event', event: StormEvent): boolean;
+    emit(type: 'page', event: StormEventPage): boolean;
+    addPrompt(initialPrompt: UIPagePrompt): Promise<void>;
+    private addPageGenerator;
+    cancel(): void;
+    wait(): Promise<void>;
+}
+export declare class PageGenerator extends EventEmitter {
+    private readonly conversationId;
+    private prompt;
+    constructor(prompt: UIPagePrompt, conversationId?: string);
+    on(event: 'event', listener: (data: StormEvent) => void): this;
+    on(event: 'page_refs', listener: (data: {
+        event: StormEventPage;
+        references: ReferenceClassification[];
+    }) => void): this;
+    emit(type: 'event', event: StormEvent): boolean;
+    emit(type: 'page_refs', event: {
+        event: StormEventPage;
+        references: ReferenceClassification[];
+    }): boolean;
+    generate(): Promise<void>;
+    private resolveReferences;
+}

package/dist/cjs/src/storm/PageGenerator.js

@@ -0,0 +1,143 @@
+"use strict";
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PageGenerator = exports.PageQueue = void 0;
+const node_uuid_1 = __importDefault(require("node-uuid"));
+const stormClient_1 = require("./stormClient");
+const node_events_1 = require("node:events");
+const PromiseQueue_1 = require("./PromiseQueue");
+class PageQueue extends node_events_1.EventEmitter {
+    queue;
+    systemId;
+    references = new Map();
+    constructor(systemId, concurrency = 5) {
+        super();
+        this.systemId = systemId;
+        this.queue = new PromiseQueue_1.PromiseQueue(concurrency);
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    addPrompt(initialPrompt) {
+        if (this.references.has(initialPrompt.path)) {
+            console.log('Ignoring duplicate prompt', initialPrompt.path);
+            return Promise.resolve();
+        }
+        console.log('processing prompt', initialPrompt.path);
+        const generator = new PageGenerator(initialPrompt);
+        this.references.set(initialPrompt.path, generator);
+        return this.addPageGenerator(generator);
+    }
+    async addPageGenerator(generator) {
+        generator.on('event', (event) => this.emit('event', event));
+        generator.on('page_refs', ({ event, references }) => {
+            this.emit('page', event);
+            references.forEach((reference) => {
+                if (reference.url.startsWith('#') ||
+                    reference.url.startsWith('javascript:') ||
+                    reference.url.startsWith('http://') ||
+                    reference.url.startsWith('https://')) {
+                    return;
+                }
+                switch (reference.type) {
+                    case 'image':
+                        console.log('Ignoring image reference', reference);
+                        break;
+                    case 'css':
+                    case 'javascript':
+                        //console.log('Ignoring reference', reference);
+                        break;
+                    case 'html':
+                        console.log('Adding page generator for', reference);
+                        const paths = Array.from(this.references.keys());
+                        this.addPrompt({
+                            name: reference.name,
+                            title: reference.title,
+                            path: reference.url,
+                            method: 'GET',
+                            storage_prefix: this.systemId + '_',
+                            prompt: `Implement a page for ${reference.name} at ${reference.url} with the following description: ${reference.description}.\n` +
+                                `The page was referenced from this page: \`\`\`html\n${event.payload.content}\n\`\`\`\n` +
+                                (paths.length > 0
+                                    ? `\nThese paths are already implemented:\n- ${paths.join('\n - ')}\n\n`
+                                    : ''),
+                            description: reference.description,
+                            filename: '',
+                        });
+                        break;
+                }
+            });
+        });
+        return this.queue.add(() => generator.generate());
+    }
+    cancel() {
+        this.queue.cancel();
+    }
+    wait() {
+        return this.queue.wait();
+    }
+}
+exports.PageQueue = PageQueue;
+class PageGenerator extends node_events_1.EventEmitter {
+    conversationId;
+    prompt;
+    constructor(prompt, conversationId = node_uuid_1.default.v4()) {
+        super();
+        this.conversationId = conversationId;
+        this.prompt = prompt;
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    async generate() {
+        return new Promise(async (resolve) => {
+            const screenStream = await stormClient_1.stormClient.createUIPage(this.prompt, this.conversationId);
+            const promises = [];
+            screenStream.on('data', (event) => {
+                if (event.type === 'PAGE') {
+                    event.payload.conversationId = this.conversationId;
+                    promises.push((async () => {
+                        const references = await this.resolveReferences(event.payload.content);
+                        //console.log('Resolved references for page', references, event.payload);
+                        this.emit('page_refs', {
+                            event,
+                            references,
+                        });
+                    })());
+                    return;
+                }
+                this.emit('event', event);
+            });
+            screenStream.on('end', () => {
+                Promise.allSettled(promises).finally(resolve);
+            });
+            await screenStream.waitForDone();
+        });
+    }
+    async resolveReferences(content) {
+        const referenceStream = await stormClient_1.stormClient.classifyUIReferences(content);
+        const references = [];
+        referenceStream.on('data', (referenceData) => {
+            if (referenceData.type !== 'REF_CLASSIFICATION') {
+                return;
+            }
+            //console.log('Processing reference classification', referenceData);
+            references.push(referenceData.payload);
+        });
+        await referenceStream.waitForDone();
+        return references;
+    }
+}
+exports.PageGenerator = PageGenerator;

package/dist/cjs/src/storm/events.d.ts

@@ -342,5 +342,34 @@ export interface StormEventPromptImprove {
         prompt: string;
     };
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFileLogical | StormEventFileState | StormEventFileDone | StormEventFileFailed | StormEventFileChunk | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventErrorDetails | StormEventBlockReady | StormEventPhases | StormEventBlockStatus | StormEventCreateDSLRetry | StormEventUserJourney | StormEventUIShell | StormEventPage | StormEventPageUrl | StormEventPromptImprove;
+export interface LandingPage {
+    name: string;
+    title: string;
+    filename: string;
+    create_prompt: string;
+    path: string;
+    archetype: string;
+    requires_authentication: boolean;
+}
+export interface StormEventLandingPage {
+    type: 'LANDING_PAGE';
+    reason: string;
+    created: number;
+    payload: LandingPage;
+}
+export interface ReferenceClassification {
+    name: string;
+    title: string;
+    url: string;
+    description: string;
+    type: 'image' | 'css' | 'javascript' | 'html';
+    source: 'local' | 'cdn' | 'example';
+}
+export interface StormEventReferenceClassification {
+    type: 'REF_CLASSIFICATION';
+    reason: string;
+    created: number;
+    payload: ReferenceClassification;
+}
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventCreateDSLResource | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFileLogical | StormEventFileState | StormEventFileDone | StormEventFileFailed | StormEventFileChunk | StormEventDone | StormEventDefinitionChange | StormEventErrorClassifier | StormEventCodeFix | StormEventErrorDetails | StormEventBlockReady | StormEventPhases | StormEventBlockStatus | StormEventCreateDSLRetry | StormEventUserJourney | StormEventUIShell | StormEventPage | StormEventPageUrl | StormEventPromptImprove | StormEventLandingPage | StormEventReferenceClassification;
 export {};

package/dist/cjs/src/storm/page-utils.d.ts

@@ -4,9 +4,19 @@
  */
 import { StormEventPage } from './events';
 import { Response } from 'express';
+import { ConversationItem } from './stream';
 export declare const SystemIdHeader = "System-Id";
 export declare function writePageToDisk(systemId: string, event: StormEventPage): Promise<{
     path: string;
 }>;
+export declare function resolveReadPath(systemId: string, path: string, method: string): string | null;
 export declare function readPageFromDiskAsString(systemId: string, path: string, method: string): string | null;
 export declare function readPageFromDisk(systemId: string, path: string, method: string, res: Response): void;
+export interface Conversation {
+    messages: ConversationItem[];
+    variantId: string;
+    type: 'page';
+    filename: string;
+}
+export declare function readConversationFromFile(filename: string): Conversation[];
+export declare function writeConversationToFile(filename: string, conversations: Conversation[]): void;

package/dist/cjs/src/storm/page-utils.js

@@ -3,13 +3,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.readPageFromDisk = exports.readPageFromDiskAsString = exports.writePageToDisk = exports.SystemIdHeader = void 0;
+exports.writeConversationToFile = exports.readConversationFromFile = exports.readPageFromDisk = exports.readPageFromDiskAsString = exports.resolveReadPath = exports.writePageToDisk = exports.SystemIdHeader = void 0;
 const node_os_1 = __importDefault(require("node:os"));
 const path_1 = __importDefault(require("path"));
 const fs_extra_1 = __importDefault(require("fs-extra"));
 exports.SystemIdHeader = 'System-Id';
+function normalizePath(path) {
+    return path
+        .replace(/\?.*$/gi, '')
+        .replace(/:[a-z][a-z_]*\b/gi, '*')
+        .replace(/\{[a-z]+}/gi, '*');
+}
 async function writePageToDisk(systemId, event) {
-    const path = path_1.default.join(node_os_1.default.tmpdir(), 'ai-systems', systemId, event.payload.path, event.payload.method.toLowerCase(), 'index.html');
+    const baseDir = getBaseDir(systemId);
+    const filePath = getFilePath(event.payload.method);
+    const path = path_1.default.join(baseDir, normalizePath(event.payload.path), filePath);
     await fs_extra_1.default.ensureDir(path_1.default.dirname(path));
     await fs_extra_1.default.writeFile(path, event.payload.content);
     console.log(`Page written to disk: ${event.payload.title} > ${path}`);
@@ -18,17 +26,53 @@ async function writePageToDisk(systemId, event) {
     };
 }
 exports.writePageToDisk = writePageToDisk;
+function getBaseDir(systemId) {
+    return path_1.default.join(node_os_1.default.tmpdir(), 'ai-systems', systemId);
+}
+function getFilePath(method) {
+    return path_1.default.join(method.toLowerCase(), 'index.html');
+}
+function resolveReadPath(systemId, path, method) {
+    const baseDir = getBaseDir(systemId);
+    path = normalizePath(path);
+    const filePath = getFilePath(method);
+    const fullPath = path_1.default.join(baseDir, path, filePath);
+    if (fs_extra_1.default.existsSync(fullPath)) {
+        return fullPath;
+    }
+    const parts = path.split(/\*/g);
+    let currentPath = '';
+    for (let part in parts) {
+        const thisPath = path_1.default.join(currentPath, part);
+        const starPath = path_1.default.join(currentPath, '*');
+        const thisPathDir = path_1.default.join(baseDir, thisPath);
+        const starPathDir = path_1.default.join(baseDir, starPath);
+        if (fs_extra_1.default.existsSync(thisPathDir)) {
+            currentPath = thisPath;
+            continue;
+        }
+        if (fs_extra_1.default.existsSync(starPathDir)) {
+            currentPath = starPath;
+            continue;
+        }
+        console.log('Path not found', thisPathDir, starPathDir);
+        // Path not found
+        return null;
+    }
+    return path_1.default.join(baseDir, currentPath, filePath);
+}
+exports.resolveReadPath = resolveReadPath;
 function readPageFromDiskAsString(systemId, path, method) {
-    const filePath = path_1.default.join(node_os_1.default.tmpdir(), 'ai-systems', systemId, path, method.toLowerCase(), 'index.html');
-    if (!fs_extra_1.default.existsSync(filePath)) {
+    const filePath = resolveReadPath(systemId, path, method);
+    if (!filePath || !fs_extra_1.default.existsSync(filePath)) {
         return null;
     }
     return fs_extra_1.default.readFileSync(filePath, 'utf8');
 }
 exports.readPageFromDiskAsString = readPageFromDiskAsString;
 function readPageFromDisk(systemId, path, method, res) {
-    const filePath = path_1.default.join(node_os_1.default.tmpdir(), 'ai-systems', systemId, path, method.toLowerCase(), 'index.html');
-    if (!fs_extra_1.default.existsSync(filePath)) {
+    const filePath = resolveReadPath(systemId, path, method);
+    if (!filePath || !fs_extra_1.default.existsSync(filePath)) {
         res.status(404).send('Page not found');
         return;
     }
@@ -38,3 +82,18 @@ function readPageFromDisk(systemId, path, method, res) {
     res.end();
 }
 exports.readPageFromDisk = readPageFromDisk;
+function readConversationFromFile(filename) {
+    if (!fs_extra_1.default.existsSync(filename)) {
+        return [];
+    }
+    const content = fs_extra_1.default.readFileSync(filename).toString();
+    if (!content.trim()) {
+        return [];
+    }
+    return content.split(/\n/g).map((line) => JSON.parse(line));
+}
+exports.readConversationFromFile = readConversationFromFile;
+function writeConversationToFile(filename, conversations) {
+    fs_extra_1.default.writeFileSync(filename, conversations.map((conversation) => JSON.stringify(conversation)).join('\n'));
+}
+exports.writeConversationToFile = writeConversationToFile;

package/dist/cjs/src/storm/routes.js

@@ -19,13 +19,14 @@ const event_parser_1 = require("./event-parser");
 const codegen_1 = require("./codegen");
 const assetManager_1 = require("../assetManager");
 const node_uuid_1 = __importDefault(require("node-uuid"));
-const PromiseQueue_1 = require("./PromiseQueue");
 const page_utils_1 = require("./page-utils");
 const UIServer_1 = require("./UIServer");
+const PageGenerator_1 = require("./PageGenerator");
 const UI_SERVERS = {};
 const router = (0, express_promise_router_1.default)();
 router.use('/', cors_1.corsHandler);
 router.use('/', stringBody_1.stringBody);
+const samplesBaseDir = path_1.default.join(__dirname, 'samples');
 function convertPageEvent(screenData, innerConversationId, mainConversationId) {
     if (screenData.type === 'PAGE') {
         const server = UI_SERVERS[mainConversationId];
@@ -62,19 +63,20 @@ router.post('/ui/screen', async (req, res) => {
         const systemId = req.headers[page_utils_1.SystemIdHeader.toLowerCase()];
         const aiRequest = JSON.parse(req.stringBody ?? '{}');
         aiRequest.storage_prefix = systemId ? systemId + '_' : 'mock_';
-        const screenStream = await stormClient_1.stormClient.createUIPage(aiRequest, conversationId);
-        onRequestAborted(req, res, () => {
-            screenStream.abort();
-        });
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
-        res.set(stormClient_1.ConversationIdHeader, screenStream.getConversationId());
+        res.set(stormClient_1.ConversationIdHeader, conversationId);
+        const parentConversationId = systemId ?? '';
+        const queue = new PageGenerator_1.PageQueue(parentConversationId, 5);
+        onRequestAborted(req, res, () => {
+            queue.cancel();
+        });
+        await queue.addPrompt(aiRequest);
         const promises = [];
-        screenStream.on('data', (data) => {
+        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));
                     }
@@ -82,7 +84,7 @@ router.post('/ui/screen', async (req, res) => {
             }
             sendEvent(res, data);
         });
-        await waitForStormStream(screenStream);
+        await queue.wait();
         await Promise.allSettled(promises);
         sendDone(res);
     }
@@ -105,6 +107,78 @@ router.delete('/:handle/ui', async (req, res) => {
         delete UI_SERVERS[conversationId];
     }
 });
+router.post('/:handle/ui/iterative', async (req, res) => {
+    const handle = req.params.handle;
+    try {
+        const conversationId = req.headers[stormClient_1.ConversationIdHeader.toLowerCase()];
+        const aiRequest = JSON.parse(req.stringBody ?? '{}');
+        const landingPagesStream = await stormClient_1.stormClient.createUILandingPages(aiRequest.prompt, conversationId);
+        onRequestAborted(req, res, () => {
+            landingPagesStream.abort();
+        });
+        res.set('Content-Type', 'application/x-ndjson');
+        res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
+        res.set(stormClient_1.ConversationIdHeader, landingPagesStream.getConversationId());
+        const promises = {};
+        const pageEventPromises = [];
+        const systemId = landingPagesStream.getConversationId();
+        const pageQueue = new PageGenerator_1.PageQueue(systemId, 5);
+        landingPagesStream.on('data', async (data) => {
+            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_1.UIServer(systemId);
+        await UI_SERVERS[systemId].start();
+        onRequestAborted(req, res, () => {
+            pageQueue.cancel();
+        });
+        pageQueue.on('page', (screenData) => {
+            pageEventPromises.push(sendPageEvent(landingPagesStream.getConversationId(), screenData, res));
+        });
+        pageQueue.on('event', (screenData) => {
+            sendEvent(res, screenData);
+        });
+        await waitForStormStream(landingPagesStream);
+        await pageQueue.wait();
+        await Promise.allSettled(pageEventPromises);
+        if (landingPagesStream.isAborted()) {
+            return;
+        }
+        sendDone(res);
+    }
+    catch (err) {
+        sendError(err, res);
+        if (!res.closed) {
+            res.end();
+        }
+    }
+});
 router.post('/:handle/ui', async (req, res) => {
     const handle = req.params.handle;
     try {
@@ -180,60 +254,34 @@ router.post('/:handle/ui', async (req, res) => {
         UI_SERVERS[outerConversationId] = new UIServer_1.UIServer(outerConversationId);
         await UI_SERVERS[outerConversationId].start();
         // Get the pages (5 at a time)
-        const queue = new PromiseQueue_1.PromiseQueue(5);
+        const queue = new PageGenerator_1.PageQueue(outerConversationId, 5);
+        const pagePromises = [];
         onRequestAborted(req, res, () => {
             queue.cancel();
         });
+        const pageEventPromises = [];
+        queue.on('page', (screenData) => {
+            pageEventPromises.push(sendPageEvent(outerConversationId, screenData, res));
+        });
+        queue.on('event', (screenData) => {
+            sendEvent(res, screenData);
+        });
         for (const screen of Object.values(uniqueUserJourneyScreens)) {
-            void queue.add(() => new Promise(async (resolve, reject) => {
-                try {
-                    const innerConversationId = node_uuid_1.default.v4();
-                    const screenStream = await stormClient_1.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 = [];
-                    screenStream.on('data', (screenData) => {
-                        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;
         }
@@ -484,6 +532,12 @@ function waitForStormStream(result) {
 function streamStormPartialResponse(result, res) {
     return new Promise((resolve) => {
         result.on('data', (data) => {
+            switch (data.type) {
+                // todo: temporarily (for demo purposes) disable error messages when codegen fails
+                case 'ERROR_INTERNAL':
+                    console.log("Error internal", data);
+                    return;
+            }
             sendEvent(res, data);
         });
         resolve(result.waitForDone());

package/dist/cjs/src/storm/stormClient.d.ts

@@ -23,6 +23,9 @@ export interface UIPagePrompt {
     storage_prefix: string;
     shell_page?: string;
 }
+export interface UIPageSamplePrompt extends UIPagePrompt {
+    variantId: string;
+}
 export interface UIPageEditPrompt {
     planDescription: string;
     blockDescription: string;
@@ -44,7 +47,9 @@ declare class StormClient {
     createUIPages(prompt: string, conversationId?: string): Promise<StormStream>;
     createUIUserJourneys(prompt: string, conversationId?: string): Promise<StormStream>;
     createUIShells(prompt: UIShellsPrompt, conversationId?: string): Promise<StormStream>;
-    createUIPage(prompt: UIPagePrompt, conversationId?: string): Promise<StormStream>;
+    createUILandingPages(prompt: string, conversationId?: string): Promise<StormStream>;
+    createUIPage(prompt: UIPagePrompt, conversationId?: string, history?: ConversationItem[]): Promise<StormStream>;
+    classifyUIReferences(prompt: string, conversationId?: string): Promise<StormStream>;
     editPages(prompt: UIPageEditPrompt, conversationId?: string): Promise<StormStream>;
     listScreens(prompt: StormUIListPrompt, conversationId?: string): Promise<StormStream>;
     createUIImplementation(prompt: StormUIImplementationPrompt, conversationId?: string): Promise<StormStream>;
@@ -53,6 +58,7 @@ declare class StormClient {
     createCodeFix(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
     createErrorDetails(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
     generateCode(prompt: StormFileImplementationPrompt, conversationId?: string): Promise<StormStream>;
+    deleteUIPageConversation(conversationId: string): Promise<string>;
 }
 export declare const stormClient: StormClient;
 export {};

package/dist/cjs/src/storm/stormClient.js

@@ -95,13 +95,25 @@ class StormClient {
     createUIShells(prompt, conversationId) {
         return this.send('/v2/ui/shells', {
             prompt: JSON.stringify(prompt),
+        });
+    }
+    createUILandingPages(prompt, conversationId) {
+        return this.send('/v2/ui/landing-pages', {
+            prompt: prompt,
             conversationId,
         });
     }
-    createUIPage(prompt, conversationId) {
+    createUIPage(prompt, conversationId, history) {
         return this.send('/v2/ui/page', {
             prompt: prompt,
             conversationId,
+            history,
+        });
+    }
+    classifyUIReferences(prompt, conversationId) {
+        return this.send('/v2/ui/references', {
+            prompt: prompt,
+            conversationId,
         });
     }
     editPages(prompt, conversationId) {
@@ -152,5 +164,16 @@ class StormClient {
             conversationId: conversationId,
         });
     }
+    async deleteUIPageConversation(conversationId) {
+        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();
+    }
 }
 exports.stormClient = new StormClient();

package/dist/cjs/src/storm/stream.d.ts

@@ -35,6 +35,7 @@ export interface ConversationItem {
 }
 export interface StormContextRequest<T = string> {
     conversationId?: string;
+    history?: ConversationItem[];
     prompt: T;
 }
 export interface StormCreateBlockRequest {