@kapeta/local-cluster-service 0.43.3 → 0.45.0

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

@@ -0,0 +1,109 @@
+"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 });
+const express_promise_router_1 = __importDefault(require("express-promise-router"));
+const cors_1 = require("../middleware/cors");
+const stringBody_1 = require("../middleware/stringBody");
+const stormClient_1 = require("./stormClient");
+const event_parser_1 = require("./event-parser");
+const codegen_1 = require("./codegen");
+const router = (0, express_promise_router_1.default)();
+router.use('/', cors_1.corsHandler);
+router.use('/', stringBody_1.stringBody);
+router.post('/:handle/all', async (req, res) => {
+    const handle = req.params.handle;
+    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);
+        });
+        await streamStormPartialResponse(metaStream, res);
+        if (!eventParser.isValid()) {
+            // We can't continue if the meta stream is invalid
+            res.write({
+                type: 'ERROR_INTERNAL',
+                payload: { error: eventParser.getError() },
+                reason: 'Failed to generate system',
+                created: Date.now(),
+            });
+            res.end();
+            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);
+        const codegenStream = streamStormPartialResponse(stormCodegen.getStream(), res);
+        await stormCodegen.process();
+        await codegenStream;
+        sendDone(res);
+    }
+    catch (err) {
+        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 sendDone(res) {
+    res.write(JSON.stringify({
+        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({
+            type: 'ERROR_INTERNAL',
+            created: Date.now(),
+            payload: { error: err.message },
+            reason: 'Failed while sending prompt',
+        }) + '\n');
+    }
+    else {
+        res.status(400).send({ error: err.message });
+    }
+}
+function streamStormPartialResponse(result, res) {
+    return new Promise((resolve, reject) => {
+        result.on('data', (data) => {
+            res.write(JSON.stringify(data) + '\n');
+        });
+        result.on('error', (err) => {
+            reject(err);
+        });
+        result.on('end', () => {
+            resolve();
+        });
+    });
+}
+exports.default = router;

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

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

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

@@ -0,0 +1,87 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stormClient = exports.STORM_ID = void 0;
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+const nodejs_api_client_1 = require("@kapeta/nodejs-api-client");
+const utils_1 = require("../utils/utils");
+const promises_1 = __importDefault(require("node:readline/promises"));
+const node_stream_1 = require("node:stream");
+const stream_1 = require("./stream");
+exports.STORM_ID = 'storm';
+class StormClient {
+    _baseUrl;
+    constructor() {
+        this._baseUrl = (0, utils_1.getRemoteUrl)('ai-service', 'https://ai.kapeta.com');
+    }
+    createOptions(path, method, body) {
+        const url = `${this._baseUrl}${path}`;
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        const api = new nodejs_api_client_1.KapetaAPI();
+        if (api.hasToken()) {
+            //headers['Authorization'] = `Bearer ${api.getAccessToken()}`; //TODO: Enable authentication
+        }
+        return {
+            url,
+            method: method,
+            body: JSON.stringify(body),
+            headers,
+        };
+    }
+    async send(path, body, method = 'POST') {
+        const stringPrompt = typeof body.prompt === 'string' ? body.prompt : JSON.stringify(body.prompt);
+        const options = this.createOptions(path, method, {
+            prompt: stringPrompt,
+            history: body.history,
+        });
+        const out = new stream_1.StormStream(stringPrompt, body.history);
+        const response = await fetch(options.url, options);
+        if (response.status !== 200) {
+            throw new Error(`Got error response from ${options.url}: ${response.status}\nContent: ${await response.text()}`);
+        }
+        const jsonLStream = promises_1.default.createInterface(node_stream_1.Readable.fromWeb(response.body));
+        jsonLStream.on('line', (line) => {
+            out.addJSONLine(line);
+        });
+        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();
+        });
+        return out;
+    }
+    createMetadata(prompt, history) {
+        return this.send('/v2/all', {
+            history: history ?? [],
+            prompt: prompt,
+        });
+    }
+    createUIImplementation(prompt, history) {
+        return this.send('/v2/ui/merge', {
+            history: history ?? [],
+            prompt,
+        });
+    }
+    createServiceImplementation(prompt, history) {
+        console.log('SENDING SERVICE PROMPT', JSON.stringify(prompt, null, 2));
+        return this.send('/v2/services/merge', {
+            history: history ?? [],
+            prompt,
+        });
+    }
+}
+exports.stormClient = new StormClient();

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

