@kapeta/local-cluster-service 0.54.0 → 0.54.2

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [0.54.2](https://github.com/kapetacom/local-cluster-service/compare/v0.54.1...v0.54.2) (2024-06-19)
+
+
+### Bug Fixes
+
+* handle error events to/from screen AIs ([#181](https://github.com/kapetacom/local-cluster-service/issues/181)) ([6cfd9d4](https://github.com/kapetacom/local-cluster-service/commit/6cfd9d48d221ba3c3b16c8514a7d19d6e4ffd805))
+
+## [0.54.1](https://github.com/kapetacom/local-cluster-service/compare/v0.54.0...v0.54.1) (2024-06-19)
+
+
+### Bug Fixes
+
+* handle screen events by adding a meta-file to context + routes ([#180](https://github.com/kapetacom/local-cluster-service/issues/180)) ([69d67f8](https://github.com/kapetacom/local-cluster-service/commit/69d67f84fd7a373d49f5c20ff9057d8b2baa620a))
+
 # [0.54.0](https://github.com/kapetacom/local-cluster-service/compare/v0.53.5...v0.54.0) (2024-06-17)
 
 

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

@@ -151,6 +151,9 @@ class StormCodegen {
                 break;
             case 'FILE_DONE':
                 return this.handleFileDoneOutput(blockUri, blockName, data);
+            default:
+                console.warn('Unknown event type', data);
+                break;
         }
     }
     handleFileEvents(blockUri, blockName, data) {
@@ -242,7 +245,6 @@ class StormCodegen {
             file.type !== codegen_1.AIFileTypes.WEB_SCREEN &&
             file.type !== codegen_1.AIFileTypes.WEB_ROUTER);
         const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
-        const webRouters = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_ROUTER);
         const screenFiles = [];
         let filteredEvents = [];
         for (const event of this.events) {
@@ -251,66 +253,71 @@ class StormCodegen {
                 filteredEvents = [];
             }
         }
+        const failedEvents = filteredEvents.filter((event) => event.type.endsWith('_FAILED'));
+        if (failedEvents.length > 0) {
+            console.warn('Codegen encountered failed plan events. Plan might be invalid', failedEvents);
+        }
+        // Skip failed events - they are not relevant to the materializer
+        // TODO: should the materializer be able to handle failed events?
+        filteredEvents = filteredEvents.filter((event) => !event.type.endsWith('_FAILED') && !event.type.endsWith('ERROR_INTERNAL'));
         const screenEvents = [];
-        // generate screens
-        const screenStream = await stormClient_1.stormClient.listScreens({
-            events: filteredEvents,
-            templates: uiTemplates,
-            context: relevantFiles,
-            blockName: block.aiName,
-            prompt: this.userPrompt,
+        const getScreenEventsFile = () => ({
+            content: JSON.stringify(screenEvents),
+            filename: '<screens>.json',
+            type: codegen_1.AIFileTypes.CONFIG,
+            mode: codegen_1.MODE_WRITE_NEVER,
+            permissions: '0644',
         });
-        screenStream.on('data', (evt) => {
-            if (evt.type === 'SCREEN') {
-                screenEvents.push(evt);
-            }
-            this.handleUiOutput(blockUri, block.aiName, evt);
-        });
-        this.out.on('aborted', () => {
-            screenStream.abort();
-        });
-        await screenStream.waitForDone();
-        // screenfiles
-        const screenTemplates = screenEvents
-            .map((screenEvent) => ({
-            ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
-            filename: screenEvent.payload.filename,
-        }))
-            .filter((tpl) => !!tpl.content);
-        await Promise.all(screenTemplates.concat(webRouters).map(async (template) => {
-            const payload = {
+        const uiEvents = [];
+        // generate screens
+        if (uiTemplates.length) {
+            const screenStream = await stormClient_1.stormClient.listScreens({
                 events: filteredEvents,
+                templates: uiTemplates,
+                context: relevantFiles,
                 blockName: block.aiName,
-                filename: template.filename,
-                template: template,
-                context: relevantFiles.concat([
-                    {
-                        type: codegen_1.AIFileTypes.INSTRUCTIONS,
-                        mode: codegen_1.MODE_CREATE_ONLY,
-                        permissions: '0644',
-                        filename: '<screens>.md',
-                        content: `
-# Generated screens
-
-${JSON.stringify({ screenEvents })}
-
-`,
-                    },
-                ]),
                 prompt: this.userPrompt,
-            };
-            const uiStream = await stormClient_1.stormClient.createUIImplementation(payload);
-            uiStream.on('data', (evt) => {
-                const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
-                if (uiFile != undefined) {
-                    screenFiles.push(uiFile);
+            });
+            screenStream.on('data', (evt) => {
+                if (evt.type === 'SCREEN') {
+                    screenEvents.push(evt);
                 }
+                this.handleUiOutput(blockUri, block.aiName, evt);
             });
             this.out.on('aborted', () => {
-                uiStream.abort();
+                screenStream.abort();
             });
-            await uiStream.waitForDone();
-        }));
+            await screenStream.waitForDone();
+            // screenfiles
+            const screenTemplates = screenEvents
+                .map((screenEvent) => ({
+                ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
+                filename: screenEvent.payload.filename,
+            }))
+                .filter((tpl) => !!tpl.content);
+            await Promise.all(screenTemplates.map(async (template) => {
+                const payload = {
+                    events: filteredEvents,
+                    blockName: block.aiName,
+                    filename: template.filename,
+                    template: template,
+                    context: relevantFiles.concat([getScreenEventsFile()]),
+                    prompt: this.userPrompt,
+                };
+                const uiStream = await stormClient_1.stormClient.createUIImplementation(payload);
+                uiStream.on('data', (evt) => {
+                    const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
+                    if (uiFile != undefined) {
+                        screenFiles.push(uiFile);
+                    }
+                    uiEvents.push(evt);
+                });
+                this.out.on('aborted', () => {
+                    uiStream.abort();
+                });
+                await uiStream.waitForDone();
+            }));
+        }
         if (this.isAborted()) {
             return;
         }
@@ -324,6 +331,24 @@ ${JSON.stringify({ screenEvents })}
                 type: codegen_1.AIFileTypes.WEB_SCREEN,
             };
         });
+        allFiles.push(...screenFilesConverted);
+        const webRouters = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_ROUTER);
+        await Promise.all(webRouters.map(async (webRouter) => {
+            const payload = {
+                filename: webRouter.filename,
+                template: webRouter,
+                context: screenFilesConverted.concat([getScreenEventsFile()]),
+                prompt: this.userPrompt,
+            };
+            const stream = await stormClient_1.stormClient.generateCode(payload);
+            stream.on('data', (evt) => {
+                this.handleTemplateFileOutput(blockUri, block.aiName, webRouter, evt);
+            });
+            this.out.on('aborted', () => {
+                stream.abort();
+            });
+            await stream.waitForDone();
+        }));
         // Gather the context files for implementation. These will be all be passed to the AI
         const contextFiles = relevantFiles.filter((file) => ![codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN, codegen_1.AIFileTypes.WEB_ROUTER].includes(file.type));
         // Send the service and UI templates to the AI. These will be sent one-by-one in addition to the context files
@@ -346,12 +371,13 @@ ${JSON.stringify({ screenEvents })}
             const filePath = (0, path_2.join)(basePath, serviceFile.filename);
             await (0, promises_1.writeFile)(filePath, serviceFile.content);
         }
+        // Write again after modifications
+        for (const webRouterFile of webRouters) {
+            const filePath = (0, path_2.join)(basePath, webRouterFile.filename);
+            await (0, promises_1.writeFile)(filePath, webRouterFile.content);
+        }
         const kapetaYmlPath = (0, path_2.join)(basePath, 'kapeta.yml');
         await (0, promises_1.writeFile)(kapetaYmlPath, yaml_1.default.stringify(block.content));
-        for (const screenFile of screenFiles) {
-            const filePath = (0, path_2.join)(basePath, screenFile.payload.filename);
-            await (0, promises_1.writeFile)(filePath, screenFile.payload.content);
-        }
         const blockRef = block.uri;
         this.emitBlockStatus(blockUri, block.aiName, events_1.StormEventBlockStatusType.QA);
         const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);

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

@@ -13,6 +13,7 @@ declare class StormClient {
     createErrorClassification(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
     createCodeFix(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
     createErrorDetails(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
+    generateCode(prompt: StormFileImplementationPrompt, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
 }
 export declare const stormClient: StormClient;
 export {};

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

@@ -116,5 +116,11 @@ class StormClient {
             prompt,
         });
     }
+    generateCode(prompt, history, conversationId) {
+        return this.send('/v2/code/generate', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
 }
 exports.stormClient = new StormClient();

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

@@ -151,6 +151,9 @@ class StormCodegen {
                 break;
             case 'FILE_DONE':
                 return this.handleFileDoneOutput(blockUri, blockName, data);
+            default:
+                console.warn('Unknown event type', data);
+                break;
         }
     }
     handleFileEvents(blockUri, blockName, data) {
@@ -242,7 +245,6 @@ class StormCodegen {
             file.type !== codegen_1.AIFileTypes.WEB_SCREEN &&
             file.type !== codegen_1.AIFileTypes.WEB_ROUTER);
         const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
-        const webRouters = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_ROUTER);
         const screenFiles = [];
         let filteredEvents = [];
         for (const event of this.events) {
@@ -251,66 +253,71 @@ class StormCodegen {
                 filteredEvents = [];
             }
         }
+        const failedEvents = filteredEvents.filter((event) => event.type.endsWith('_FAILED'));
+        if (failedEvents.length > 0) {
+            console.warn('Codegen encountered failed plan events. Plan might be invalid', failedEvents);
+        }
+        // Skip failed events - they are not relevant to the materializer
+        // TODO: should the materializer be able to handle failed events?
+        filteredEvents = filteredEvents.filter((event) => !event.type.endsWith('_FAILED') && !event.type.endsWith('ERROR_INTERNAL'));
         const screenEvents = [];
-        // generate screens
-        const screenStream = await stormClient_1.stormClient.listScreens({
-            events: filteredEvents,
-            templates: uiTemplates,
-            context: relevantFiles,
-            blockName: block.aiName,
-            prompt: this.userPrompt,
+        const getScreenEventsFile = () => ({
+            content: JSON.stringify(screenEvents),
+            filename: '<screens>.json',
+            type: codegen_1.AIFileTypes.CONFIG,
+            mode: codegen_1.MODE_WRITE_NEVER,
+            permissions: '0644',
         });
-        screenStream.on('data', (evt) => {
-            if (evt.type === 'SCREEN') {
-                screenEvents.push(evt);
-            }
-            this.handleUiOutput(blockUri, block.aiName, evt);
-        });
-        this.out.on('aborted', () => {
-            screenStream.abort();
-        });
-        await screenStream.waitForDone();
-        // screenfiles
-        const screenTemplates = screenEvents
-            .map((screenEvent) => ({
-            ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
-            filename: screenEvent.payload.filename,
-        }))
-            .filter((tpl) => !!tpl.content);
-        await Promise.all(screenTemplates.concat(webRouters).map(async (template) => {
-            const payload = {
+        const uiEvents = [];
+        // generate screens
+        if (uiTemplates.length) {
+            const screenStream = await stormClient_1.stormClient.listScreens({
                 events: filteredEvents,
+                templates: uiTemplates,
+                context: relevantFiles,
                 blockName: block.aiName,
-                filename: template.filename,
-                template: template,
-                context: relevantFiles.concat([
-                    {
-                        type: codegen_1.AIFileTypes.INSTRUCTIONS,
-                        mode: codegen_1.MODE_CREATE_ONLY,
-                        permissions: '0644',
-                        filename: '<screens>.md',
-                        content: `
-# Generated screens
-
-${JSON.stringify({ screenEvents })}
-
-`,
-                    },
-                ]),
                 prompt: this.userPrompt,
-            };
-            const uiStream = await stormClient_1.stormClient.createUIImplementation(payload);
-            uiStream.on('data', (evt) => {
-                const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
-                if (uiFile != undefined) {
-                    screenFiles.push(uiFile);
+            });
+            screenStream.on('data', (evt) => {
+                if (evt.type === 'SCREEN') {
+                    screenEvents.push(evt);
                 }
+                this.handleUiOutput(blockUri, block.aiName, evt);
             });
             this.out.on('aborted', () => {
-                uiStream.abort();
+                screenStream.abort();
             });
-            await uiStream.waitForDone();
-        }));
+            await screenStream.waitForDone();
+            // screenfiles
+            const screenTemplates = screenEvents
+                .map((screenEvent) => ({
+                ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
+                filename: screenEvent.payload.filename,
+            }))
+                .filter((tpl) => !!tpl.content);
+            await Promise.all(screenTemplates.map(async (template) => {
+                const payload = {
+                    events: filteredEvents,
+                    blockName: block.aiName,
+                    filename: template.filename,
+                    template: template,
+                    context: relevantFiles.concat([getScreenEventsFile()]),
+                    prompt: this.userPrompt,
+                };
+                const uiStream = await stormClient_1.stormClient.createUIImplementation(payload);
+                uiStream.on('data', (evt) => {
+                    const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
+                    if (uiFile != undefined) {
+                        screenFiles.push(uiFile);
+                    }
+                    uiEvents.push(evt);
+                });
+                this.out.on('aborted', () => {
+                    uiStream.abort();
+                });
+                await uiStream.waitForDone();
+            }));
+        }
         if (this.isAborted()) {
             return;
         }
@@ -324,6 +331,24 @@ ${JSON.stringify({ screenEvents })}
                 type: codegen_1.AIFileTypes.WEB_SCREEN,
             };
         });
+        allFiles.push(...screenFilesConverted);
+        const webRouters = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_ROUTER);
+        await Promise.all(webRouters.map(async (webRouter) => {
+            const payload = {
+                filename: webRouter.filename,
+                template: webRouter,
+                context: screenFilesConverted.concat([getScreenEventsFile()]),
+                prompt: this.userPrompt,
+            };
+            const stream = await stormClient_1.stormClient.generateCode(payload);
+            stream.on('data', (evt) => {
+                this.handleTemplateFileOutput(blockUri, block.aiName, webRouter, evt);
+            });
+            this.out.on('aborted', () => {
+                stream.abort();
+            });
+            await stream.waitForDone();
+        }));
         // Gather the context files for implementation. These will be all be passed to the AI
         const contextFiles = relevantFiles.filter((file) => ![codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN, codegen_1.AIFileTypes.WEB_ROUTER].includes(file.type));
         // Send the service and UI templates to the AI. These will be sent one-by-one in addition to the context files
@@ -346,12 +371,13 @@ ${JSON.stringify({ screenEvents })}
             const filePath = (0, path_2.join)(basePath, serviceFile.filename);
             await (0, promises_1.writeFile)(filePath, serviceFile.content);
         }
+        // Write again after modifications
+        for (const webRouterFile of webRouters) {
+            const filePath = (0, path_2.join)(basePath, webRouterFile.filename);
+            await (0, promises_1.writeFile)(filePath, webRouterFile.content);
+        }
         const kapetaYmlPath = (0, path_2.join)(basePath, 'kapeta.yml');
         await (0, promises_1.writeFile)(kapetaYmlPath, yaml_1.default.stringify(block.content));
-        for (const screenFile of screenFiles) {
-            const filePath = (0, path_2.join)(basePath, screenFile.payload.filename);
-            await (0, promises_1.writeFile)(filePath, screenFile.payload.content);
-        }
         const blockRef = block.uri;
         this.emitBlockStatus(blockUri, block.aiName, events_1.StormEventBlockStatusType.QA);
         const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);

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

@@ -13,6 +13,7 @@ declare class StormClient {
     createErrorClassification(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
     createCodeFix(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
     createErrorDetails(prompt: string, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
+    generateCode(prompt: StormFileImplementationPrompt, history?: ConversationItem[], conversationId?: string): Promise<StormStream>;
 }
 export declare const stormClient: StormClient;
 export {};

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

@@ -116,5 +116,11 @@ class StormClient {
             prompt,
         });
     }
+    generateCode(prompt, history, conversationId) {
+        return this.send('/v2/code/generate', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
 }
 exports.stormClient = new StormClient();

package/package.json

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

package/src/storm/codegen.ts

@@ -12,6 +12,7 @@ import {
     GeneratedFile,
     GeneratedResult,
     MODE_CREATE_ONLY,
+    MODE_WRITE_NEVER,
 } from '@kapeta/codegen';
 
 import { BlockDefinition } from '@kapeta/schemas';
@@ -173,6 +174,9 @@ export class StormCodegen {
                 break;
             case 'FILE_DONE':
                 return this.handleFileDoneOutput(blockUri, blockName, data);
+            default:
+                console.warn('Unknown event type', data);
+                break;
         }
     }
 
@@ -277,8 +281,8 @@ export class StormCodegen {
                 file.type !== AIFileTypes.WEB_ROUTER
         );
         const uiTemplates = allFiles.filter((file) => file.type === AIFileTypes.WEB_SCREEN);
-        const webRouters = allFiles.filter((file) => file.type === AIFileTypes.WEB_ROUTER);
         const screenFiles: StormEventFileDone[] = [];
+
         let filteredEvents = [] as StormEvent[];
         for (const event of this.events) {
             filteredEvents.push(event);
@@ -287,76 +291,85 @@ export class StormCodegen {
             }
         }
 
-        const screenEvents: StormEventScreen[] = [];
-        // generate screens
-        const screenStream = await stormClient.listScreens({
-            events: filteredEvents,
-            templates: uiTemplates,
-            context: relevantFiles,
-            blockName: block.aiName,
-            prompt: this.userPrompt,
-        });
-        screenStream.on('data', (evt) => {
-            if (evt.type === 'SCREEN') {
-                screenEvents.push(evt);
-            }
-            this.handleUiOutput(blockUri, block.aiName, evt);
-        });
+        const failedEvents = filteredEvents.filter((event) => event.type.endsWith('_FAILED'));
+        if (failedEvents.length > 0) {
+            console.warn('Codegen encountered failed plan events. Plan might be invalid', failedEvents);
+        }
+        // Skip failed events - they are not relevant to the materializer
+        // TODO: should the materializer be able to handle failed events?
+        filteredEvents = filteredEvents.filter(
+            (event) => !event.type.endsWith('_FAILED') && !event.type.endsWith('ERROR_INTERNAL')
+        );
 
-        this.out.on('aborted', () => {
-            screenStream.abort();
+        const screenEvents: StormEventScreen[] = [];
+        const getScreenEventsFile = () => ({
+            content: JSON.stringify(screenEvents),
+            filename: '<screens>.json',
+            type: AIFileTypes.CONFIG,
+            mode: MODE_WRITE_NEVER,
+            permissions: '0644',
         });
+        const uiEvents = [];
 
-        await screenStream.waitForDone();
-
-        // screenfiles
-        const screenTemplates = screenEvents
-            .map((screenEvent) => ({
-                ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
-                filename: screenEvent.payload.filename,
-            }))
-            .filter((tpl): tpl is StormFileInfo => !!tpl.content);
-
-        await Promise.all(
-            screenTemplates.concat(webRouters).map(async (template) => {
-                const payload = {
-                    events: filteredEvents,
-                    blockName: block.aiName,
-                    filename: template.filename,
-                    template: template,
-                    context: relevantFiles.concat([
-                        {
-                            type: AIFileTypes.INSTRUCTIONS,
-                            mode: MODE_CREATE_ONLY,
-                            permissions: '0644',
-                            filename: '<screens>.md',
-                            content: `
-# Generated screens
-
-${JSON.stringify({ screenEvents })}
-
-`,
-                        },
-                    ]),
-                    prompt: this.userPrompt,
-                };
-
-                const uiStream = await stormClient.createUIImplementation(payload);
-
-                uiStream.on('data', (evt) => {
-                    const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
-                    if (uiFile != undefined) {
-                        screenFiles.push(uiFile);
-                    }
-                });
+        // generate screens
+        if (uiTemplates.length) {
+            const screenStream = await stormClient.listScreens({
+                events: filteredEvents,
+                templates: uiTemplates,
+                context: relevantFiles,
+                blockName: block.aiName,
+                prompt: this.userPrompt,
+            });
+            screenStream.on('data', (evt) => {
+                if (evt.type === 'SCREEN') {
+                    screenEvents.push(evt);
+                }
+                this.handleUiOutput(blockUri, block.aiName, evt);
+            });
 
-                this.out.on('aborted', () => {
-                    uiStream.abort();
-                });
+            this.out.on('aborted', () => {
+                screenStream.abort();
+            });
 
-                await uiStream.waitForDone();
-            })
-        );
+            await screenStream.waitForDone();
+
+            // screenfiles
+            const screenTemplates = screenEvents
+                .map((screenEvent) => ({
+                    ...uiTemplates.find((template) => template.filename.endsWith(screenEvent.payload.template)),
+                    filename: screenEvent.payload.filename,
+                }))
+                .filter((tpl): tpl is StormFileInfo => !!tpl.content);
+
+            await Promise.all(
+                screenTemplates.map(async (template) => {
+                    const payload = {
+                        events: filteredEvents,
+                        blockName: block.aiName,
+                        filename: template.filename,
+                        template: template,
+                        context: relevantFiles.concat([getScreenEventsFile()]),
+                        prompt: this.userPrompt,
+                    };
+
+                    const uiStream = await stormClient.createUIImplementation(payload);
+
+                    uiStream.on('data', (evt) => {
+                        const uiFile = this.handleUiOutput(blockUri, block.aiName, evt);
+                        if (uiFile != undefined) {
+                            screenFiles.push(uiFile);
+                        }
+                        uiEvents.push(evt);
+                    });
+
+                    this.out.on('aborted', () => {
+                        uiStream.abort();
+                    });
+
+                    await uiStream.waitForDone();
+                })
+            );
+        }
 
         if (this.isAborted()) {
             return;
@@ -372,6 +385,31 @@ ${JSON.stringify({ screenEvents })}
                 type: AIFileTypes.WEB_SCREEN,
             };
         });
+        allFiles.push(...screenFilesConverted);
+
+        const webRouters = allFiles.filter((file) => file.type === AIFileTypes.WEB_ROUTER);
+        await Promise.all(
+            webRouters.map(async (webRouter) => {
+                const payload = {
+                    filename: webRouter.filename,
+                    template: webRouter,
+                    context: screenFilesConverted.concat([getScreenEventsFile()]),
+                    prompt: this.userPrompt,
+                };
+
+                const stream = await stormClient.generateCode(payload);
+
+                stream.on('data', (evt) => {
+                    this.handleTemplateFileOutput(blockUri, block.aiName, webRouter, evt);
+                });
+
+                this.out.on('aborted', () => {
+                    stream.abort();
+                });
+
+                await stream.waitForDone();
+            })
+        );
 
         // Gather the context files for implementation. These will be all be passed to the AI
         const contextFiles: StormFileInfo[] = relevantFiles.filter(
@@ -409,20 +447,21 @@ ${JSON.stringify({ screenEvents })}
             await writeFile(filePath, serviceFile.content);
         }
 
-        const kapetaYmlPath = join(basePath, 'kapeta.yml');
-        await writeFile(kapetaYmlPath, YAML.stringify(block.content as BlockDefinition));
-
-        for (const screenFile of screenFiles) {
-            const filePath = join(basePath, screenFile.payload.filename);
-            await writeFile(filePath, screenFile.payload.content);
+        // Write again after modifications
+        for (const webRouterFile of webRouters) {
+            const filePath = join(basePath, webRouterFile.filename);
+            await writeFile(filePath, webRouterFile.content);
         }
 
+        const kapetaYmlPath = join(basePath, 'kapeta.yml');
+        await writeFile(kapetaYmlPath, YAML.stringify(block.content));
+
         const blockRef = block.uri;
 
         this.emitBlockStatus(blockUri, block.aiName, StormEventBlockStatusType.QA);
 
         const filesToBeFixed = serviceFiles.concat(contextFiles).concat(screenFilesConverted);
-        const codeGenerator = new BlockCodeGenerator(block.content as BlockDefinition);
+        const codeGenerator = new BlockCodeGenerator(block.content);
 
         this.emitBlockStatus(blockUri, block.aiName, StormEventBlockStatusType.BUILDING);
         await this.verifyAndFixCode(blockUri, block.aiName, codeGenerator, basePath, filesToBeFixed, allFiles);
@@ -881,6 +920,7 @@ ${JSON.stringify({ screenEvents })}
                 type,
             };
         });
+
         return allFiles;
     }
 

package/src/storm/stormClient.ts

@@ -154,6 +154,13 @@ class StormClient {
             prompt,
         });
     }
+
+    public generateCode(prompt: StormFileImplementationPrompt, history?: ConversationItem[], conversationId?: string) {
+        return this.send('/v2/code/generate', {
+            conversationId: conversationId,
+            prompt,
+        });
+    }
 }
 
 export const stormClient = new StormClient();