@vertesia/workflow 0.52.0 → 0.55.0

package/src/activities/generateOrAssignContentType.ts

@@ -1,11 +1,16 @@
 import { log } from "@temporalio/activity";
-import { ContentObjectTypeItem, CreateContentObjectTypePayload, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import {
+    ContentObjectTypeItem,
+    CreateContentObjectTypePayload,
+    DSLActivityExecutionPayload,
+    DSLActivitySpec,
+} from "@vertesia/common";
 import { ActivityContext, setupActivity } from "../dsl/setup/ActivityContext.js";
 import { TruncateSpec, truncByMaxTokens } from "../utils/tokens.js";
 import { InteractionExecutionParams, executeInteractionFromActivity } from "./executeInteraction.js";
 
-const INT_SELECT_DOCUMENT_TYPE = "sys:SelectDocumentType"
-const INT_GENERATE_METADATA_MODEL = "sys:GenerateMetadataModel"
+const INT_SELECT_DOCUMENT_TYPE = "sys:SelectDocumentType";
+const INT_GENERATE_METADATA_MODEL = "sys:GenerateMetadataModel";
 
 export interface GenerateOrAssignContentTypeParams extends InteractionExecutionParams {
     typesHint?: string[];
@@ -21,20 +26,21 @@ export interface GenerateOrAssignContentTypeParams extends InteractionExecutionP
     interactionNames?: {
         selectDocumentType?: string;
         generateMetadataModel?: string;
-    }
+    };
 }
 
 export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrAssignContentTypeParams> {
-    name: 'generateOrAssignContentType';
+    name: "generateOrAssignContentType";
 }
 