@@ -0,0 +1,38 @@
+/// <reference types="node" />
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+import { EventEmitter } from 'node:events';
+import { StormEvent } from './events';
+import { AIFileTypes, GeneratedFile } from '@kapeta/codegen';
+export declare class StormStream extends EventEmitter {
+    private history;
+    private lines;
+    constructor(prompt?: string, history?: ConversationItem[]);
+    addJSONLine(line: string): void;
+    end(): void;
+    on(event: 'end', listener: () => void): this;
+    on(event: 'error', listener: (e: Error) => void): this;
+    on(event: 'data', listener: (data: StormEvent) => void): this;
+    emit(event: 'end'): boolean;
+    emit(event: 'error', e: Error): boolean;
+    emit(event: 'data', data: StormEvent): boolean;
+    waitForDone(): Promise<void>;
+}
+export interface ConversationItem {
+    role: 'user' | 'model';
+    content: string;
+}
+export interface StormContextRequest<T = string> {
+    history?: ConversationItem[];
+    prompt: T;
+}
+export interface StormFileInfo extends GeneratedFile {
+    type: AIFileTypes;
+}
+export interface StormFileImplementationPrompt {
+    context: StormFileInfo[];
+    template: StormFileInfo;
+    prompt: string;
+}

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StormStream = void 0;
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+const node_events_1 = require("node:events");
+class StormStream extends node_events_1.EventEmitter {
+    history;
+    lines = [];
+    constructor(prompt = '', history) {
+        super();
+        this.history = history ?? [];
+        this.history.push({
+            role: 'user',
+            content: prompt,
+        });
+    }
+    addJSONLine(line) {
+        try {
+            this.lines.push(line);
+            const event = JSON.parse(line);
+            if (!event.created) {
+                event.created = Date.now();
+            }
+            this.emit('data', event);
+        }
+        catch (e) {
+            this.emit('error', e);
+        }
+    }
+    end() {
+        this.history.push({
+            role: 'model',
+            content: this.lines.join('\n'),
+        });
+        this.emit('end');
+    }
+    on(event, listener) {
+        return super.on(event, listener);
+    }
+    emit(eventName, ...args) {
+        return super.emit(eventName, ...args);
+    }
+    waitForDone() {
+        return new Promise((resolve, reject) => {
+            this.on('error', (err) => {
+                reject(err);
+            });
+            this.on('end', () => {
+                resolve();
+            });
+        });
+    }
+}
+exports.StormStream = StormStream;

package/dist/esm/src/types.d.ts

@@ -6,6 +6,7 @@ import express from 'express';
 import { Connection, Resource } from '@kapeta/schemas';
 import { StringBodyRequest } from './middleware/stringBody';
 import { KapetaRequest } from './middleware/kapeta';
+import { EnrichedAsset } from './assetManager';
 export declare const KIND_RESOURCE_OPERATOR = "core/resource-type-operator";
 export declare const KIND_BLOCK_TYPE = "core/block-type";
 export declare const KIND_BLOCK_TYPE_OPERATOR = "core/block-type-operator";
