@vertesia/workflow 0.67.0 → 0.69.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "0.67.0",
+  "version": "0.69.0",
   "type": "module",
   "description": "Composable prompts workflow dsl",
   "main": "./lib/esm/index.js",
@@ -50,10 +50,10 @@
     "tmp": "^0.2.3",
     "tmp-promise": "^3.0.3",
     "yaml": "^2.6.0",
-    "@vertesia/client": "0.67.0",
-    "@vertesia/api-fetch-client": "0.67.0",
-    "@llumiverse/common": "0.20.0",
-    "@vertesia/common": "0.67.0"
+    "@vertesia/api-fetch-client": "0.69.0",
+    "@vertesia/common": "0.69.0",
+    "@llumiverse/common": "0.21.0",
+    "@vertesia/client": "0.69.0"
   },
   "ts_dual_module": {
     "outDir": "lib",

package/src/activities/executeInteraction.ts

@@ -177,7 +177,7 @@ export async function executeInteractionFromActivity(
     const userTags = params.tags;
     const info = activityInfo();
     const runId = info.workflowExecution.runId;
-    let tags = ["workflow", `tmpRunId:${runId}`]; //TODO use wf:wfName
+    let tags = ["workflow"];
     if (userTags) {
         tags = tags.concat(userTags);
     }
@@ -191,9 +191,9 @@ export async function executeInteractionFromActivity(
     if (params.include_previous_error) {
         //retrieve last failed run if any
         if (info.attempt > 1) {
-            log.info("Retrying, searching for previous run", { tags: ["tmpRunId:" + runId] });
+            log.info("Retrying, searching for previous run", { prev_run_id: runId });
             const payload: RunSearchPayload = {
-                query: { tags: ["tmpRunId:" + info.workflowExecution.runId] },
+                query: { workflow_run_ids: [runId] },
                 limit: 1,
             };
             const previousRun = await client.runs.search(payload).then((res) => {

package/src/activities/generateEmbeddings.ts

@@ -158,9 +158,6 @@ async function generateTextEmbeddings(
     { document, client, type, config }: ExecuteGenerateEmbeddingsParams,
     parts?: DocPart[],
 ) {
-    // if (!force && document.embeddings[type]?.etag === (document.text_etag ?? md5(document.text))) {
-    //     return { id: objectId, status: "skipped", message: "embeddings already generated" }
-    // }
 
     if (!document) {
         return { status: "error", message: "document is null or undefined" };
@@ -401,7 +398,6 @@ async function generateImageEmbeddings({
 
     const resRnd = await client.store.objects.getRendition(document.id, {
         format: ImageRenditionFormat.jpeg,
-        max_hw: 1024,
         generate_if_missing: true,
         sign_url: true,
     });

package/src/activities/generateOrAssignContentType.ts

@@ -104,7 +104,6 @@ export async function generateOrAssignContentType(
       return undefined;
     }
     const res = await client.objects.getRendition(objectId, {
-      max_hw: 1024,
       format: ImageRenditionFormat.jpeg,
       generate_if_missing: true,
     });

package/src/activities/notifyWebhook.ts

@@ -25,7 +25,6 @@ export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyW
 
     const body = method === 'POST' ? JSON.stringify({
         ...requestPayload,
-        ...params
     }) : undefined
 
     log.info(`Notifying webhook at ${target_url}`);
@@ -48,4 +47,4 @@ export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyW
 
     return { status: res.status, message: res.statusText, url: res.url }
 
-}
+}

package/src/activities/renditions/generateImageRendition.ts

@@ -27,7 +27,7 @@ export async function generateImageRendition(
     // Fix: Use maxHeightWidth if max_hw is not provided
     const params = {
         ...originParams,
-        max_hw: originParams.max_hw || (originParams as any).maxHeightWidth || 1024, // Default to 1024 if both are missing
+        max_hw: originParams.max_hw || (originParams as any).maxHeightWidth || 1596, // Default to 1596 if both are missing
         format: originParams.format || (originParams as any).format_output || "png", // Default to png if format is missing
     };
 
@@ -49,11 +49,6 @@ export async function generateImageRendition(
         throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
     }
 
-    if (!inputObject.content?.source) {
-        log.error(`Document ${objectId} has no etag or source`);
-        throw new DocumentNotFoundError(`Document ${objectId} has no etag or source`, [objectId]);
-    }
-
     if (!params.format) {
         log.error(`Format not found`);
         throw new WorkflowParamNotFoundError(`format`);

package/src/conversion/image.test.ts

@@ -20,7 +20,7 @@ const execAsync = promisify(exec);
 
 describe("ImageMagick image resizing", () => {
     test("should resize an image to a maximum height or width using ImageMagick", async () => {
-        const max_hw = 1024;
+        const max_hw = 1596;
         const format = "jpeg";
         const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
 
@@ -48,7 +48,7 @@ describe("ImageMagick image resizing", () => {
     });
 
     test("should throw an error for non-existent input file", async () => {
-        const max_hw = 1024;
+        const max_hw = 1596;
         const format = "jpeg";
         const nonExistentPath = path.join(__dirname, "non-existent-image.jpg");
 
@@ -60,7 +60,7 @@ describe("ImageMagick image resizing", () => {
     });
 
     test("should throw error with empty format", async () => {
-        const max_hw = 1024;
+        const max_hw = 1596;
         const format = "";
         const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
 

package/src/conversion/image.ts

@@ -7,11 +7,13 @@ const execFile = promisify(execFileCallback);
 
 /**
  * Resizes an image to a maximum height or width using ImageMagick
- * with progressive loading when supported
+ * with progressive loading when supported and colorspace correction
  * @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)
+ * @param colorspaceCorrection Enable colorspace correction (defaults to true), not recommended for Q8 image magick.
+ * @param colorspace Colorspace to use for processing ('RGB', 'LAB', 'LUV', 'sigmoidal') (defaults to 'RGB')
  * @returns Path to the resized image
  */
 export async function imageResizer(
@@ -19,8 +21,10 @@ export async function imageResizer(
     max_hw: number,
     format: string,
     progressive: boolean = true,
+    colorspaceCorrection: boolean = true,
+    colorspace: 'RGB' | 'LAB' | 'LUV' | 'sigmoidal' = 'RGB'
 ): Promise<string> {
-    log.info(`[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}`);
+    log.info(`[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}, colorspaceCorrection: ${colorspaceCorrection ? colorspace : 'disabled'}`);
 
     const allowedFormats = ["jpg", "jpeg", "png", "webp"];
 
@@ -72,13 +76,71 @@ export async function imageResizer(
         log.info(`Resizing image using ImageMagick: ${inputPath} -> ${outputPath}`);
 
         const command = `convert`
-        const args = [
-            inputPath,
-            "-resize",
-            `${max_hw}x${max_hw}>`,
-            ...(conversionOption ? conversionOption.split(" ") : []),
-            outputPath,
-        ];
+        let args = [inputPath];
+
+        // https://usage.imagemagick.org/filter/nicolas/#downsample
+        // Add colorspace correction if enabled
+        if (colorspaceCorrection) {
+            switch (colorspace) {
+                case 'RGB':
+                    // Linear light, recommended default
+                    // Convert from sRGB to linear RGB for processing
+                    args.push("-colorspace", "RGB");
+                    log.info("Using linear RGB colorspace for resize processing");
+                    break;
+                case 'LAB':
+                    // Perceptual linear light
+                    // Use LAB colorspace which separates intensity from color
+                    // Better for avoiding color clipping and distortion
+                    args.push("-colorspace", "LAB");
+                    log.info("Using LAB colorspace for resize processing");
+                    break;
+                case 'LUV':
+                    // Perceptual linear light
+                    // Alternative to LAB with perceptually uniform color deltas
+                    args.push("-colorspace", "LUV");
+                    log.info("Using LUV colorspace for resize processing");
+                    break;
+                case 'sigmoidal':
+                    // Sigmoidal colorspace modification to reduce ringing artifacts
+                    args.push("-colorspace", "RGB");
+                    args.push("+sigmoidal-contrast", "6.5,50%");
+                    log.info("Using sigmoidal contrast modification for resize processing");
+                    break;
+            }
+        }
+
+        // Add JPEG shrink-on-load optimization
+        args.push("-define", `jpeg:size=${max_hw * 3}x${max_hw * 3}`);
+
+        // Resize operation
+        args.push("-resize", `${max_hw}x${max_hw}>`);
+
+        // Restore colorspace after processing
+        if (colorspaceCorrection) {
+            switch (colorspace) {
+                case 'RGB':
+                case 'LAB':
+                case 'LUV':
+                    // Convert back to sRGB for output
+                    args.push("-colorspace", "sRGB");
+                    break;
+                case 'sigmoidal':
+                    // Restore from sigmoidal modification and convert to sRGB
+                    args.push("-sigmoidal-contrast", "6.5,50%");
+                    args.push("-colorspace", "sRGB");
+                    break;
+            }
+        }
+
+        // Add progressive/interlace options
+        if (conversionOption) {
+            args.push(...conversionOption.split(" "));
+        }
+
+        // Output path
+        args.push(outputPath);
+
         log.info(`ImageMagick command: ${command} ${args.join(" ")}`);
 
         const { stderr } = await execFile(command, args);
@@ -100,4 +162,4 @@ export async function imageResizer(
         log.error(`Image conversion failed: ${errorMessage}`);
         throw new Error(`Image conversion failed: ${errorMessage}`);
     }
-}
+}

package/src/dsl/dsl-workflow.ts

@@ -151,8 +151,9 @@ async function handleError(originalError: any, basePayload: BaseActivityPayload,
 async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkflowExecutionPayload, vars: Vars, debug_mode?: boolean) {
     const resolvedVars = vars.resolve();
     if (step.vars) {
-        // copy user vars (from step definition) to the resolved vars
-        Object.assign(resolvedVars, step.vars);
+        // copy user vars (from step definition) to the resolved vars, resolving any expressions
+        const resolvedStepVars = vars.resolveParams(step.vars);
+        Object.assign(resolvedVars, resolvedStepVars);
     }
     if (debug_mode) {
         log.debug(`Workflow vars before starting child workflow ${step.name}`, { vars: resolvedVars });
@@ -182,8 +183,9 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
 async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkflowExecutionPayload, vars: Vars, debug_mode?: boolean) {
     const resolvedVars = vars.resolve();
     if (step.vars) {
-        // copy user vars (from step definition) to the resolved vars
-        Object.assign(resolvedVars, step.vars);
+        // copy user vars (from step definition) to the resolved vars, resolving any expressions
+        const resolvedStepVars = vars.resolveParams(step.vars);
+        Object.assign(resolvedVars, resolvedStepVars);
     }
     if (debug_mode) {
         log.debug(`Workflow vars before executing child workflow ${step.name}`, { vars: resolvedVars });

package/src/dsl/workflow-exec-child.test.ts

@@ -83,6 +83,35 @@ const steps2: DSLWorkflowStep[] = [
     }
 ]
 
+const steps3: DSLWorkflowStep[] = [
+    {
+        type: 'activity',
+        name: 'sayHelloFromParent',
+        output: 'parent',
+        import: ["name"],
+    },
+    {
+        type: 'workflow',
+        name: 'dslWorkflow',
+        output: 'child',
+        spec: {
+            name: 'testChildWorkflow',
+            steps: childSteps,
+            vars: {}
+        },
+        vars: {
+            storeUrl: 'store:${objectIds[0]}',
+            name: '${name}'
+        }
+    },
+    {
+        type: 'activity',
+        name: 'prepareResult',
+        import: ["parent", "child"],
+        output: 'result',
+    }
+]
+
 
 // ========== test env setup ==========
 
@@ -128,7 +157,6 @@ describe('DSL Workflow with child workflows', () => {
             vars: {},
             account_id: '123',
             project_id: '123',
-            timestamp: Date.now(),
             wf_rule_name: 'test',
             auth_token: 'test',
             config: {
@@ -173,7 +201,6 @@ describe('DSL Workflow with child workflows', () => {
             vars: {},
             account_id: '123',
             project_id: '123',
-            timestamp: Date.now(),
             wf_rule_name: 'test',
             auth_token: 'test',
             config: {
@@ -198,4 +225,48 @@ describe('DSL Workflow with child workflows', () => {
         expect(result).toEqual([`Parent: Hello, ${name}!`, `DSL Child: Hello, ${name}!`]);
 
     });
+
+    test('execute DSL child workflow with variable resolution', async () => {
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const name = 'Baz';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./test/test-child-workflow.ts", import.meta.url).pathname,
+            activities: { sayHelloFromParent, prepareResult, sayHelloFromDSLChild },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['doc123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            wf_rule_name: 'test',
+            auth_token: 'test',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                steps: steps3,
+                vars: {
+                    name,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test-vars',
+            taskQueue,
+        }));
+
+        expect(result).toEqual([`Parent: Hello, ${name}!`, `DSL Child: Hello, ${name}!`]);
+
+    });
 });

package/src/system/notifyWebhookWorkflow.ts

@@ -1,6 +1,6 @@
 
 import { log } from "@temporalio/workflow";
-import { ContentEventName, WorkflowExecutionPayload } from "@vertesia/common";
+import { 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";
@@ -18,13 +18,19 @@ const {
     },
 });
 
+export interface NotifyWebhookWorfklowParams {
+    endpoints: string[],
+    data: Record<string, any>
+}
+
 
-export async function notifyWebhookWorkflow(payload: WorkflowExecutionPayload): Promise<any> {
+export async function notifyWebhookWorkflow(payload: WorkflowExecutionPayload<NotifyWebhookWorfklowParams>): Promise<any> {
 
     const { objectIds, vars } = payload;
     const notifications = [];
-    const endpoints = vars?.webhooks || [];
-    const eventName = vars.event || ContentEventName.workflow_finished;
+    const endpoints = vars.endpoints ?? (vars as any).webhooks ?? [];
+    const data = vars.data ?? (vars as any).webhook_data ?? undefined;
+    const eventName = payload.event;
 
     if (!endpoints.length) {
         log.info(`No webhooks to notify`);
@@ -38,8 +44,7 @@ export async function notifyWebhookWorkflow(payload: WorkflowExecutionPayload):
             payload: {
                 object_ids: objectIds,
                 event: eventName,
-                data: vars.webhook_data ?? undefined,
-                vars
+                data
             }
         }).then(res => {
             log.info(`Webhook notified at ${ep} with response code: ${res.status}`, { res });