@kapeta/local-cluster-service 0.45.0 → 0.47.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+# [0.47.0](https://github.com/kapetacom/local-cluster-service/compare/v0.46.0...v0.47.0) (2024-05-29)
+
+
+### Features
+
+* Added tests for event parsing and layouting of nodes ([#149](https://github.com/kapetacom/local-cluster-service/issues/149)) ([d36afa9](https://github.com/kapetacom/local-cluster-service/commit/d36afa905d0c66c4562b4eccf07c067efe6b3c9c))
+
+# [0.46.0](https://github.com/kapetacom/local-cluster-service/compare/v0.45.0...v0.46.0) (2024-05-28)
+
+
+### Features
+
+* Change how the UI AI work to get templates from codegen ([#148](https://github.com/kapetacom/local-cluster-service/issues/148)) ([f757ec8](https://github.com/kapetacom/local-cluster-service/commit/f757ec8e4fab0dbb58b96a1b9e25f3e734ddb10f))
+
 # [0.45.0](https://github.com/kapetacom/local-cluster-service/compare/v0.44.0...v0.45.0) (2024-05-24)
 
 

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

@@ -2,15 +2,19 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { StormEvent } from './events';
 import { BlockDefinitionInfo } from './event-parser';
 import { StormStream } from './stream';
 export declare class StormCodegen {
     private readonly userPrompt;
     private readonly blocks;
     private readonly out;
-    constructor(userPrompt: string, blocks: BlockDefinitionInfo[]);
+    private readonly events;
+    constructor(userPrompt: string, blocks: BlockDefinitionInfo[], events: StormEvent[]);
     process(): Promise<void>;
     getStream(): StormStream;
+    private handleTemplateFileOutput;
+    private handleUiOutput;
     private handleFileOutput;
     /**
      * Generates the code for a block and sends it to the AI

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

@@ -13,12 +13,13 @@ class StormCodegen {
     userPrompt;
     blocks;
     out = new stream_1.StormStream();
-    constructor(userPrompt, blocks) {
+    events;
+    constructor(userPrompt, blocks, events) {
         this.userPrompt = userPrompt;
         this.blocks = blocks;
+        this.events = events;
     }
     async process() {
-        console.log('Processing blocks', this.blocks.length);
         for (const block of this.blocks) {
             await this.processBlockCode(block);
         }
@@ -27,13 +28,42 @@ class StormCodegen {
     getStream() {
         return this.out;
     }
-    handleFileOutput(blockUri, template, data) {
+    handleTemplateFileOutput(blockUri, template, data) {
         switch (data.type) {
             case 'FILE':
                 template.filename = data.payload.filename;
                 template.content = data.payload.content;
+                return this.handleFileOutput(blockUri, data);
+        }
+    }
+    handleUiOutput(blockUri, data) {
+        switch (data.type) {
+            case 'SCREEN':
+                this.out.emit('data', {
+                    type: 'SCREEN',
+                    reason: data.reason,
+                    created: Date.now(),
+                    payload: {
+                        ...data.payload,
+                        blockName: blockUri.toNormalizedString(),
+                    },
+                });
+            case 'FILE':
+                return this.handleFileOutput(blockUri, data);
+        }
+    }
+    handleFileOutput(blockUri, data) {
+        switch (data.type) {
+            case 'FILE':
                 this.emitFile(blockUri, data.payload.filename, data.payload.content, data.reason);
-                break;
+                return {
+                    type: 'FILE',
+                    created: Date.now(),
+                    payload: {
+                        filename: data.payload.filename,
+                        content: data.payload.content,
+                    },
+                };
         }
     }
     /**
@@ -41,22 +71,35 @@ class StormCodegen {
      */
     async processBlockCode(block) {
         // Generate the code for the block using the standard codegen templates
-        const generatedResult = await this.generateBlock(block.content, block.screens);
+        const generatedResult = await this.generateBlock(block.content);
         if (!generatedResult) {
-            console.warn('No generated result for block', block.uri);
             return;
         }
         const allFiles = this.toStormFiles(generatedResult);
         // Send all the non-ai files to the stream
         this.emitFiles(block.uri, allFiles);
-        const implementFiles = [codegen_1.AIFileTypes.SERVICE, codegen_1.AIFileTypes.WEB_SCREEN];
-        // Gather the context files. These will be all be passed to the AI
-        const contextFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && !implementFiles.includes(file.type));
+        const relevantFiles = allFiles.filter((file) => file.type !== codegen_1.AIFileTypes.IGNORE && file.type !== codegen_1.AIFileTypes.WEB_SCREEN);
+        const uiTemplates = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.WEB_SCREEN);
+        if (uiTemplates.length > 0) {
+            const uiStream = await stormClient_1.stormClient.createUIImplementation({
+                events: this.events,
+                templates: uiTemplates,
+                context: relevantFiles,
+                blockName: block.aiName,
+                prompt: this.userPrompt,
+            });
+            uiStream.on('data', (evt) => {
+                this.handleUiOutput(block.uri, evt);
+            });
+            await uiStream.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].includes(file.type));
         // Send the service and UI templates to the AI. These will be send one-by-one in addition to the context files
         const serviceFiles = allFiles.filter((file) => file.type === codegen_1.AIFileTypes.SERVICE);
-        await this.processTemplates(block.uri, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
-        //const uiTemplates: StormFileInfo[] = allFiles.filter((file) => file.type === 'ui');
-        //await this.processTemplates(stormClient.createUIImplementation, uiTemplates, contextFiles);
+        if (serviceFiles.length > 0) {
+            await this.processTemplates(block.uri, stormClient_1.stormClient.createServiceImplementation.bind(stormClient_1.stormClient), serviceFiles, contextFiles);
+        }
     }
     /**
      * Emits the text-based files to the stream
@@ -94,17 +137,25 @@ class StormCodegen {
     /**
      * Sends the template to the AI and processes the response
      */
-    processTemplates(blockUri, generator, templates, contextFiles) {
+    async processTemplates(blockUri, generator, templates, contextFiles) {
         const promises = templates.map(async (templateFile) => {
             const stream = await generator({
                 context: contextFiles,
                 template: templateFile,
                 prompt: this.userPrompt,
             });
-            stream.on('data', (evt) => this.handleFileOutput(blockUri, templateFile, evt));
-            return stream.waitForDone();
+            const files = [];
+            stream.on('data', (evt) => {
+                const file = this.handleTemplateFileOutput(blockUri, templateFile, evt);
+                if (file) {
+                    files.push(file);
+                }
+            });
+            await stream.waitForDone();
+            return files;
         });
-        return Promise.all(promises);
+        const fileChunks = await Promise.all(promises);
+        return fileChunks.flat();
     }
     /**
      * Converts the generated files to a format that can be sent to the AI
@@ -143,7 +194,7 @@ class StormCodegen {
     /**
      * Generates the code using codegen for a given block.
      */
-    async generateBlock(yamlContent, screens) {
+    async generateBlock(yamlContent) {
         if (!yamlContent.spec.target?.kind) {
             //Not all block types have targets
             return;
@@ -153,7 +204,6 @@ class StormCodegen {
         }
         const codeGenerator = new codegen_1.BlockCodeGenerator(yamlContent);
         codeGenerator.withOption('AIContext', stormClient_1.STORM_ID);
-        codeGenerator.withOption('AIScreens', screens ?? []);
         return codeGenerator.generate();
     }
 }

package/dist/cjs/src/storm/event-parser.d.ts

@@ -2,15 +2,15 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
-import { ScreenTemplate, StormEvent } from './events';
+import { StormEvent } from './events';
 import { BlockDefinition, Plan } from '@kapeta/schemas';
 import { KapetaURI } from '@kapeta/nodejs-utils';
 export interface BlockDefinitionInfo {
     uri: KapetaURI;
     content: BlockDefinition;
-    screens: ScreenTemplate[];
+    aiName: string;
 }
-export interface ParsedResult {
+export interface StormDefinitions {
     plan: Plan;
     blocks: BlockDefinitionInfo[];
 }
@@ -51,12 +51,12 @@ export declare class StormEventParser {
     private options;
     constructor(options: StormOptions);
     private reset;
-    addEvent(evt: StormEvent): void;
+    addEvent(handle: string, evt: StormEvent): StormDefinitions;
     getEvents(): StormEvent[];
     isValid(): boolean;
     getError(): string;
     private applyLayoutToBlocks;
-    toResult(handle: string): ParsedResult;
+    toResult(handle: string): StormDefinitions;
     private toSafeName;
     private toRef;
     toBlockDefinitions(handle: string): {

package/dist/cjs/src/storm/event-parser.js

@@ -12,6 +12,8 @@ const nodejs_utils_1 = require("@kapeta/nodejs-utils");
 const kaplang_core_1 = require("@kapeta/kaplang-core");
 const node_uuid_1 = __importDefault(require("node-uuid"));
 const definitionsManager_1 = require("../definitionsManager");
+const ngraph_graph_1 = __importDefault(require("ngraph.graph"));
+const ngraph_forcelayout_1 = __importDefault(require("ngraph.forcelayout"));
 async function resolveOptions() {
     // Predefined types for now - TODO: Allow user to select / change
     const blockTypeService = await definitionsManager_1.definitionsManager.getLatestDefinition('kapeta/block-type-service');
@@ -87,6 +89,7 @@ async function resolveOptions() {
     };
 }
 exports.resolveOptions = resolveOptions;
+const LAYOUT_MARGIN = 50;
 class StormEventParser {
     events = [];
     planName = '';
@@ -105,8 +108,7 @@ class StormEventParser {
         this.blocks = {};
         this.connections = [];
     }
-    addEvent(evt) {
-        console.log('Processing storm event', evt);
+    addEvent(handle, evt) {
         this.events.push(evt);
         switch (evt.type) {
             case 'CREATE_PLAN_PROPERTIES':
@@ -119,7 +121,6 @@ class StormEventParser {
                     apis: [],
                     models: [],
                     types: [],
-                    screens: [],
                 };
                 break;
             case 'PLAN_RETRY':
@@ -141,20 +142,12 @@ class StormEventParser {
             case 'CREATE_CONNECTION':
                 this.connections.push(evt.payload);
                 break;
-            case 'SCREEN':
-                this.blocks[evt.payload.blockName].screens.push({
-                    name: evt.payload.name,
-                    description: evt.payload.description,
-                    url: evt.payload.url,
-                    template: evt.payload.template,
-                });
-                break;
             default:
             case 'SCREEN_CANDIDATE':
             case 'FILE':
-                console.warn('Unhandled event: %s', evt.type, evt);
                 break;
         }
+        return this.toResult(handle);
     }
     getEvents() {
         return this.events;
@@ -166,13 +159,47 @@ class StormEventParser {
         return this.error;
     }
     applyLayoutToBlocks(result) {
+        const graph = (0, ngraph_graph_1.default)();
+        const blockInstances = {};
+        result.plan.spec.blocks.forEach((block, index) => {
+            graph.addNode(block.id, block);
+            blockInstances[block.id] = block;
+        });
+        result.plan.spec.connections.forEach((connection) => {
+            graph.addLink(connection.provider.blockId, connection.consumer.blockId);
+        });
+        const layout = (0, ngraph_forcelayout_1.default)(graph, {
+            springLength: 150,
+            debug: true,
+            dimensions: 2,
+            gravity: 2,
+            springCoefficient: 0.0008,
+        });
+        for (let i = 0; i < 100; ++i) {
+            layout.step();
+        }
+        // Layout might place things in negative space. We move everything to positive space
+        const graphBox = layout.getGraphRect();
+        let yAdjust = 0;
+        let xAdjust = 0;
+        if (graphBox.y1 < 0) {
+            yAdjust = -graphBox.y1;
+        }
+        if (graphBox.x1 < 0) {
+            xAdjust = -graphBox.x1;
+        }
+        graph.forEachNode((node) => {
+            const position = layout.getNodePosition(node.id);
+            blockInstances[node.id].dimensions.left = LAYOUT_MARGIN + Math.round(position.x + xAdjust);
+            blockInstances[node.id].dimensions.top = LAYOUT_MARGIN + Math.round(position.y + yAdjust);
+        });
+        layout.dispose();
         return result;
     }
     toResult(handle) {
         const planRef = this.toRef(handle, this.planName);
         const blockDefinitions = this.toBlockDefinitions(handle);
         const refIdMap = {};
-        const screens = {};
         const blocks = Object.entries(blockDefinitions).map(([ref, block]) => {
             const id = node_uuid_1.default.v4();
             refIdMap[ref] = id;
@@ -185,20 +212,11 @@ class StormEventParser {
                 dimensions: {
                     left: 0,
                     top: 0,
-                    width: 200,
+                    width: 150,
                     height: 200,
                 },
             };
         });
-        Object.values(this.blocks).forEach((blockInfo) => {
-            const blockRef = this.toRef(handle, blockInfo.name);
-            const block = blockDefinitions[blockRef.toNormalizedString()];
-            if (!block) {
-                console.warn('Block not found: %s', blockInfo.name);
-                return;
-            }
-            screens[blockRef.fullName] = blockInfo.screens;
-        });
         // Copy API methods from API provider to CLIENT consumer
         this.connections
             .filter((connection) => connection.fromResourceType === 'API' && connection.toResourceType === 'CLIENT')
@@ -207,29 +225,28 @@ class StormEventParser {
             const clientConsumerRef = this.toRef(handle, apiConnection.toComponent);
             const apiProviderBlock = blockDefinitions[apiProviderRef.toNormalizedString()];
             if (!apiProviderBlock) {
-                console.warn('API provider not found: %s', apiConnection.fromComponent);
+                console.warn('API provider not found: %s', apiConnection.fromComponent, apiConnection);
                 return;
             }
             const clientConsumerBlock = blockDefinitions[clientConsumerRef.toNormalizedString()];
             if (!clientConsumerBlock) {
-                console.warn('Client consumer not found: %s', apiConnection.toComponent);
+                console.warn('Client consumer not found: %s', apiConnection.toComponent, apiConnection);
                 return;
             }
             const apiResource = apiProviderBlock.content.spec.providers?.find((p) => p.kind === this.options.apiKind && p.metadata.name === apiConnection.fromResource);
             if (!apiResource) {
-                console.warn('API resource not found: %s on %s', apiConnection.fromResource, apiProviderRef.toNormalizedString());
+                console.warn('API resource not found: %s on %s', apiConnection.fromResource, apiProviderRef.toNormalizedString(), apiConnection);
                 return;
             }
             const clientResource = clientConsumerBlock.content.spec.consumers?.find((clientResource) => {
                 if (clientResource.kind !== this.options.clientKind) {
-                    return;
-                }
-                if (clientResource.metadata.name !== apiConnection.toResource) {
-                    return;
+                    console.warn('Client resource kind mismatch: %s', clientResource.kind, this.options.clientKind);
+                    return false;
                 }
+                return clientResource.metadata.name === apiConnection.toResource;
             });
             if (!clientResource) {
-                console.warn('Client resource not found: %s on %s', apiConnection.toResource, clientConsumerRef.toNormalizedString());
+                console.warn('Client resource not found: %s on %s', apiConnection.toResource, clientConsumerRef.toNormalizedString(), apiConnection);
                 return;
             }
             clientResource.spec.methods = apiResource.spec.methods;
@@ -284,6 +301,7 @@ class StormEventParser {
             const blockRef = this.toRef(handle, blockInfo.name);
             const blockDefinitionInfo = {
                 uri: blockRef,
+                aiName: blockInfo.name,
                 content: {
                     kind: this.toBlockKind(blockInfo.type),
                     metadata: {
@@ -305,7 +323,6 @@ class StormEventParser {
                         consumers: [],
                     },
                 },
-                screens: blockInfo.screens,
             };
             const blockSpec = blockDefinitionInfo.content.spec;
             let apiResource = undefined;
@@ -398,7 +415,7 @@ class StormEventParser {
                                 },
                             },
                         };
-                        blockSpec.providers.push(dbResource);
+                        blockSpec.consumers.push(dbResource);
                         break;
                     case 'JWTCONSUMER':
                     case 'WEBFRAGMENT':

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

@@ -2,6 +2,7 @@
  * Copyright 2023 Kapeta Inc.
  * SPDX-License-Identifier: BUSL-1.1
  */
+import { StormDefinitions } from "./event-parser";
 export type StormResourceType = 'API' | 'DATABASE' | 'CLIENT' | 'JWTPROVIDER' | 'JWTCONSUMER' | 'WEBFRAGMENT' | 'WEBPAGE' | 'SMTPCLIENT' | 'EXTERNAL_API' | 'SUBSCRIBER' | 'PUBLISHER' | 'QUEUE' | 'EXCHANGE';
 export type StormBlockType = 'BACKEND' | 'FRONTEND' | 'GATEWAY' | 'MQ' | 'CLI' | 'DESKTOP';
 export interface StormBlockInfo {
@@ -18,7 +19,6 @@ export interface StormBlockInfoFilled extends StormBlockInfo {
     apis: string[];
     types: string[];
     models: string[];
-    screens: ScreenTemplate[];
 }
 export interface StormEventCreateBlock {
     type: 'CREATE_BLOCK';
@@ -124,4 +124,10 @@ export interface StormEventDone {
     type: 'DONE';
     created: number;
 }
-export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone;
+export interface StormEventDefinitionChange {
+    type: 'DEFINITION_CHANGE';
+    reason: string;
+    created: number;
+    payload: StormDefinitions;
+}
+export type StormEvent = StormEventCreateBlock | StormEventCreateConnection | StormEventCreatePlanProperties | StormEventInvalidResponse | StormEventPlanRetry | StormEventCreateDSL | StormEventError | StormEventScreen | StormEventScreenCandidate | StormEventFile | StormEventDone | StormEventDefinitionChange;

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

@@ -1,6 +1,2 @@
 "use strict";
-/**
- * Copyright 2023 Kapeta Inc.
- * SPDX-License-Identifier: BUSL-1.1
- */
 Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -21,17 +21,17 @@ router.post('/:handle/all', async (req, res) => {
     try {
         const stormOptions = await (0, event_parser_1.resolveOptions)();
         const eventParser = new event_parser_1.StormEventParser(stormOptions);
-        console.log('Got prompt', req.stringBody);
         const aiRequest = JSON.parse(req.stringBody ?? '{}');
         const metaStream = await stormClient_1.stormClient.createMetadata(aiRequest.prompt, aiRequest.history);
         res.set('Content-Type', 'application/x-ndjson');
         metaStream.on('data', (data) => {
-            eventParser.addEvent(data);
+            const result = eventParser.addEvent(req.params.handle, data);
+            sendDefinitions(res, result);
         });
         await streamStormPartialResponse(metaStream, res);
         if (!eventParser.isValid()) {
             // We can't continue if the meta stream is invalid
-            res.write({
+            sendEvent(res, {
                 type: 'ERROR_INTERNAL',
                 payload: { error: eventParser.getError() },
                 reason: 'Failed to generate system',
@@ -41,8 +41,8 @@ router.post('/:handle/all', async (req, res) => {
             return;
         }
         const result = eventParser.toResult(handle);
-        console.log('RESULT\n', JSON.stringify(result, null, 2));
-        const stormCodegen = new codegen_1.StormCodegen(aiRequest.prompt, result.blocks);
+        sendDefinitions(res, result);
+        const stormCodegen = new codegen_1.StormCodegen(aiRequest.prompt, result.blocks, eventParser.getEvents());
         const codegenStream = streamStormPartialResponse(stormCodegen.getStream(), res);
         await stormCodegen.process();
         await codegenStream;
@@ -52,42 +52,30 @@ router.post('/:handle/all', async (req, res) => {
         sendError(err, res);
     }
 });
-router.post('/metadata', async (req, res) => {
-    const aiRequest = JSON.parse(req.stringBody ?? '{}');
-    const result = await stormClient_1.stormClient.createMetadata(aiRequest.prompt, aiRequest.history);
-    await streamStormResponse(result, res);
-});
-router.post('/services/implement', async (req, res) => {
-    const aiRequest = JSON.parse(req.stringBody ?? '{}');
-    const result = await stormClient_1.stormClient.createServiceImplementation(aiRequest.prompt, aiRequest.history);
-    await streamStormResponse(result, res);
-});
-router.post('/ui/implement', async (req, res) => {
-    const aiRequest = JSON.parse(req.stringBody ?? '{}');
-    const result = await stormClient_1.stormClient.createUIImplementation(aiRequest.prompt, aiRequest.history);
-    await streamStormResponse(result, res);
-});
-async function streamStormResponse(result, res) {
-    res.set('Content-Type', 'application/x-ndjson');
-    await streamStormPartialResponse(result, res);
-    sendDone(res);
+function sendDefinitions(res, result) {
+    sendEvent(res, {
+        type: 'DEFINITION_CHANGE',
+        payload: result,
+        reason: 'Updates to definition',
+        created: Date.now(),
+    });
 }
 function sendDone(res) {
-    res.write(JSON.stringify({
+    sendEvent(res, {
         type: 'DONE',
         created: Date.now(),
-    }) + '\n');
+    });
     res.end();
 }
 function sendError(err, res) {
     console.error('Failed to send prompt', err);
     if (res.headersSent) {
-        res.write(JSON.stringify({
+        sendEvent(res, {
             type: 'ERROR_INTERNAL',
             created: Date.now(),
             payload: { error: err.message },
             reason: 'Failed while sending prompt',
-        }) + '\n');
+        });
     }
     else {
         res.status(400).send({ error: err.message });
@@ -96,7 +84,7 @@ function sendError(err, res) {
 function streamStormPartialResponse(result, res) {
     return new Promise((resolve, reject) => {
         result.on('data', (data) => {
-            res.write(JSON.stringify(data) + '\n');
+            sendEvent(res, data);
         });
         result.on('error', (err) => {
             reject(err);
@@ -106,4 +94,7 @@ function streamStormPartialResponse(result, res) {
         });
     });
 }
+function sendEvent(res, evt) {
+    res.write(JSON.stringify(evt) + '\n');
+}
 exports.default = router;

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

@@ -1,4 +1,4 @@
-import { ConversationItem, StormFileImplementationPrompt, StormStream } from './stream';
+import { ConversationItem, StormFileImplementationPrompt, StormStream, StormUIImplementationPrompt } from './stream';
 export declare const STORM_ID = "storm";
 declare class StormClient {
     private readonly _baseUrl;
@@ -6,7 +6,7 @@ declare class StormClient {
     private createOptions;
     private send;
     createMetadata(prompt: string, history?: ConversationItem[]): Promise<StormStream>;
-    createUIImplementation(prompt: StormFileImplementationPrompt, history?: ConversationItem[]): Promise<StormStream>;
+    createUIImplementation(prompt: StormUIImplementationPrompt, history?: ConversationItem[]): Promise<StormStream>;
     createServiceImplementation(prompt: StormFileImplementationPrompt, history?: ConversationItem[]): Promise<StormStream>;
 }
 export declare const stormClient: StormClient;

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

@@ -53,12 +53,6 @@ class StormClient {
         jsonLStream.on('error', (error) => {
             out.emit('error', error);
         });
-        jsonLStream.on('pause', () => {
-            console.log('paused');
-        });
-        jsonLStream.on('resume', () => {
-            console.log('resumed');
-        });
         jsonLStream.on('close', () => {
             out.end();
         });
@@ -77,7 +71,6 @@ class StormClient {
         });
     }
     createServiceImplementation(prompt, history) {
-        console.log('SENDING SERVICE PROMPT', JSON.stringify(prompt, null, 2));
         return this.send('/v2/services/merge', {
             history: history ?? [],
             prompt,

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

@@ -36,3 +36,10 @@ export interface StormFileImplementationPrompt {
     template: StormFileInfo;
     prompt: string;
 }
+export interface StormUIImplementationPrompt {
+    events: StormEvent[];
+    templates: StormFileInfo[];
+    context: StormFileInfo[];
+    blockName: string;
+    prompt: string;
+}

package/dist/cjs/test/storm/event-parser.test.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+export {};