@vertesia/workflow 0.51.0 → 0.52.0

package/src/conversion/image.test.ts

@@ -1,26 +1,118 @@
-import fs from 'fs';
-import path from 'path';
-import sharp from 'sharp';
-import { expect, test } from 'vitest';
-import { imageResizer } from '../conversion/image';
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { expect, test, vi, describe } from "vitest";
 
+// Mock Temporal activity context
+vi.mock("@temporalio/activity", () => ({
+    log: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
 
-test('should resize an image to a maximum height or width', async () => {
-  const max_hw = 1024;
-  const format: keyof sharp.FormatEnum = 'jpeg';
-  const imageFile = fs.readFileSync(path.join(__dirname, '../../fixtures', 'cat-picture.jpg'));
+// Import after mocking
+import { imageResizer } from "../conversion/image";
 
-  const resizer = imageResizer(max_hw, format);
+const execAsync = promisify(exec);
 
-  const resized = sharp(imageFile).pipe(resizer);
-  const buffer = await resized.toBuffer();
-  const metadata = await sharp(buffer).metadata();
+describe("ImageMagick image resizing", () => {
+    test("should resize an image to a maximum height or width using ImageMagick", async () => {
+        const max_hw = 1024;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
 
-  console.log(metadata);
-  resized.toFile('/tmp/cat-picture.jpg');
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
 
-  expect(metadata.width).to.be.lessThanOrEqual(max_hw);
-  expect(metadata.height).to.be.lessThanOrEqual(max_hw);
-  expect(metadata.format).to.equal(format);
+        // Call the imageResizer function with a file path
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format);
 
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to get metadata about the resized image
+        const { stdout } = await execAsync(`identify -format "%w %h %m" "${resizedImagePath}"`);
+        const [width, height, imageFormat] = stdout.trim().split(" ");
+
+        console.log({ width, height, imageFormat });
+
+        // Check dimensions
+        expect(parseInt(width)).to.be.lessThanOrEqual(max_hw);
+        expect(parseInt(height)).to.be.lessThanOrEqual(max_hw);
+
+        // Check format (JPEG)
+        expect(imageFormat.toLowerCase()).to.equal("jpeg");
+    });
+
+    test("should throw an error for non-existent input file", async () => {
+        const max_hw = 1024;
+        const format = "jpeg";
+        const nonExistentPath = path.join(__dirname, "non-existent-image.jpg");
+
+        // Verify file doesn't exist
+        expect(fs.existsSync(nonExistentPath)).toBe(false);
+
+        // Expect the function to throw an error
+        await expect(imageResizer(nonExistentPath, max_hw, format)).rejects.toThrow("Input file does not exist");
+    });
+
+    test("should throw error with empty format", async () => {
+        const max_hw = 1024;
+        const format = "";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Test for empty format validation
+        await expect(imageResizer(inputImagePath, max_hw, format)).rejects.toThrow("Invalid format");
+    });
+
+    test("should create progressive/interlaced image when enabled", async () => {
+        const max_hw = 800;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
+
+        // Call the imageResizer function with progressive=true
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format, true);
+
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to check if the image is interlaced
+        const { stdout } = await execAsync(`identify -format "%[interlace]" "${resizedImagePath}"`);
+        const interlaceMode = stdout.trim();
+
+        console.log({ interlaceMode });
+
+        // Check that interlace is enabled (should be 'JPEG' or 'Line' for progressive JPEG)
+        expect(["JPEG", "Line", "Plane"]).to.include(interlaceMode);
+    });
+
+    test("should create non-interlaced image when progressive is disabled", async () => {
+        const max_hw = 800;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
+
+        // Call the imageResizer function with progressive=false
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format, false);
+
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to check if the image is interlaced
+        const { stdout } = await execAsync(`identify -format "%[interlace]" "${resizedImagePath}"`);
+        const interlaceMode = stdout.trim().toLowerCase();
+
+        console.log({ interlaceMode });
+
+        // Check that interlace is disabled (should be 'none' or empty string)
+        expect(["none", ""]).to.include(interlaceMode);
+    });
 });

package/src/conversion/image.ts

@@ -1,22 +1,97 @@
-
-import sharp from "sharp";
-
+import { log } from "@temporalio/activity";
+import { execFile as execFileCallback } from "child_process";
+import fs from "fs";
+import { file } from "tmp-promise";
+import { promisify } from "util";
+const execFile = promisify(execFileCallback);
 
 /**
- * Resizes an image to a maximum height or width
- * @param max_hw 
- * @param format 
- * @returns 
+ * Resizes an image to a maximum height or width using ImageMagick
+ * with progressive loading when supported
+ * @param inputPath Input file path
+ * @param max_hw Maximum height or width
+ * @param format Output format
+ * @param progressive Enable progressive loading for supported formats (defaults to true)
+ * @returns Path to the resized image
  */
-export function imageResizer(max_hw: number, format: keyof sharp.FormatEnum) {
+export async function imageResizer(
+    inputPath: string,
+    max_hw: number,
+    format: string,
+    progressive: boolean = true,
+): Promise<string> {
+    const allowedFormats = ["jpg", "jpeg", "png", "webp"];
 
-    return sharp().resize({
-        width: max_hw,
-        height: max_hw,
-        fit: sharp.fit.inside,
-        withoutEnlargement: true,
+    if (!format || format.trim() === "") {
+        throw new Error(`Invalid format: ${format}.Supported : ${allowedFormats.join(", ")}`);
+    }
 
-    }).toFormat(format);
+    //check that max_hw is valid
+    if (!Number.isInteger(max_hw) || max_hw <= 0) {
+        throw new Error(`Invalid max_hw value: ${max_hw}`);
+    }
 
-}
+    //check that inputPath exists
+    if (!fs.existsSync(inputPath)) {
+        throw new Error(`Input file does not exist: ${inputPath}`);
+    }
+
+    // Create a temporary file
+    const { path: outputPath, cleanup } = await file({ postfix: `.${format}` });
+    try {
+        // Check if input file exists
+        if (!fs.existsSync(inputPath)) {
+            throw new Error(`Input file does not exist: ${inputPath}`);
+        }
+        // Validate max_hw
+        if (!Number.isInteger(max_hw) || max_hw <= 0) {
+            throw new Error(`Invalid max_hw value: ${max_hw}`);
+        }
+
+        // Progressive loading options
+        let conversionOption = "";
+
+        // Only add progressive option for formats that support it
+        if (progressive) {
+            // JPEG and some other formats support progressive loading
+            const lowerFormat = format.toLowerCase();
+            if (lowerFormat === "jpg" || lowerFormat === "jpeg") {
+                conversionOption = "-interlace JPEG";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            } else if (lowerFormat === "png") {
+                conversionOption = "-interlace PNG";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            } else if (lowerFormat === "gif") {
+                conversionOption = "-interlace GIF";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            }
+        }
 
+        log.info(`Resizing image using ImageMagick: ${inputPath} -> ${outputPath}`);
+
+        const { stderr } = await execFile("convert", [
+            inputPath,
+            "-resize",
+            `${max_hw}x${max_hw}>`,
+            ...(conversionOption ? conversionOption.split(" ") : []),
+            outputPath,
+        ]);
+
+        if (stderr) {
+            log.warn(`ImageMagick warning: ${stderr}`);
+        }
+
+        // Verify output exists and has content
+        if (!fs.existsSync(outputPath) || fs.statSync(outputPath).size === 0) {
+            throw new Error(`ImageMagick conversion failed: output file not created or empty`);
+        }
+
+        return outputPath;
+    } catch (error) {
+        // Clean up the temporary file
+        await cleanup();
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log.error(`Image conversion failed: ${errorMessage}`);
+        throw new Error(`Image conversion failed: ${errorMessage}`);
+    }
+}

package/src/conversion/pandoc.test.ts

@@ -9,14 +9,16 @@ let testEnv: TestWorkflowEnvironment;
 let activityContext: MockActivityEnvironment;
 
 beforeAll(async () => {
-  testEnv = await TestWorkflowEnvironment.createLocal();
-  activityContext = new MockActivityEnvironment();
+    testEnv = await TestWorkflowEnvironment.createLocal();
+    activityContext = new MockActivityEnvironment();
 });
 
 
 // Add more test cases for other file types (ODT, DOCX) if needed
 test('should convert docx to markdown', async () => {
-  const docx = fs.readFileSync(path.join(__dirname, '../../fixtures', 'us-ciia.docx'));
-  const result = await activityContext.run(manyToMarkdown, Buffer.from(docx), 'docx');
-  expect(result).to.include('confidential');
+    const filepath = path.join(__dirname, '../../fixtures', 'us-ciia.docx');
+    console.log("Converting file from", filepath);
+    const docx = fs.readFileSync(filepath);
+    const result = await activityContext.run(manyToMarkdown, Buffer.from(docx), 'docx');
+    expect(result).to.include('confidential');
 });

package/src/dsl/setup/ActivityContext.ts

@@ -1,6 +1,11 @@
-import { log } from "@temporalio/activity";
+import { log, activityInfo } from "@temporalio/activity";
 import { VertesiaClient } from "@vertesia/client";
-import { DSLActivityExecutionPayload, DSLWorkflowExecutionPayload, Project, WorkflowExecutionPayload } from "@vertesia/common";
+import {
+    DSLActivityExecutionPayload,
+    DSLWorkflowExecutionPayload,
+    Project,
+    WorkflowExecutionPayload,
+} from "@vertesia/common";
 import { NoDocumentFound, WorkflowParamNotFound } from "../../errors.js";
 import { getProjectFromToken } from "../../utils/auth.js";
 import { getVertesiaClient } from "../../utils/client.js";
@@ -8,7 +13,6 @@ import { Vars } from "../vars.js";
 import { getFetchProvider, registerFetchProviderFactory } from "./fetch/index.js";
 import { DocumentProvider, DocumentTypeProvider, InteractionRunProvider } from "./fetch/providers.js";
 
-
 registerFetchProviderFactory(DocumentProvider.ID, DocumentProvider.factory);
 registerFetchProviderFactory(DocumentTypeProvider.ID, DocumentTypeProvider.factory);
 registerFetchProviderFactory(InteractionRunProvider.ID, InteractionRunProvider.factory);
@@ -17,7 +21,11 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     client: VertesiaClient;
     _project?: Promise<Project | undefined>;
 
-    constructor(public payload: DSLActivityExecutionPayload<ParamsT>, client: VertesiaClient, public params: ParamsT) {
+    constructor(
+        public payload: DSLActivityExecutionPayload<ParamsT>,
+        client: VertesiaClient,
+        public params: ParamsT,
+    ) {
         this.client = client;
         this.fetchProject = this.fetchProject.bind(this);
     }
@@ -29,24 +37,54 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     get objectId() {
         const objectId = this.payload.objectIds && this.payload.objectIds[0];
         if (!objectId) {
-            log.error('No objectId found in payload');
-            throw new WorkflowParamNotFound('objectIds[0]', (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow);
+            log.error("No objectId found in payload");
+            throw new WorkflowParamNotFound(
+                "objectIds[0]",
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
+            );
         }
         return objectId;
     }
 
+    get activityInfo() {
+        return activityInfo();
+    }
+
+    get runId() {
+        const runId = activityInfo().workflowExecution.runId;
+        if (!runId) {
+            log.error("No runId found in activityInfo");
+            throw new WorkflowParamNotFound(
+                "runId",
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
+            );
+        }
+        return runId;
+    }
+
+    get workflowId() {
+        const workflowId = activityInfo().workflowExecution.workflowId;
+        if (!workflowId) {
+            log.error("No workflowId found in activityInfo");
+            throw new WorkflowParamNotFound(
+                "workflowId",
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
+            );
+        }
+        return workflowId;
+    }
+
     fetchProject() {
         if (!this._project) {
             this._project = _fetchProject(this.client, this.payload);
         }
         return this._project;
     }
-
 }
 
-
-export async function setupActivity<ParamsT extends Record<string, any>>(payload: DSLActivityExecutionPayload<ParamsT>) {
-
+export async function setupActivity<ParamsT extends Record<string, any>>(
+    payload: DSLActivityExecutionPayload<ParamsT>,
+) {
     const isDebugMode = !!payload.debug_mode;
 
     const vars = new Vars({
@@ -56,13 +94,17 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
 
     //}
     if (isDebugMode) {
-        log.info(`Setting up activity ${payload.activity.name}`, { config: payload.config, activity: payload.activity, params: payload.params, vars });
+        log.info(`Setting up activity ${payload.activity.name}`, {
+            config: payload.config,
+            activity: payload.activity,
+            params: payload.params,
+            vars,
+        });
     }
 
     const client = getVertesiaClient(payload);
     const fetchSpecs = payload.activity.fetch;
     if (fetchSpecs) {
-
         const keys = Object.keys(fetchSpecs);
         if (keys.length > 0) {
             // create a new Vars instance to store the fetched data
@@ -74,7 +116,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
                     fetchSpec = { ...fetchSpec, query };
                 }
 
-                const provider = await getFetchProvider(client, fetchSpec);
+                const provider = getFetchProvider(client, fetchSpec);
 
                 log.info(`Fetching data for ${key} with provider ${provider.name}`, { fetchSpec });
                 const result = await provider.fetch(fetchSpec);
@@ -84,7 +126,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
                     } else {
                         vars.setValue(key, result);
                     }
-                } else if (fetchSpec.on_not_found === 'throw') {
+                } else if (fetchSpec.on_not_found === "throw") {
                     throw new NoDocumentFound("No documents found for: " + JSON.stringify(fetchSpec));
                 } else {
                     vars.setValue(key, null);
@@ -94,12 +136,11 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
     }
 
     const params = vars.resolve() as ParamsT;
-    log.info(`Activity ${payload.activity.name} setup complete`, { params });
+    log.info(`Activity ${payload.activity.name} setup complete`);
 
     return new ActivityContext<ParamsT>(payload, client, params);
 }
 
-
 async function _fetchProject(client: VertesiaClient, payload: WorkflowExecutionPayload) {
     const project = await getProjectFromToken(payload.auth_token);
     return project ? await client.projects.retrieve(project.id) : undefined;

package/src/dsl.ts

@@ -1,3 +1,3 @@
 export * from "./dsl/dslProxyActivities.js";
+export * from "./errors.js";
 export * from "./result-types.js";
-export * from "./errors.js";

package/src/errors.ts

@@ -1,24 +1,45 @@
 import { DSLActivitySpec, DSLWorkflowSpec } from "@vertesia/common";
 
-
 export class NoDocumentFound extends Error {
-    constructor(message: string, public ids?: string[]) {
+    constructor(
+        message: string,
+        public ids?: string[],
+    ) {
         super(message);
         this.name = "NoDocumentFound";
-        this.ids = ids
+        this.ids = ids;
     }
 }
 
 export class ActivityParamNotFound extends Error {
-    constructor(public paramName: string, public activity: DSLActivitySpec) {
+    constructor(
+        public paramName: string,
+        public activity: DSLActivitySpec,
+    ) {
         super(`Required parameter ${paramName} not found in activity ${activity.name}`);
         this.name = "ActivityParamNotFound";
     }
 }
 
+export class ActivityParamInvalid extends Error {
+    constructor(
+        public paramName: string,
+        public activity: DSLActivitySpec,
+        reason?: string,
+    ) {
+        super(`${paramName} in activity ${activity.name} is invalid${reason ? ` ${reason}` : ""}`);
+        this.name = "ActivityParamInvalid";
+    }
+}
+
 export class WorkflowParamNotFound extends Error {
-    constructor(public paramName: string, public workflow?: DSLWorkflowSpec) {
+    constructor(
+        public paramName: string,
+        public workflow?: DSLWorkflowSpec,
+    ) {
         super(`Required parameter ${paramName} not found in workflow ${workflow?.name}`);
         this.name = "WorkflowParamNotFound";
     }
-}
+}
+
+export const WF_NON_RETRYABLE_ERRORS = ["NoDocumentFound", "ActivityParamNotFound", "WorkflowParamNotFound"];

package/src/iterative-generation/iterativeGenerationWorkflow.ts

@@ -1,6 +1,7 @@
 import { WorkflowExecutionPayload } from "@vertesia/common";
 
 import { log, proxyActivities } from "@temporalio/workflow";
+import { WF_NON_RETRYABLE_ERRORS } from "../errors.js";
 import * as activities from "./activities/index.js";
 import { IterativeGenerationPayload, PartIndex, SECTION_ID_PLACEHOLDER } from "./types.js";
 
@@ -16,7 +17,7 @@ const {
         backoffCoefficient: 2,
         maximumAttempts: 20,
         maximumInterval: 100 * 30 * 1000, //ms
-        nonRetryableErrorTypes: [],
+        nonRetryableErrorTypes: WF_NON_RETRYABLE_ERRORS,
     },
 });
 

package/src/system/notifyWebhookWorkflow.ts

@@ -3,6 +3,7 @@ import { log } from "@temporalio/workflow";
 import { ContentEventName, WorkflowExecutionPayload } from "@vertesia/common";
 import * as activities from "../activities/notifyWebhook.js";
 import { dslProxyActivities } from "../dsl/dslProxyActivities.js";
+import { WF_NON_RETRYABLE_ERRORS } from "../errors.js";
 
 const {
     notifyWebhook
@@ -13,7 +14,7 @@ const {
         backoffCoefficient: 2,
         maximumAttempts: 5,
         maximumInterval: 100 * 30 * 1000, //ms
-        nonRetryableErrorTypes: [],
+        nonRetryableErrorTypes: WF_NON_RETRYABLE_ERRORS,
     },
 });
 

package/src/system/recalculateEmbeddingsWorkflow.ts

@@ -2,7 +2,7 @@
 import { SupportedEmbeddingTypes, WorkflowExecutionPayload } from "@vertesia/common";
 import * as activities from "../activities/index-dsl.js";
 import { dslProxyActivities } from "../dsl/dslProxyActivities.js";
-import { NoDocumentFound } from "../errors.js";
+import { WF_NON_RETRYABLE_ERRORS } from "../errors.js";
 
 const {
     generateEmbeddings,
@@ -13,7 +13,7 @@ const {
         backoffCoefficient: 2,
         maximumAttempts: 10,
         maximumInterval: 100 * 30 * 1000, //ms
-        nonRetryableErrorTypes: [NoDocumentFound.name],
+        nonRetryableErrorTypes: WF_NON_RETRYABLE_ERRORS,
     },
 });
 

package/src/utils/blobs.ts

@@ -10,7 +10,12 @@ export async function fetchBlobAsStream(client: VertesiaClient, blobUri: string)
     try {
         return await client.files.downloadFile(blobUri);
     } catch (err: any) {
-        throw new NoDocumentFound(`Failed to download blob ${blobUri}: ${err.message}`, []);
+        if (err.message.includes("not found")) {
+            //TODO improve error handling with a fetch fail error class in the client
+            throw new NoDocumentFound(`Failed to download blob ${blobUri}: ${err.message}`, []);
+        } else {
+            throw new Error(`Failed to download blob ${blobUri}: ${err.message}`);
+        }
     }
 }
 export async function fetchBlobAsBuffer(client: VertesiaClient, blobUri: string): Promise<Buffer> {
@@ -24,7 +29,7 @@ export async function fetchBlobAsBuffer(client: VertesiaClient, blobUri: string)
 
 export async function fetchBlobAsBase64(client: VertesiaClient, blobUri: string): Promise<string> {
     const buffer = await fetchBlobAsBuffer(client, blobUri);
-    return buffer.toString('base64');
+    return buffer.toString("base64");
 }
 
 export async function saveBlobToFile(client: VertesiaClient, blobUri: string, toFile: string): Promise<void> {
@@ -36,8 +41,8 @@ export async function saveBlobToFile(client: VertesiaClient, blobUri: string, to
 export async function saveBlobToTempFile(client: VertesiaClient, blobUri: string, fileExt?: string): Promise<string> {
     const tmpFile = tmp.fileSync({
         prefix: "vertesia-activity-",
-        postfix: "." + fileExt,
-        discardDescriptor: true
+        postfix: fileExt ? "." + fileExt : "",
+        discardDescriptor: true,
     });
     await saveBlobToFile(client, blobUri, tmpFile.name);
     return tmpFile.name;
@@ -47,12 +52,12 @@ async function writeChunksToStream(chunks: AsyncIterable<Uint8Array>, out: NodeJ
     for await (const chunk of chunks) {
         if (!out.write(chunk)) {
             // If the internal buffer is full, wait until it's drained
-            await new Promise(resolve => out.once('drain', resolve));
+            await new Promise((resolve) => out.once("drain", resolve));
         }
     }
     out.end(); // Close the stream when done
 }
 
 export function md5(contents: string) {
-    return crypto.createHash('md5').update(contents).digest("hex");
+    return crypto.createHash("md5").update(contents).digest("hex");
 }

package/src/utils/chunks.ts

@@ -0,0 +1,17 @@
+
+export interface DocPart {
+    line_number_start: number
+    line_number_end: number
+    name: string
+    type: string
+}
+
+export const getContentPart = (content: string, part: DocPart): string => {
+    const lines = content.split('\n');
+    const text = lines.filter((_l, i) => i >= part.line_number_start && i <= part.line_number_end).join('\n');
+    return text;
+}
+
+export const getContentParts = (content: string, parts: DocPart[]): string[] => {
+    return parts.map(part => getContentPart(content, part));
+}

package/src/utils/client.ts

@@ -4,20 +4,21 @@
 
 import { VertesiaClient } from "@vertesia/client";
 import { WorkflowExecutionBaseParams } from "@vertesia/common";
+import { WorkflowParamNotFound } from "../errors.js";
 
 
 export function getVertesiaClient(payload: WorkflowExecutionBaseParams) {
 
     if (!payload.auth_token) {
-        throw new Error("Authentication Token is missing from WorkflowExecutionPayload.authToken");
+        throw new WorkflowParamNotFound("Authentication Token is missing from WorkflowExecutionPayload.authToken");
     }
 
     if (!payload.config?.studio_url) {
-        throw new Error("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
+        throw new WorkflowParamNotFound("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
     }
 
     if (!payload.config?.store_url) {
-        throw new Error("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
+        throw new WorkflowParamNotFound("Content Store URL is missing from WorkflowExecutionPayload.servers.storeUrl");
     }
 
     const client = new VertesiaClient({

package/src/utils/memory.ts

@@ -1,9 +1,9 @@
-import { VertesiaClient, StreamSource } from "@vertesia/client";
+import { VertesiaClient } from "@vertesia/client";
+import { NodeStreamSource } from "@vertesia/client/node";
 import { Commands, MemoryPack, buildMemoryPack as _buildMemoryPack, loadMemoryPack as _loadMemoryPack } from "@vertesia/memory";
 import { createReadStream, createWriteStream } from "fs";
 import { rm } from "fs/promises";
-import { readableToWebStream, webStreamToReadable } from "node-web-stream-adapters";
-import { Readable } from "stream";
+import { webStreamToReadable } from "node-web-stream-adapters";
 import { pipeline } from "stream/promises";
 
 import tmp from "tmp";
@@ -11,11 +11,6 @@ import zlib from "zlib";
 
 tmp.setGracefulCleanup();
 
-export class NodeStreamSource extends StreamSource {
-    constructor(stream: Readable, name: string, type?: string, id?: string) {
-        super(readableToWebStream(stream), name, type, id);
-    }
-}
 
 export async function publishMemoryPack(client: VertesiaClient, file: string, name: string): Promise<void> {
     const stream = createReadStream(file);