@kapeta/local-cluster-service 0.60.2 → 0.61.0

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

@@ -280,6 +280,7 @@ export interface Page {
     method: string;
     conversationId: string;
     prompt: string;
+    shellPage?: string;
 }
 export interface StormEventPage {
     type: 'PAGE';
@@ -323,5 +324,23 @@ export interface StormEventUserJourney {
     created: number;
     payload: UserJourney;
 }
-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 | StormEventPage | StormEventPageUrl;
+export interface UIShell {
+    name: string;
+    content: string;
+    screens: string[];
+}
+export interface StormEventUIShell {
+    type: 'UI_SHELL';
+    reason: string;
+    created: number;
+    payload: UIShell;
+}
+export interface StormEventPromptImprove {
+    type: 'PROMPT_IMPROVE';
+    reason: string;
+    payload: {
+        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 {};

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

@@ -110,24 +110,18 @@ router.post('/:handle/ui', async (req, res) => {
     try {
         const conversationId = req.headers[stormClient_1.ConversationIdHeader.toLowerCase()];
         const aiRequest = JSON.parse(req.stringBody ?? '{}');
+        // Get user journeys
         const userJourneysStream = await stormClient_1.stormClient.createUIUserJourneys(aiRequest.prompt, conversationId);
+        const outerConversationId = userJourneysStream.getConversationId();
         onRequestAborted(req, res, () => {
             userJourneysStream.abort();
         });
         res.set('Content-Type', 'application/x-ndjson');
         res.set('Access-Control-Expose-Headers', stormClient_1.ConversationIdHeader);
-        res.set(stormClient_1.ConversationIdHeader, userJourneysStream.getConversationId());
-        const promises = {};
-        const queue = new PromiseQueue_1.PromiseQueue(5);
-        onRequestAborted(req, res, () => {
-            queue.cancel();
-        });
-        const systemId = userJourneysStream.getConversationId();
-        UI_SERVERS[systemId] = new UIServer_1.UIServer(systemId);
-        await UI_SERVERS[systemId].start();
-        userJourneysStream.on('data', async (data) => {
+        res.set(stormClient_1.ConversationIdHeader, outerConversationId);
+        const uniqueUserJourneyScreens = {};
+        userJourneysStream.on('data', (data) => {
             try {
-                console.log('Processing user journey event', data);
                 sendEvent(res, data);
                 if (data.type !== 'USER_JOURNEY') {
                     return;
@@ -136,48 +130,109 @@ router.post('/:handle/ui', async (req, res) => {
                     return;
                 }
                 data.payload.screens.forEach((screen) => {
-                    if (screen.name in promises) {
-                        return;
+                    if (!uniqueUserJourneyScreens[screen.name]) {
+                        uniqueUserJourneyScreens[screen.name] = screen;
                     }
-                    promises[screen.name] = 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: userJourneysStream.getConversationId() + '_',
-                            }, innerConversationId);
-                            const promises = [];
-                            screenStream.on('data', (screenData) => {
-                                if (screenData.type === 'PAGE') {
-                                    screenData.payload.conversationId = innerConversationId;
-                                    promises.push(sendPageEvent(userJourneysStream.getConversationId(), screenData, res));
-                                }
-                                else {
-                                    sendEvent(res, screenData);
-                                }
-                            });
-                            screenStream.on('end', () => {
-                                Promise.allSettled(promises).finally(resolve);
-                            });
-                        }
-                        catch (e) {
-                            console.error('Failed to process screen', e);
-                            reject(e);
-                        }
-                    }));
                 });
             }
             catch (e) {
                 console.error('Failed to process event', e);
             }
         });
+        userJourneysStream.on('error', (error) => {
+            console.error('Error on userJourneysStream', error);
+            userJourneysStream.abort();
+            sendError(error, res);
+        });
         await waitForStormStream(userJourneysStream);
+        // Get the UI shells
+        const shellsStream = await stormClient_1.stormClient.createUIShells({
+            pages: Object.values(uniqueUserJourneyScreens).map((screen) => ({
+                name: screen.name,
+                title: screen.title,
+                filename: screen.filename,
+                path: screen.path,
+                method: screen.method,
+                requirements: screen.requirements,
+            })),
+        }, conversationId);
+        onRequestAborted(req, res, () => {
+            shellsStream.abort();
+        });
+        const uiShells = [];
+        shellsStream.on('data', (data) => {
+            console.log('Processing shell event', data);
+            sendEvent(res, data);
+            if (data.type !== 'UI_SHELL') {
+                return;
+            }
+            if (shellsStream.isAborted()) {
+                return;
+            }
+            uiShells.push(data.payload);
+        });
+        shellsStream.on('error', (error) => {
+            console.error('Error on shellsStream', error);
+            shellsStream.abort();
+            sendError(error, res);
+        });
+        await waitForStormStream(shellsStream);
+        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);
+        onRequestAborted(req, res, () => {
+            queue.cancel();
+        });
+        for (const screen of Object.values(uniqueUserJourneyScreens)) {
+            await 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);
+                }
+            }));
+        }
         await queue.wait();
         if (userJourneysStream.isAborted()) {
             return;

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

@@ -2,6 +2,16 @@ import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIIm
 import { Page, StormEventPageUrl } from './events';
 export declare const STORM_ID = "storm";
 export declare const ConversationIdHeader = "Conversation-Id";
+export interface UIShellsPrompt {
+    pages: {
+        name: string;
+        title: string;
+        filename: string;
+        path: string;
+        method: string;
+        requirements: string;
+    }[];
+}
 export interface UIPagePrompt {
     name: string;
     title: string;
@@ -11,6 +21,7 @@ export interface UIPagePrompt {
     method: string;
     description: string;
     storage_prefix: string;
+    shell_page?: string;
 }
 export interface UIPageEditPrompt {
     planDescription: string;
@@ -32,6 +43,7 @@ declare class StormClient {
     createMetadata(prompt: string, conversationId?: string): Promise<StormStream>;
     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>;
     editPages(prompt: UIPageEditPrompt, conversationId?: string): Promise<StormStream>;
     listScreens(prompt: StormUIListPrompt, conversationId?: string): Promise<StormStream>;

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

@@ -92,6 +92,12 @@ class StormClient {
             conversationId,
         });
     }
+    createUIShells(prompt, conversationId) {
+        return this.send('/v2/ui/shells', {
+            prompt: JSON.stringify(prompt),
+            conversationId,
+        });
+    }
     createUIPage(prompt, conversationId) {
         return this.send('/v2/ui/page', {
             prompt: prompt,

package/dist/esm/test/storm/duplicate-entities-events.json

@@ -0,0 +1,143 @@
+[
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Block updated",
+        "payload": {
+            "archetype": "",
+            "description": "Handles traffic from the backend services.",
+            "name": "api-gateway",
+            "resources": [
+                {
+                    "description": "",
+                    "name": "posts",
+                    "to": "post-service",
+                    "type": "CLIENT"
+                },
+                {
+                    "description": "",
+                    "name": "comments",
+                    "to": "comment-service",
+                    "type": "CLIENT"
+                }
+            ],
+            "type": "GATEWAY",
+            "blockRef": "kapeta://kapeta/api-gateway:local",
+            "instanceId": "6b247f30-dec4-5960-a8a0-f300caa95226"
+        },
+        "created": 1720784242064
+    },
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Block updated",
+        "payload": {
+            "archetype": "",
+            "description": "Manages the creation, editing, and deletion of blog posts.",
+            "name": "post-service",
+            "resources": [
+                {
+                    "description": "The posts API provides endpoints for managing blog posts. It includes functionality for creating, editing, and deleting posts, as well as retrieving and searching for posts. The API is designed to be secure and follows best practices for authentication and authorization.",
+                    "name": "posts",
+                    "type": "API"
+                }
+            ],
+            "type": "BACKEND",
+            "blockRef": "kapeta://kapeta/post-service:local",
+            "instanceId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26"
+        },
+        "created": 1720784243137
+    },
+    {
+        "type": "CREATE_BLOCK",
+        "reason": "Block updated",
+        "payload": {
+            "archetype": "",
+            "description": "Manages the creation, editing, and deletion of comments on blog posts.",
+            "name": "comment-service",
+            "resources": [
+                {
+                    "description": "The comments API provides endpoints for managing comments on blog posts. It includes functionality for creating, editing, and deleting comments, as well as retrieving and searching for comments. The API is designed to be secure and follows best practices for authentication and authorization.",
+                    "name": "comments",
+                    "type": "API"
+                }
+            ],
+            "type": "BACKEND",
+            "blockRef": "kapeta://kapeta/comment-service:local",
+            "instanceId": "d4215220-f552-5a6d-9429-bef1c40c4d7c"
+        },
+        "created": 1720784243141
+    },
+    {
+        "type": "CREATE_TYPE",
+        "reason": "Create type for post-service",
+        "payload": {
+            "blockName": "post-service",
+            "content": "enum Status {\n    NEW,\n    ARCHIVED\n}\n\ntype Result {\n    status: Status\n}\n\ntype User {\n   id: string\n}",
+            "blockRef": "kapeta://kapeta/post-service:local",
+            "instanceId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26"
+        },
+        "created": 1720784233286
+    },
+    {
+        "type": "CREATE_API",
+        "reason": "Create API for post-service",
+        "payload": {
+            "blockName": "post-service",
+            "content": "@GET(\"/status\")\ngetStatus(): Result",
+            "blockRef": "kapeta://kapeta/post-service:local",
+            "instanceId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26"
+        },
+        "created": 1720784233290
+    },
+    {
+        "type": "CREATE_TYPE",
+        "reason": "Create type for comment-service",
+        "payload": {
+            "blockName": "comment-service",
+            "content": "enum Status {\n    NEW,\n    APPROVED\n}\n\ntype Result {\n    status: Status\n}\n\ntype User {\n   id: string\n}",
+            "blockRef": "kapeta://kapeta/comment-service:local",
+            "instanceId": "d4215220-f552-5a6d-9429-bef1c40c4d7c"
+        },
+        "created": 1720784241000
+    },
+    {
+        "type": "CREATE_API",
+        "reason": "Create API for comment-service",
+        "payload": {
+            "blockName": "comment-service",
+            "content": "@GET(\"/status\")\ngetStatus(): Result",
+            "blockRef": "kapeta://kapeta/comment-service:local",
+            "instanceId": "d4215220-f552-5a6d-9429-bef1c40c4d7c"
+        },
+        "created": 1720784241002
+    },
+    {
+        "type": "CREATE_CONNECTION",
+        "reason": "api-gateway needs to be able to serve the posts API from the post-service",
+        "payload": {
+            "fromComponent": "post-service",
+            "fromResource": "posts",
+            "fromResourceType": "API",
+            "toComponent": "api-gateway",
+            "toResource": "posts",
+            "toResourceType": "CLIENT",
+            "fromBlockId": "4e002962-ca24-5b8b-bcea-395b9bbf7c26",
+            "toBlockId": "6b247f30-dec4-5960-a8a0-f300caa95226"
+        },
+        "created": 1720784243173
+    },
+    {
+        "type": "CREATE_CONNECTION",
+        "reason": "api-gateway needs to be able to serve the comments API from the comment-service",
+        "payload": {
+            "fromComponent": "comment-service",
+            "fromResource": "comments",
+            "fromResourceType": "API",
+            "toComponent": "api-gateway",
+            "toResource": "comments",
+            "toResourceType": "CLIENT",
+            "fromBlockId": "d4215220-f552-5a6d-9429-bef1c40c4d7c",
+            "toBlockId": "6b247f30-dec4-5960-a8a0-f300caa95226"
+        },
+        "created": 1720784243174
+    }
+]

package/dist/esm/test/storm/event-parser.test.js

@@ -12,6 +12,8 @@ const event_parser_1 = require("../../src/storm/event-parser");
 const simple_blog_events_json_1 = __importDefault(require("./simple-blog-events.json"));
 const predefined_user_events_json_1 = __importDefault(require("./predefined-user-events.json"));
 const blog_events_json_1 = __importDefault(require("./blog-events.json"));
+const duplicate_entities_events_json_1 = __importDefault(require("./duplicate-entities-events.json"));
+const kaplang_core_1 = require("@kapeta/kaplang-core");
 exports.parserOptions = {
     serviceKind: 'kapeta/block-service:local',
     serviceLanguage: 'kapeta/language-target-java-spring-boot:local',
@@ -217,4 +219,33 @@ describe('event-parser', () => {
         const safeName = event_parser_1.StormEventParser.toSafeArtifactName('Browser-based CRM Application');
         expect(safeName).toBe('browserbasedcrmapplication');
     });
+    it('rename duplicate entity names', async () => {
+        const events = duplicate_entities_events_json_1.default;
+        const parser = new event_parser_1.StormEventParser(exports.parserOptions);
+        for (const event of events) {
+            await parser.processEvent('kapeta', event);
+        }
+        const result = await parser.toResult('kapeta');
+        const apiGateway = result.blocks.find((block) => block.aiName === 'api-gateway');
+        expect(apiGateway).toBeDefined();
+        const dataTypes = kaplang_core_1.DSLDataTypeParser.parse(apiGateway.content.spec.entities.source.value, {
+            ignoreSemantics: true,
+        });
+        expect(dataTypes.map((type) => type.name)).toStrictEqual(['Status', 'Result', 'User', 'Status_1', 'Result_1']);
+        const conflictingType = dataTypes.find((type) => type.name === 'Result_1');
+        expect(conflictingType).toBeDefined();
+        const dataType = conflictingType;
+        expect(dataType.properties?.length).toBe(1);
+        const dslDataTypeProperty = dataType.properties[0];
+        expect(dslDataTypeProperty.type).toBe('Status_1');
+        const commentsClient = apiGateway?.content.spec.consumers?.find((resource) => resource.metadata.name === 'comments');
+        expect(commentsClient).toBeDefined();
+        const methods = kaplang_core_1.DSLAPIParser.parse(commentsClient.spec.source.value, {
+            ignoreSemantics: true,
+        });
+        expect(methods).toBeDefined();
+        expect(methods.length).toBe(1);
+        const method = methods[0];
+        expect(method.returnType).toBe('Result_1');
+    });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.60.2",
+    "version": "0.61.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {

package/src/storm/event-parser.ts

@@ -24,12 +24,16 @@ import {
 import { KapetaURI, normalizeKapetaUri, parseKapetaUri } from '@kapeta/nodejs-utils';
 import {
     DSLAPIParser,
+    DSLCompatibilityHelper,
     DSLController,
     DSLConverters,
+    DSLData,
     DSLDataTypeParser,
     DSLEntityType,
     DSLMethod,
     DSLParser,
+    DSLReferenceResolver,
+    DSLTypeHelper,
     KAPLANG_ID,
     KAPLANG_VERSION,
     KaplangWriter,
@@ -413,13 +417,11 @@ export class StormEventParser {
                     return;
                 }
 
-                const apiResource = apiProviderBlock.content.spec.providers?.find(
-                    (p) => {
-                        const pKind = normalizeKapetaUri(p.kind);
-                        const apiKind = normalizeKapetaUri(this.options.apiKind);
-                        return pKind === apiKind && p.metadata.name === apiConnection.fromResource
-                    }
-                );
+                const apiResource = apiProviderBlock.content.spec.providers?.find((p) => {
+                    const pKind = normalizeKapetaUri(p.kind);
+                    const apiKind = normalizeKapetaUri(this.options.apiKind);
+                    return pKind === apiKind && p.metadata.name === apiConnection.fromResource;
+                });
 
                 if (!apiResource) {
                     if (warn) {
@@ -454,6 +456,8 @@ export class StormEventParser {
                     return;
                 }
 
+                const renamedEntities: { [from: string]: string } = {};
+
                 if (apiProviderBlock.content.spec.entities?.source?.value) {
                     if (!clientConsumerBlock.content.spec.entities) {
                         clientConsumerBlock.content.spec.entities = {
@@ -473,19 +477,99 @@ export class StormEventParser {
                     const apiTypes = DSLDataTypeParser.parse(apiProviderBlock.content.spec.entities?.source?.value, {
                         ignoreSemantics: true,
                     });
+                    const newTypes: DSLData[] = [];
+
+                    const clientTypeExists = function (apiType: DSLData): boolean {
+                        const clientType = clientTypes.find((t) => t.name === apiType.name);
+                        return clientType != undefined;
+                    };
+
+                    const clientTypeIsCompatible = function (apiType: DSLData): boolean {
+                        const clientType = clientTypes.find((t) => t.name === apiType.name);
+                        return (
+                            clientType != undefined &&
+                            DSLCompatibilityHelper.isDataCompatible(apiType, clientType, apiTypes, clientTypes)
+                        );
+                    };
 
                     apiTypes.forEach((apiType) => {
-                        if (clientTypes.some((clientType) => clientType.name === apiType.name)) {
-                            // Already exists
+                        if (!clientTypeExists(apiType)) {
+                            newTypes.push(apiType);
                             return;
                         }
-                        clientTypes.push(apiType);
+
+                        if (clientTypeIsCompatible(apiType)) {
+                            return;
+                        }
+
+                        const originalName = apiType.name;
+                        const toEntity = _.cloneDeep(apiType);
+                        let conflictCount = 1;
+
+                        while (clientTypeExists(toEntity) && !clientTypeIsCompatible(toEntity)) {
+                            toEntity.name = `${originalName}_${conflictCount}`;
+                            conflictCount++;
+                        }
+
+                        newTypes.push(toEntity);
+                        renamedEntities[originalName] = toEntity.name;
+                    });
+
+                    Object.entries(renamedEntities).forEach(([from, to]) => {
+                        newTypes.forEach((newType) => {
+                            if (newType.type !== DSLEntityType.DATATYPE) {
+                                return;
+                            }
+
+                            if (!newType.properties) {
+                                return;
+                            }
+
+                            newType.properties.forEach((property) => {
+                                const type = DSLTypeHelper.asType(property.type);
+
+                                if (from !== type.name) {
+                                    return;
+                                }
+
+                                type.name = to;
+                                property.type = type;
+                            });
+                        });
                     });
 
-                    clientConsumerBlock.content.spec.entities.source!.value = KaplangWriter.write(clientTypes);
+                    clientConsumerBlock.content.spec.entities.source!.value = KaplangWriter.write([
+                        ...clientTypes,
+                        ...newTypes,
+                    ]);
                 }
+
                 clientResource.spec.methods = apiResource.spec.methods;
-                clientResource.spec.source = apiResource.spec.source;
+
+                if (Object.keys(renamedEntities).length == 0) {
+                    clientResource.spec.source = apiResource.spec.source;
+                } else {
+                    // entities were renamed - rename references as well
+                    const targetSource = _.cloneDeep(apiResource.spec.source);
+                    const methods = DSLAPIParser.parse(targetSource.value, {
+                        ignoreSemantics: true,
+                    });
+
+                    const resolver = new DSLReferenceResolver();
+                    resolver.visitReferences(methods, (name) => {
+                        const type = DSLTypeHelper.asType(name);
+
+                        if (renamedEntities[type.name]) {
+                            type.name = renamedEntities[type.name];
+                            return type;
+                        }
+
+                        return name;
+                    });
+
+                    targetSource.value = KaplangWriter.write(methods);
+                    clientResource.spec.source = targetSource;
+                }
             });
 
         const connections: Connection[] = this.connections.map((connection) => {
@@ -802,13 +886,11 @@ export class StormEventParser {
             return;
         }
 
-        const apiResource = apiProviderBlock.content.spec.providers?.find(
-            (p) => {
-                const pKind = normalizeKapetaUri(p.kind);
-                const apiKind = normalizeKapetaUri(this.options.apiKind);
-                return pKind === apiKind && p.metadata.name === connection.fromResource
-            }
-            );
+        const apiResource = apiProviderBlock.content.spec.providers?.find((p) => {
+            const pKind = normalizeKapetaUri(p.kind);
+            const apiKind = normalizeKapetaUri(this.options.apiKind);
+            return pKind === apiKind && p.metadata.name === connection.fromResource;
+        });
 
         if (!apiResource) {
             if (warn) {

package/src/storm/events.ts

@@ -332,6 +332,7 @@ export interface Page {
     method: string;
     conversationId: string;
     prompt: string;
+    shellPage?: string;
 }
 
 // Event for creating a page
@@ -384,6 +385,27 @@ export interface StormEventUserJourney {
     payload: UserJourney;
 }
 
+export interface UIShell {
+    name: string;
+    content: string;
+    screens: string[];
+}
+
+export interface StormEventUIShell {
+    type: 'UI_SHELL';
+    reason: string;
+    created: number;
+    payload: UIShell;
+}
+
+export interface StormEventPromptImprove {
+    type: 'PROMPT_IMPROVE';
+    reason: string;
+    payload: {
+        prompt: string;
+    };
+}
+
 export type StormEvent =
     | StormEventCreateBlock
     | StormEventCreateConnection
@@ -410,5 +432,7 @@ export type StormEvent =
     | StormEventBlockStatus
     | StormEventCreateDSLRetry
     | StormEventUserJourney
+    | StormEventUIShell
     | StormEventPage
-    | StormEventPageUrl;
+    | StormEventPageUrl
+    | StormEventPromptImprove;