@@ -80,9 +81,11 @@ export type ProxyRequestHandler = (req: StringBodyRequest, res: express.Response
 export interface ProxyRequestInfo {
     address: string;
     connection: Connection;
-    providerResource: Resource;
-    consumerResource: Resource;
     consumerPath: string;
+    consumerResource: Resource;
+    consumerBlockAsset: EnrichedAsset;
+    providerResource: Resource;
+    providerBlockAsset: EnrichedAsset;
 }
 export interface SimpleResponse {
     code: number;

package/index.ts

@@ -24,6 +24,7 @@ import AttachmentRoutes from './src/attachments/routes';
 import TaskRoutes from './src/tasks/routes';
 import APIRoutes from './src/api';
 import AIRoutes from './src/ai/routes';
+import StormRoutes from './src/storm/routes';
 import { isLinux } from './src/utils/utils';
 import request from 'request';
 import { repositoryManager } from './src/repositoryManager';
@@ -74,6 +75,7 @@ function createServer() {
     app.use('/tasks', TaskRoutes);
     app.use('/api', APIRoutes);
     app.use('/ai', AIRoutes);
+    app.use('/storm', StormRoutes);
 
     app.get('/status', async (req, res) => {
         res.send({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@kapeta/local-cluster-service",
-    "version": "0.43.3",
+    "version": "0.45.0",
     "description": "Manages configuration, ports and service discovery for locally running Kapeta systems",
     "type": "commonjs",
     "exports": {
@@ -43,13 +43,16 @@
         "build:cjs": "tsc  --outDir ./dist/cjs && echo '{\"type\":\"commonjs\"}' > ./dist/cjs/package.json",
         "build": "npm run clean && npm run build:esm && npm run build:cjs",
         "format": "prettier --write .",
-        "lint": "tsc --noEmit && eslint src/**/*.ts",
+        "lint": "npm run lint:tsc && npm run lint:eslint",
+        "lint:tsc": "tsc --noEmit",
+        "lint:eslint": "eslint src/**/*.ts",
         "prepublishOnly": "npm run build"
     },
     "homepage": "https://github.com/kapetacom/local-cluster-service#readme",
     "dependencies": {
-        "@kapeta/codegen": "^1.3.0",
+        "@kapeta/codegen": "^1.4.0",
         "@kapeta/config-mapper": "^1.2.1",
+        "@kapeta/kaplang-core": "^1.16.0",
         "@kapeta/local-cluster-config": "^0.4.2",
         "@kapeta/nodejs-api-client": ">=0.2.0 <2",
         "@kapeta/nodejs-process": "^1.2.0",

package/src/codeGeneratorManager.ts

@@ -16,6 +16,22 @@ const TARGET_KIND = 'core/language-target';
 const BLOCK_TYPE_REGEX = /^core\/block-type.*/;
 
 class CodeGeneratorManager {
+    public async ensureTarget(targetKind: string) {
+        const targetRef = normalizeKapetaUri(targetKind);
+
+        // Automatically downloads target if not available
+        const targetAsset = await assetManager.getAsset(targetRef);
+
+        if (!targetAsset) {
+            console.error('Language target not found: %s', targetKind);
+            return false;
+        }
+
+        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
+
+        return true;
+    }
+
     private async ensureLanguageTargetInRegistry(path: string, version: string, definition: Definition) {
         const key = `${definition.metadata.name}:${version}`;
 
@@ -81,17 +97,10 @@ class CodeGeneratorManager {
             return;
         }
 
-        const targetRef = normalizeKapetaUri(yamlContent.spec.target?.kind);
-
-        // Automatically downloads target if not available
-        const targetAsset = await assetManager.getAsset(targetRef);
-
-        if (!targetAsset) {
-            console.error('Language target not found: %s', yamlContent.spec.target?.kind);
+        if (!(await this.ensureTarget(yamlContent.spec.target?.kind))) {
             return;
         }
 
-        await this.ensureLanguageTargetInRegistry(targetAsset?.path, targetAsset?.version, targetAsset?.data);
         const baseDir = Path.dirname(yamlFile);
         console.log('Generating code for path: %s', baseDir);
         const codeGenerator = new BlockCodeGenerator(yamlContent as BlockDefinition);

package/src/proxy/routes.ts

@@ -4,7 +4,7 @@
  */
 
 import Router from 'express-promise-router';
-import { Request, Response } from 'express';
+import { Response } from 'express';
 import { Resource } from '@kapeta/schemas';
 import { proxyRestRequest } from './types/rest';
 import { proxyHttpRequest } from './types/web';
@@ -61,23 +61,26 @@ router.all(
                 return;
             }
 
-            const toBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
+            const consumerBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
                 return blockInstance.id.toLowerCase() === connection.consumer.blockId.toLowerCase();
             });
 
-            if (!toBlockInstance) {
+            if (!consumerBlockInstance) {
                 res.status(401).send({ error: `Block instance not found "${req.params.consumerInstanceId}` });
                 return;
             }
 
-            const toBlockAsset = await assetManager.getAsset(toBlockInstance.block.ref);
+            const consumerBlockAsset = await assetManager.getAsset(consumerBlockInstance.block.ref);
 
-            if (!toBlockAsset) {
-                res.status(401).send({ error: `Block asset not found "${toBlockInstance.block.ref}` });
+            if (!consumerBlockAsset) {
+                res.status(401).send({ error: `Block asset not found "${consumerBlockInstance.block.ref}` });
                 return;
             }
 
-            const consumerResource = getResource(toBlockAsset.data.spec.consumers, req.params.consumerResourceName);
+            const consumerResource = getResource(
+                consumerBlockAsset.data.spec.consumers,
+                req.params.consumerResourceName
+            );
 
             if (!consumerResource) {
                 res.status(401).send({
@@ -93,23 +96,26 @@ router.all(
                 req.params.type
             );
 
-            const fromBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
+            const providerBlockInstance = _.find(plan.spec.blocks, (blockInstance) => {
                 return blockInstance.id.toLowerCase() === connection.provider.blockId.toLowerCase();
             });
 
-            if (!fromBlockInstance) {
+            if (!providerBlockInstance) {
                 res.status(401).send({ error: `Block instance not found "${connection.provider.blockId}` });
                 return;
             }
 
-            const fromBlockAsset = await assetManager.getAsset(fromBlockInstance.block.ref);
+            const providerBlockAsset = await assetManager.getAsset(providerBlockInstance.block.ref);
 
-            if (!fromBlockAsset) {
-                res.status(401).send({ error: `Block asset not found "${fromBlockInstance.block.ref}` });
+            if (!providerBlockAsset) {
+                res.status(401).send({ error: `Block asset not found "${providerBlockInstance.block.ref}` });
                 return;
             }
 
-            const providerResource = getResource(fromBlockAsset.data.spec.providers, connection.provider.resourceName);
+            const providerResource = getResource(
+                providerBlockAsset.data.spec.providers,
+                connection.provider.resourceName
+            );
 
             if (!providerResource) {
                 res.status(401).send({
@@ -129,19 +135,19 @@ router.all(
                 address = address.substring(0, address.length - 1);
             }
 
-            /*
-         Get the path the consumer requested.
-         Note that this might not match the path the destination is expecting so we need to identify the method
-         that is being called and identify the destination path from the connection.
-         */
+            // Get the path the consumer requested. Note that this might not match the path the
+            // destination is expecting so we need to identify the method that is being called and
+            // identify the destination path from the connection.
             const consumerPath = req.originalUrl.substring(basePath.length - 1);
 
             typeHandler(req, res, {
-                consumerPath,
                 address,
+                connection,
+                consumerPath,
                 consumerResource,
+                consumerBlockAsset,
                 providerResource,
-                connection,
+                providerBlockAsset,
             });
         } catch (err: any) {
             console.warn('Failed to process proxy request', err);

package/src/proxy/types/rest.ts

@@ -10,12 +10,13 @@ import { pathTemplateParser } from '../../utils/pathTemplateParser';
 import { networkManager } from '../../networkManager';
 
 import { socketManager } from '../../socketManager';
-import { Request, Response } from 'express';
-import { ProxyRequestInfo, SimpleRequest, StringMap } from '../../types';
-import { StringBodyRequest } from '../../middleware/stringBody';
+import { Request } from 'express';
+import { ProxyRequestHandler, ProxyRequestInfo, SimpleRequest, SimpleResponse, StringMap } from '../../types';
 import { Resource } from '@kapeta/schemas';
 import { stringify } from 'qs';
 import { proxyHttpRequest } from './web';
+import { DSLConverters, HTTPTransport, RESTMethod, maskSensitiveData } from '@kapeta/kaplang-core';
+import { EnrichedAsset } from '../../assetManager';
 
 export function getRestMethodId(restResource: Resource, httpMethod: string, httpPath: string) {
     return _.findKey(restResource.spec.methods, (method) => {
@@ -37,6 +38,10 @@ export function getRestMethodId(restResource: Resource, httpMethod: string, http
     });
 }
 
+interface RESTMethodWithId extends RESTMethod {
+    id: string;
+}
+
 /**
  *
  * @param req {Request}
@@ -52,7 +57,7 @@ function resolveMethods(req: Request, opts: ProxyRequestInfo) {
         );
     }
 
-    const consumerMethod = _.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId]);
+    const consumerMethod = _.cloneDeep(opts.consumerResource.spec.methods[consumerMethodId] as RESTMethodWithId);
 
     if (!consumerMethod) {
         throw new Error(
@@ -70,7 +75,7 @@ function resolveMethods(req: Request, opts: ProxyRequestInfo) {
         throw new Error(`Connection contained no mapping for consumer method "${consumerMethodId}`);
     }
 
-    const providerMethod = _.cloneDeep(opts.providerResource.spec.methods[providerMethodId]);
+    const providerMethod = _.cloneDeep(opts.providerResource.spec.methods[providerMethodId] as RESTMethodWithId);
 
     if (!providerMethod) {
         throw new Error(
@@ -86,12 +91,67 @@ function resolveMethods(req: Request, opts: ProxyRequestInfo) {
     };
 }
 
-export function proxyRestRequest(req: StringBodyRequest, res: Response, opts: ProxyRequestInfo) {
+function resolveEntitiesSource(blockAsset: EnrichedAsset) {
+    return (blockAsset.data.spec?.entities?.source?.value as string) || '';
+}
+
+const MASK_STRING = '*******';
+
+function maskSimpleRequest(req: SimpleRequest, consumerMethod: RESTMethod, entitiesSource: string) {
+    const maskedRequest = _.cloneDeep(req);
+
+    Object.entries(consumerMethod.arguments || {}).forEach(([key, value]) => {
+        if (value.transport === HTTPTransport.BODY && typeof maskedRequest.body === 'string') {
+            try {
+                maskedRequest.body = maskSensitiveData(
+                    maskedRequest.body,
+                    DSLConverters.fromSchemaType(value),
+                    entitiesSource,
+                    MASK_STRING
+                );
+            } catch (error) {
+                // Ignore errors masking the request body
+            }
+        }
+        // TODO: Mask HEADER
+        // TODO: Mask QUERY
+    });
+
+    return maskedRequest;
+}
+
+function maskSimpleResponse(res: SimpleResponse, consumerMethod: RESTMethod, entitiesSource: string) {
+    const maskedResponse = _.cloneDeep(res);
+
+    Object.entries(consumerMethod.arguments || {}).forEach(([key, value]) => {
+        // TODO: Mask HEADER
+    });
+
+    try {
+        if (typeof maskedResponse.body === 'string') {
+            maskedResponse.body = maskSensitiveData(
+                maskedResponse.body,
+                DSLConverters.fromSchemaType(consumerMethod.responseType),
+                entitiesSource,
+                MASK_STRING
+            );
+        }
+    } catch (error) {
+        // Ignore errors masking the response body
+    }
+
+    return maskedResponse;
+}
+
+export const proxyRestRequest: ProxyRequestHandler = (req, res, opts) => {
     if (_.isEmpty(opts.consumerResource.spec.methods) && _.isEmpty(opts.providerResource.spec.methods)) {
         // If there are no methods defined, we assume the user controls the path and we just proxy the raw request
         return proxyHttpRequest(req, res, opts);
     }
-    let { consumerMethod, providerMethod } = resolveMethods(req, opts);
+    const { consumerMethod, providerMethod } = resolveMethods(req, opts);
+
+    const consumerEntitiesSource = resolveEntitiesSource(opts.consumerBlockAsset);
+    const providerEntitiesSource = resolveEntitiesSource(opts.providerBlockAsset);
 
     const consumerPathTemplate = pathTemplateParser(consumerMethod.path);
     const providerPathTemplate = pathTemplateParser(providerMethod.path);
@@ -134,7 +194,7 @@ export function proxyRestRequest(req: StringBodyRequest, res: Response, opts: Pr
     const traffic = networkManager.addRequest(
         req.params.systemId,
         opts.connection,
-        reqOpts,
+        maskSimpleRequest(reqOpts, consumerMethod, consumerEntitiesSource),
         consumerMethod.id,
         providerMethod.id
     );
@@ -160,11 +220,13 @@ export function proxyRestRequest(req: StringBodyRequest, res: Response, opts: Pr
 
         res.status(response.statusCode);
 
-        traffic.withResponse({
+        const simpleResponse = {
             code: response.statusCode,
             headers: response.headers as StringMap,
             body: responseBody,
-        });
+        };
+
+        traffic.withResponse(maskSimpleResponse(simpleResponse, consumerMethod, consumerEntitiesSource));
 
         socketManager.emit(traffic.connectionId, 'traffic_end', traffic);
 
@@ -174,4 +236,4 @@ export function proxyRestRequest(req: StringBodyRequest, res: Response, opts: Pr
 
         res.end();
     });
-}
+};