-export async function generateOrAssignContentType(payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>) {
+export async function generateOrAssignContentType(
+    payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>,
+) {
     const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
     const { params, client, objectId } = context;
 
     const interactionName = params.interactionNames?.selectDocumentType ?? INT_SELECT_DOCUMENT_TYPE;
 
-
     log.info("SelectDocumentType for object: " + objectId, { payload });
 
     const object = await client.objects.retrieve(objectId, "+text");
@@ -48,50 +54,66 @@ export async function generateOrAssignContentType(payload: DSLActivityExecutionP
         return { status: "skipped", message: "Object already has a type: " + object.type.name };
     }
 
-    if (!object || (!object.text && !object.content?.type?.startsWith("image/") && !object.content?.type?.startsWith("application/pdf"))) {
+    if (
+        !object ||
+        (!object.text &&
+            !object.content?.type?.startsWith("image/") &&
+            !object.content?.type?.startsWith("application/pdf"))
+    ) {
         log.info(`Object ${objectId} not found or text is empty and not an image`, { object });
         return { status: "failed", error: "no-text" };
     }
 
-    const types = await client.types.list();
+    const types = await client.types.list(undefined, {
+        schema: true,
+    });
 
     //make a list of all existing types, and add hints if any
-    const existing_types = types.filter(t => !["DocumentPart", "Rendition"].includes(t.name));
-    const content = object.text ? truncByMaxTokens(object.text, params.truncate || 4000) : undefined;
+    const existing_types = types.filter((t) => !["DocumentPart", "Rendition"].includes(t.name));
+    const content = object.text ? truncByMaxTokens(object.text, params.truncate || 30000) : undefined;
 
     const getImage = async () => {
         if (object.content?.type?.includes("pdf") && object.text?.length && object.text?.length < 100) {
-            return "store:" + objectId
+            return "store:" + objectId;
         }
         if (!object.content?.type?.startsWith("image/")) {
             return undefined;
         }
-        const res = await client.objects.getRendition(objectId, { max_hw: 1024, format: "image/png", generate_if_missing: true });
+        const res = await client.objects.getRendition(objectId, {
+            max_hw: 1024,
+            format: "image/png",
+            generate_if_missing: true,
+        });
         if (!res.rendition && res.status === "generating") {
             //throw to try again
             throw new Error(`Rendition for object ${objectId} is in progress`);
         } else if (res.rendition) {
             return "store:" + objectId;
         }
-    }
+    };
 
     const fileRef = await getImage();
 
-    log.info("Execute SelectDocumentType interaction on content with \nexisting types: " + existing_types.map(t => t.name).join(","));
+    log.info(
+        "Execute SelectDocumentType interaction on content with \nexisting types - passing full types: " +
+            existing_types.filter((t) => !t.tags?.includes("system")),
+    );
 
     const res = await executeInteractionFromActivity(client, interactionName, params, {
-        existing_types, content, image: fileRef
+        existing_types,
+        content,
+        image: fileRef,
     });
 
     log.info("Selected Content Type Result: " + JSON.stringify(res.result));
 
     //if type is not identified or not present in the database, generate a new type
-    let selectedType: { id: string, name: string } | undefined = undefined;
+    let selectedType: { id: string; name: string } | undefined = undefined;
 
-    selectedType = types.find(t => t.name === res.result.document_type);
+    selectedType = types.find((t) => t.name === res.result.document_type);
 
     if (!selectedType) {
-        log.warn("Document type not idenfified: starting type generation");
+        log.warn("Document type not identified: starting type generation");
         const newType = await generateNewType(context, existing_types, content, fileRef);
         selectedType = { id: newType.id, name: newType.name };
     }
@@ -109,24 +131,28 @@ export async function generateOrAssignContentType(payload: DSLActivityExecutionP
     return {
         id: selectedType.id,
         name: selectedType.name,
-        isNew: !types.find(t => t.name === selectedType.name)
+        isNew: !types.find((t) => t.name === selectedType.name),
     };
 }
 
-async function generateNewType(context: ActivityContext<GenerateOrAssignContentTypeParams>, existing_types: ContentObjectTypeItem[], content?: string, fileRef?: string) {
+async function generateNewType(
+    context: ActivityContext<GenerateOrAssignContentTypeParams>,
+    existing_types: ContentObjectTypeItem[],
+    content?: string,
+    fileRef?: string,
+) {
     const { client, params } = context;
 
     const project = await context.fetchProject();
     const interactionName = params.interactionNames?.generateMetadataModel ?? INT_GENERATE_METADATA_MODEL;
 
     const genTypeRes = await executeInteractionFromActivity(client, interactionName, params, {
-        existing_types: existing_types.map(t => t.name),
+        existing_types,
         content: content,
         human_context: project?.configuration?.human_context ?? undefined,
-        image: fileRef ? fileRef : undefined
+        image: fileRef ? fileRef : undefined,
     });
 
-
     if (!genTypeRes.result.document_type) {
         log.error("No name generated for type", genTypeRes);
         throw new Error("No name generated for type");
@@ -137,10 +163,10 @@ async function generateNewType(context: ActivityContext<GenerateOrAssignContentT
         name: genTypeRes.result.document_type,
         object_schema: genTypeRes.result.metadata_schema,
         is_chunkable: genTypeRes.result.is_chunkable,
-    }
+        table_layout: genTypeRes.result.table_layout,
+    };
 
     const type = await client.types.create(typeData);
 
     return type;
-
 }

package/src/activities/getObjectFromStore.ts

@@ -12,7 +12,7 @@ export interface GetObject extends DSLActivitySpec<GetObjectParams> {
 }
 
 /**
- * We are using a union type for the status parameter since typescript enumbs breaks the workflow code generation
+ * We are using a union type for the status parameter since typescript enums breaks the workflow code generation
  * @param objectId
  * @param status
  */

package/src/activities/handleError.ts

@@ -0,0 +1,25 @@
+import { ContentObjectStatus, DSLActivityExecutionPayload } from "@vertesia/common";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { log } from "@temporalio/activity"
+
+export interface HandleDslErrorParams {
+    errorMessage: string;
+}
+
+export async function handleDslError(payload: DSLActivityExecutionPayload<HandleDslErrorParams>): Promise<void> {
+    const { client, params, objectId } = await setupActivity<HandleDslErrorParams>(payload);
+    const isIntake = payload.workflow_name === "StandardDocumentIntake" || payload.workflow_name === "StandardImageIntake";
+    if (!isIntake) {
+        log.warn(`Workflow execution failed, but no error handler registered for this workflow: ${payload.workflow_name}`,
+            { error: params.errorMessage },
+        );
+        return;
+    }
+
+    try {
+        await client.objects.update(objectId, { status: ContentObjectStatus.failed });
+    } catch (e) {
+        log.error("Failed to handle error", { error: e });
+    }
+    return;
+}

package/src/activities/index-dsl.ts

@@ -11,6 +11,7 @@ export { generateEmbeddings } from "./generateEmbeddings.js";
 export { generateImageRendition } from "./generateImageRendition.js";
 export { generateOrAssignContentType } from "./generateOrAssignContentType.js";
 export { getObjectFromStore } from "./getObjectFromStore.js";
+export { handleDslError } from "./handleError.js";
 export { convertPdfToStructuredText } from "./media/processPdfWithTextract.js";
 export { transcribeMedia } from "./media/transcribeMediaWithGladia.js";
 export { notifyWebhook } from "./notifyWebhook.js";

package/src/activities/index.ts

@@ -2,4 +2,3 @@
  * Here we export all activities to be registered with the temporal worker
  */
 export * from "./index-dsl.js";
-export * from "../iterative-generation/activities/index.js";

package/src/activities/media/processPdfWithTextract.ts

@@ -91,11 +91,11 @@ export async function convertPdfToStructuredText(payload: DSLActivityExecutionPa
 
         if (jobStatus === "SUCCEEDED") {
             log.info(`Job ${jobId} succeeded, saving results`, { jobId });
-            const ftext = await processor.processResults(jobId);
-            const tokensData = countTokens(ftext);
-            const etag = object.content.etag ?? md5(ftext);
+            const fText = await processor.processResults(jobId);
+            const tokensData = countTokens(fText);
+            const etag = object.content.etag ?? md5(fText);
             const updateData: CreateContentObjectPayload = {
-                text: ftext,
+                text: fText,
                 text_etag: etag,
                 tokens: {
                     ...tokensData,

package/src/activities/media/transcribeMediaWithGladia.ts

@@ -74,7 +74,7 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
 
 
 function generateCallbackUrlForGladia(baseUrl: string, authToken: string, taskToken: string, objectId: string) {
-    return `${baseUrl}/api/v1/webhooks/gladia/${objectId}?auth_token=${authToken}&task_token=${taskToken}`;
+    return `${baseUrl}/api/v1/webhooks/gladia/${objectId}?access_token=${authToken}&task_token=${taskToken}`;
 }
 
 interface GladiaTranscriptRequestResponse {

package/src/activities/setDocumentStatus.ts

@@ -11,7 +11,7 @@ export interface SetDocumentStatus extends DSLActivitySpec<SetDocumentStatusPara
 }
 
 /**
- * We are using a union type for the status parameter since typescript enumbs breaks the workflow code generation
+ * We are using a union type for the status parameter since typescript enums breaks the workflow code generation
  * @param objectId
  * @param status
  */

package/src/conversion/TextractProcessor.ts

@@ -472,21 +472,21 @@ export class TextractProcessor {
         }
     
         // Build final output
-        let fulltext = '';
+        let fullText = '';
         let imgNumber = 1;
         let tableNumber = 1;
         for (const page of pageContents) {
-            fulltext += `<page number="${page.pageNumber}">\n`;
+            fullText += `<page number="${page.pageNumber}">\n`;
             for (const block of page.blocks) {
                 if (block.type === 'text') {
-                    fulltext += `<text>\n${block.content}\n</text>\n\n`;
+                    fullText += `<text>\n${block.content}\n</text>\n\n`;
                 } else if (block.type === 'table') {
                     const confidenceAttr = block.confidence !== undefined && this.includeConfidenceInTables
                         ? ` confidence="${block.confidence.toFixed(2)}"`
                         : '';
-                    fulltext += `<table number=${tableNumber++} type="csv" ${confidenceAttr}>\n`;
-                    fulltext += `${block.content}\n`;
-                    fulltext += `</table>\n\n`;
+                    fullText += `<table number=${tableNumber++} type="csv" ${confidenceAttr}>\n`;
+                    fullText += `${block.content}\n`;
+                    fullText += `</table>\n\n`;
                 } else if (block.type === 'image') {
                     // Include geometry if you like
                     const leftAttr = block.left ? ` left="${block.left.toFixed(4)}"` : '';
@@ -494,13 +494,13 @@ export class TextractProcessor {
                     const widthAttr = block.width ? ` width="${block.width.toFixed(4)}"` : '';
                     const heightAttr = block.height ? ` height="${block.height.toFixed(4)}"` : '';
     
-                    fulltext += `<image id="${imgNumber++}" ${leftAttr}${topAttr}${widthAttr}${heightAttr}>\n${block.content.trim()}\n</image>\n\n`;
+                    fullText += `<image id="${imgNumber++}" ${leftAttr}${topAttr}${widthAttr}${heightAttr}>\n${block.content.trim()}\n</image>\n\n`;
                 }
             }
-            fulltext += `</page>\n\n`;
+            fullText += `</page>\n\n`;
         }
     
-        return fulltext;
+        return fullText;
     }
     
 }

package/src/conversion/image.ts

@@ -20,6 +20,8 @@ export async function imageResizer(
     format: string,
     progressive: boolean = true,
 ): Promise<string> {
+    log.info(`[image-resizer] Resizing image: ${inputPath} to max_hw: ${max_hw}, format: ${format}, progressive: ${progressive}`);
+
     const allowedFormats = ["jpg", "jpeg", "png", "webp"];
 
     if (!format || format.trim() === "") {
@@ -69,13 +71,17 @@ export async function imageResizer(
 
         log.info(`Resizing image using ImageMagick: ${inputPath} -> ${outputPath}`);
 
-        const { stderr } = await execFile("convert", [
+        const command = `convert`
+        const args = [
             inputPath,
             "-resize",
             `${max_hw}x${max_hw}>`,
             ...(conversionOption ? conversionOption.split(" ") : []),
             outputPath,
-        ]);
+        ];
+        log.info(`ImageMagick command: ${command} ${args.join(" ")}`);
+
+        const { stderr } = await execFile(command, args);
 
         if (stderr) {
             log.warn(`ImageMagick warning: ${stderr}`);

package/src/conversion/markitdown.ts

@@ -0,0 +1,41 @@
+import { log } from "@temporalio/activity";
+import { spawn } from "child_process";
+import fs from "fs";
+import tmp from "tmp";
+
+export function markdownWithMarkitdown(buffer: Buffer, ext?: string): Promise<string> {
+    const inputFile = tmp.fileSync({ postfix: ext });
+    const targetFileName = tmp.tmpNameSync({ postfix: ".md" });
+
+    fs.writeSync(inputFile.fd, buffer);
+
+    return new Promise((resolve, reject) => {
+        const tool = "markitdown";
+        log.info(`Converting document to markdown with ${tool}`, { inputFile: inputFile.name, targetFileName });
+
+        const command = spawn(tool, [inputFile.name, "-o", targetFileName]);
+
+        command.on("exit", function (code) {
+            if (code) {
+                reject(new Error(`${tool} exited with code ${code}`));
+            }
+        });
+
+        command.on("close", function (code) {
+            if (code) {
+                reject(new Error(`${tool} exited with code ${code}`));
+            } else {
+                return fs.readFile(targetFileName, "utf8", (err, data) => {
+                    if (err) {
+                        reject(err);
+                    }
+                    return resolve(data);
+                });
+            }
+        });
+
+        command.on("error", (err) => {
+            reject(err);
+        });
+    });
+}

package/src/conversion/mutool.ts

@@ -120,7 +120,7 @@ export async function pdfToImages(file: Buffer | string, pages?: number[]): Prom
 
 
 /**
- * Get somes pages from a PDF to create a new one
+ * Get some pages from a PDF to create a new one
  */
 
 export async function pdfExtractPages(file: Buffer | string, pages: number[]): Promise<string> {

package/src/conversion/pandoc.test.ts

@@ -2,7 +2,7 @@ import { MockActivityEnvironment, TestWorkflowEnvironment } from '@temporalio/te
 import fs from 'fs';
 import path from 'path';
 import { beforeAll, expect, test } from 'vitest';
-import { manyToMarkdown } from '../conversion/pandoc';
+import { markdownWithPandoc } from '../conversion/pandoc';
 
 
 let testEnv: TestWorkflowEnvironment;
@@ -19,6 +19,6 @@ test('should convert docx to markdown', async () => {
     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');
+    const result = await activityContext.run(markdownWithPandoc, Buffer.from(docx), 'docx');
     expect(result).to.include('confidential');
 });

package/src/conversion/pandoc.ts

@@ -1,44 +1,40 @@
-import { log } from '@temporalio/activity';
-import { spawn } from 'child_process';
-import { PassThrough } from 'stream';
-
-
-export function manyToMarkdown(buffer: Buffer, fromFormat: string): Promise<string> {
-
-  const fromType = undefined;
-
-  return new Promise((resolve, reject) => {
-    log.info(`Converting ${fromType} to markdown`);
-    const input = new PassThrough();
-    input.end(buffer);
-
-    let result: string[] = [];
-
-    const command = spawn("pandoc", ["-t", "markdown", '-f', fromFormat], {
-      stdio: 'pipe',
-    });
-    input.pipe(command.stdin);
-
-    command.stdout.on('data', function (data: string) {
-      result.push(data.toString());
-    });
-    command.on('exit', function (code) {
-      if (code) {
-        reject(new Error(`pandoc exited with code ${code}`));
-      }
+import { log } from "@temporalio/activity";
+import { spawn } from "child_process";
+import { PassThrough } from "stream";
+
+export function markdownWithPandoc(buffer: Buffer, fromFormat: string): Promise<string> {
+    const fromType = undefined;
+
+    return new Promise((resolve, reject) => {
+        log.info(`Converting ${fromType} to markdown`);
+        const input = new PassThrough();
+        input.end(buffer);
+
+        let result: string[] = [];
+
+        const command = spawn("pandoc", ["-t", "markdown", "-f", fromFormat], {
+            stdio: "pipe",
+        });
+        input.pipe(command.stdin);
+
+        command.stdout.on("data", function (data: string) {
+            result.push(data.toString());
+        });
+        command.on("exit", function (code) {
+            if (code) {
+                reject(new Error(`pandoc exited with code ${code}`));
+            }
+        });
+        command.on("close", function (code) {
+            if (code) {
+                reject(new Error(`pandoc exited with code ${code}`));
+            } else {
+                resolve(result.join(""));
+            }
+        });
+
+        command.on("error", (err) => {
+            reject(err);
+        });
     });
-    command.on('close', function (code) {
-      if (code) {
-        reject(new Error(`pandoc exited with code ${code}`));
-      } else {
-        resolve(result.join(''))
-      }
-    });
-
-    command.on('error', (err) => {
-      reject(err);
-    });
-
-  });
-
 }

package/src/dsl/dsl-workflow.ts

@@ -1,15 +1,30 @@
+import {
+    ActivityInterfaceFor,
+    ActivityOptions,
+    CancellationScope,
+    executeChild,
+    isCancellation,
+    log,
+    patched,
+    proxyActivities,
+    startChild,
+    UntypedActivities,
+} from "@temporalio/workflow";
 import {
     DSLActivityExecutionPayload,
     DSLActivityOptions,
     DSLActivitySpec,
     DSLChildWorkflowStep,
     DSLWorkflowExecutionPayload,
+    DSLWorkflowSpec,
+    getDocumentIds,
     WorkflowExecutionPayload
 } from "@vertesia/common";
-import { ActivityInterfaceFor, ActivityOptions, executeChild, log, proxyActivities, startChild, UntypedActivities } from "@temporalio/workflow";
 import ms, { StringValue } from 'ms';
 import { ActivityParamNotFound, NoDocumentFound, WorkflowParamNotFound } from "../errors.js";
 import { Vars } from "./vars.js";
+import { HandleDslErrorParams } from "../activities/handleError.js";
+import * as activities from "../activities/index.js";
 
 interface BaseActivityPayload extends WorkflowExecutionPayload {
     workflow_name: string;
@@ -30,7 +45,7 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
     if (!definition) {
         throw new WorkflowParamNotFound("workflow");
     }
-    // the base payload wiull be used to create the activities payload
+    // the base payload will be used to create the activities payload
     const basePayload: BaseActivityPayload = {
         ...payload,
         workflow_name: definition.name,
@@ -42,9 +57,9 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
         ...convertDSLActivityOptions(definition.options),
         startToCloseTimeout: "5 minute",
         retry: {
-            initialInterval: '30s',
+            initialInterval: '10s',
             backoffCoefficient: 2,
-            maximumAttempts: 20,
+            maximumAttempts: 10,
             maximumInterval: 100 * 30 * 1000, //ms
             nonRetryableErrorTypes: [
                 NoDocumentFound.name,
@@ -58,7 +73,7 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
     });
     const defaultProxy = proxyActivities(defaultOptions);
     log.debug("Default activity proxy is ready");
-    // merge default vars with the payload vars and add objectIds and obejctId
+    // merge default vars with the payload vars and add objectIds and objectId
     const vars = new Vars({
         ...definition.vars,
         ...payload.vars,
@@ -68,6 +83,26 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
 
     log.info("Executing workflow", { payload });
 
+    // TODO(mhuang): remove patch when all workflows are migrated to v2
+    //   It avoids breaking the ongoing workflow execution running in v1 and also allows us to
+    //   deploy the new error handler in production.
+    //   See https://docs.temporal.io/develop/typescript/versioning
+    if (patched('dsl-workflow-error-handling')) {
+        // v2: new version with error handler
+        try {
+            await executeSteps(definition, payload, basePayload, vars, defaultProxy, defaultOptions);
+        } catch (e) {
+            await handleError(e, basePayload, defaultOptions);
+        }
+    } else {
+        // v1: old version without error handler, deprecated since v0.52.0
+        await executeSteps(definition, payload, basePayload, vars, defaultProxy, defaultOptions);
+    }
+
+    return vars.getValue(definition.result || 'result');
+}
+
+async function executeSteps(definition: DSLWorkflowSpec, payload: DSLWorkflowExecutionPayload, basePayload: BaseActivityPayload, vars: Vars, defaultProxy: ActivityInterfaceFor<UntypedActivities>, defaultOptions: ActivityOptions) {
     if (definition.steps) {
         for (const step of definition.steps) {
             const stepType = step.type;
@@ -89,7 +124,32 @@ export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {
     } else {
         throw new Error("No steps or activities found in the workflow definition");
     }
-    return vars.getValue(definition.result || 'result');
+}
+
+async function handleError(originalError: any, basePayload: BaseActivityPayload, defaultOptions: ActivityOptions) {
+    const { handleDslError } = proxyActivities<typeof activities>(defaultOptions);
+
+    const payload = dslActivityPayload(
+        basePayload,
+        {
+            name: "handleDslError",
+            params: { errorMessage: originalError.message },
+        } as DSLActivitySpec,
+        { errorMessage: originalError.message } satisfies HandleDslErrorParams,
+    )
+
+    if (isCancellation(originalError)) {
+        log.warn(`Workflow execution cancelled, executing error handler to update document status`, { error: originalError });
+        // Cleanup logic must be in a nonCancellable scope
+        // If we'd run cleanup outside of a nonCancellable scope it would've been cancelled
+        // before being started because the Workflow's root scope is cancelled.
+        // see https://docs.temporal.io/develop/typescript/cancellation
+        await CancellationScope.nonCancellable(() => handleDslError(payload));
+    } else {
+        log.warn(`Workflow execution failed, executing error handler to update document status`, { error: originalError });
+        handleDslError(payload);
+    }
+    throw originalError;
 }
 
 async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkflowExecutionPayload, vars: Vars, debug_mode?: boolean) {
@@ -101,14 +161,18 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
     if (debug_mode) {
         log.debug(`Workflow vars before starting child workflow ${step.name}`, { vars: resolvedVars });
     }
-    //@ts-ignore
     const handle = await startChild(step.name, {
         ...step.options,
         args: [{
             ...payload,
             workflow: step.spec,
             vars: resolvedVars
-        }]
+        }],
+        searchAttributes: {
+            AccountId: [payload.account_id],
+            DocumentId: getDocumentIds(payload),
+            ProjectId: [payload.project_id],
+        },
     });
     if (step.output) {
         vars.setValue(step.output, handle.workflowId);
@@ -122,16 +186,20 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
         Object.assign(resolvedVars, step.vars);
     }
     if (debug_mode) {
-        log.debug(`Workflow vars before excuting child workflow ${step.name}`, { vars: resolvedVars });
+        log.debug(`Workflow vars before executing child workflow ${step.name}`, { vars: resolvedVars });
     }
-    //@ts-ignore
     const result = await executeChild(step.name, {
         ...step.options,
         args: [{
             ...payload,
             workflow: step.spec,
             vars: resolvedVars,
-        }]
+        }],
+        searchAttributes: {
+            AccountId: [payload.account_id],
+            DocumentId: getDocumentIds(payload),
+            ProjectId: [payload.project_id],
+        },
     });
 
     if (step.output) {
@@ -149,7 +217,7 @@ async function runActivity(activity: DSLActivitySpec, basePayload: BaseActivityP
         log.debug(`Workflow vars before executing activity ${activity.name}`, { vars: vars.resolve() });
     }
     if (activity.condition && !vars.match(activity.condition)) {
-        log.info("Activity skiped: condition not satisfied", activity.condition);
+        log.info("Activity skipped: condition not satisfied", activity.condition);
         return;
     }
     const importParams = vars.createImportVars(activity.import);