@vertesia/workflow 0.78.0 → 0.79.1

package/src/activities/media/transcribeMediaWithGladia.ts

@@ -1,6 +1,6 @@
-import { DSLActivityExecutionPayload, DSLActivitySpec, GladiaConfiguration, SupportedIntegrations } from "@vertesia/common";
+import { DSLActivityExecutionPayload, DSLActivitySpec, GladiaConfiguration, SupportedIntegrations, AUDIO_RENDITION_NAME, VideoMetadata, ContentNature } from "@vertesia/common";
 import { activityInfo, CompleteAsyncError, log } from "@temporalio/activity";
-import { FetchClient } from "@vertesia/api-fetch-client";
+import { FetchClient, RequestError } from "@vertesia/api-fetch-client";
 import { setupActivity } from "../../dsl/setup/ActivityContext.js";
 import { DocumentNotFoundError } from "../../errors.js";
 import { TextExtractionResult, TextExtractionStatus } from "../../index.js";
@@ -27,7 +27,12 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
 
     const gladiaConfig = await client.projects.integrations.retrieve(payload.project_id, SupportedIntegrations.gladia) as GladiaConfiguration | undefined;
     if (!gladiaConfig || !gladiaConfig.enabled) {
-        throw new DocumentNotFoundError("Gladia integration not enabled");
+        return {
+            hasText: false,
+            objectId,
+            status: TextExtractionStatus.error,
+            error: "Gladia integration not enabled",
+        }
     }
 
     const object = await client.objects.retrieve(objectId, "+text");
@@ -42,37 +47,63 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
         throw new DocumentNotFoundError(`No source found for object ${objectId}`);
     }
 
-    const mediaUrl = await client.store.objects.getContentSource(objectId).then(res => res.source);
+    // Check for audio rendition in video metadata (preferred for videos)
+    let mediaSource: string = object.content.source;
+    if (object.metadata?.type === ContentNature.Video) {
+        const videoMetadata = object.metadata as VideoMetadata;
+        const audioRendition = videoMetadata.renditions?.find(r => r.name === AUDIO_RENDITION_NAME);
+        if (audioRendition?.content?.source) {
+            mediaSource = audioRendition.content.source;
+            log.info(`Found audio rendition for video object ${objectId}`, { mediaSource });
+        }
+    }
+
+    // Get download URL for the media source
+    const { url: mediaUrl } = await client.files.getDownloadUrl(mediaSource);
 
     if (!mediaUrl) {
-        throw new DocumentNotFoundError(`Error fetching source ${object.content.source}`);
+        throw new DocumentNotFoundError(`Error fetching media URL for ${mediaSource}`);
     }
 
+    log.info(`Using media URL for transcription`, { objectId, mediaUrl: mediaSource });
+
     const taskToken = Buffer.from(activityInfo().taskToken).toString('base64url');
     const callbackUrl = generateCallbackUrlForGladia(client.store.baseUrl, payload.auth_token, taskToken, objectId);
 
     log.info(`Transcribing media ${mediaUrl} with Gladia`, { objectId, callbackUrl });
 
-    const res = await gladiaClient.post("/transcription", {
-        payload: {
-            audio_url: mediaUrl,
-            callback_url: callbackUrl,
-            diarization_enhanced: true,
-            enable_code_switching: true,
-            subtitles: true,
-            subtitles_config: {
-                formats: ["vtt"],
+    try {
+        const res = await gladiaClient.post("/transcription", {
+            payload: {
+                audio_url: mediaUrl,
+                callback_url: callbackUrl,
+                diarization_enhanced: true,
+                enable_code_switching: true,
+                subtitles: true,
+                subtitles_config: {
+                    formats: ["vtt"],
+                }
+            }
+        }) as GladiaTranscriptRequestResponse;
+
+        log.info(`Transcription request sent to Gladia`, { objectId, res });
+        throw new CompleteAsyncError();
+
+    } catch (error: any) {
+        if (error instanceof RequestError && error.status === 422) {
+            return {
+                hasText: false,
+                objectId,
+                status: TextExtractionStatus.error,
+                error: `Gladia transcription error: ${error.message}`,
             }
+        } else {
+            log.error(`Error sending transcription request to Gladia for object ${objectId}`, { error });
+            throw error;
         }
-    }) as GladiaTranscriptRequestResponse;
-
-    log.info(`Transcription request sent to Gladia`, { objectId, res });
-
-    throw new CompleteAsyncError();
-
+    }
 }
 
-
 function generateCallbackUrlForGladia(baseUrl: string, authToken: string, taskToken: string, objectId: string) {
     return `${baseUrl}/api/v1/webhooks/gladia/${objectId}?access_token=${authToken}&task_token=${taskToken}`;
 }

package/src/activities/notifyWebhook.test.ts

@@ -1,32 +1,134 @@
 import {
   MockActivityEnvironment,
-  TestWorkflowEnvironment,
 } from "@temporalio/testing";
-import { beforeAll, describe, expect, test } from "vitest";
-import { notifyWebhook, NotifyWebhook } from "./notifyWebhook.js";
+import { ContentEventName, DSLActivityExecutionPayload } from "@vertesia/common";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { notifyWebhook, NotifyWebhookParams } from "./notifyWebhook.js";
 
-let testEnv: TestWorkflowEnvironment;
-let activityContext: MockActivityEnvironment;
+// Mock fetch globally
+vi.stubGlobal('fetch', vi.fn());
+
+let testEnv: MockActivityEnvironment;
+const mockFetch = vi.mocked(fetch);
 
 beforeAll(async () => {
-  testEnv = await TestWorkflowEnvironment.createLocal();
-  activityContext = new MockActivityEnvironment();
+  testEnv = new MockActivityEnvironment();
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
 });
 
-// https://github.com/becomposable/studio/issues/432 Skip tests
-// Cannot read properties of undefined (reading 'params')
+const defaultParams = {
+  webhook: "https://vertesia.test",
+  method: "POST" as const,
+  detail: { message: "Hello World" },
+  workflow_id: "wf_id",
+  workflow_type: "wfFuncName",
+  workflow_run_id: "wf_run_id",
+  event_name: "completed",
+} satisfies NotifyWebhookParams;
+
+// Helper function to create test payload
+const createTestPayload = (params: Partial<NotifyWebhookParams> = {}): DSLActivityExecutionPayload<NotifyWebhookParams> => {
+  const mergedParams = { ...defaultParams, ...params };
+  return {
+    auth_token: "unset",
+    account_id: "unset",
+    project_id: "unset",
+    params: mergedParams,
+    config: {
+      studio_url: "http://mock-studio",
+      store_url: "http://mock-store",
+    },
+    workflow_name: "",
+    event: ContentEventName.create,
+    objectIds: [],
+    vars: {},
+    activity: { name: "notifyWebhook", params: mergedParams }
+  };
+};
+
 describe("Webhook should be notified", () => {
-  test.skip("test POST", async () => {
-    const activityConfig = {
-      name: "notifyWebhook",
-      params: {
-        target_url: "https://en5zdcyvn4dc3.x.pipedream.net",
-        method: "POST",
-        payload: { message: "Hello World" },
+  it("test POST success", async () => {
+    // Mock successful response
+    const mockResponse = {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      url: defaultParams.webhook
+    };
+    mockFetch.mockResolvedValueOnce(mockResponse as Response);
+
+    const payload = createTestPayload();
+    const res = await testEnv.run(notifyWebhook, payload);
+
+    // Verify fetch was called with correct parameters
+    expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello World' }),
+      headers: {
+        'Content-Type': 'application/json',
       },
-    } satisfies NotifyWebhook;
+    });
 
-    const res = await activityContext.run(notifyWebhook, activityConfig);
-    expect(res).toBeDefined();
+    // Verify response
+    expect(res).toEqual({
+      status: 200,
+      message: 'OK',
+      url: defaultParams.webhook
+    });
   });
+
+  it("test POST server error", async () => {
+    // Mock error response with response body
+    const mockResponse = {
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      url: defaultParams.webhook,
+      text: vi.fn().mockResolvedValue('{"error": "Database connection failed", "code": "DB_ERROR"}')
+    } as unknown as Response;
+    mockFetch.mockResolvedValueOnce(mockResponse);
+
+    const payload = createTestPayload();
+
+    // Expect the function to throw an error with response payload
+    await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow(
+      `Webhook Notification to ${defaultParams.webhook} failed with status: 500 Internal Server Error - Response: {"error": "Database connection failed", "code": "DB_ERROR"}`
+    );
+
+    // Verify fetch was called with correct parameters
+    expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello World' }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    // Verify that text() was called to read the response
+    expect(mockResponse.text).toHaveBeenCalled();
+  });
+
+  it("test POST network error", async () => {
+    // Mock fetch to throw a network error
+    const networkError = new Error('Network request failed');
+    mockFetch.mockRejectedValueOnce(networkError);
+
+    const payload = createTestPayload();
+
+    // Expect the function to throw the network error
+    await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow('Network request failed');
+
+    // Verify fetch was called with correct parameters
+    expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello World' }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  });
+
 });

package/src/activities/notifyWebhook.ts

@@ -1,15 +1,29 @@
 import { log } from "@temporalio/activity";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { VertesiaClient } from "@vertesia/client";
+import { ApiVersions, DSLActivityExecutionPayload, DSLActivitySpec, WebHookSpec, WorkflowExecutionBaseParams } from "@vertesia/common";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
 import { WorkflowParamNotFoundError } from "../errors.js";
+import { getVertesiaClientOptions } from "../utils/client.js";
 
 export interface NotifyWebhookParams {
-    target_url: string; //URL to send the notification to
+    webhook: string | WebHookSpec; //URL to send the notification to
+    workflow_id: string; //The ID of the workflow sending the notification
+    workflow_type: string; //The type of workflow sending the notification (the wf function name)
+    workflow_run_id: string; //The ID of the specific workflow run sending the notification
+    event_name: string; //The event that triggered the notification (e.g. "completed", "failed", etc.)
+    detail?: Record<string, any>; // additional data about the event if any. It will be send to the webhook when using POST 
+    //target_url: string; //URL to send the notification to
     method: 'GET' | 'POST'; //HTTP method to use
-    payload: Record<string, any>; //payload to send (if POST then as JSON body, if GET then as query string)
-    headers?: Record<string, string>; //additional headers to send
+    headers?: Record<string, string>; // additional headers to send
 }
 
+export interface WebhookNotificationPayload {
+    workflow_id: string,
+    workflow_name: string,
+    workflow_run_id: string,
+    event_name: string,
+    detail?: Record<string, any>,
+}
 
 export interface NotifyWebhook extends DSLActivitySpec<NotifyWebhookParams> {
     name: 'notifyWebhook';
@@ -19,32 +33,167 @@ export interface NotifyWebhook extends DSLActivitySpec<NotifyWebhookParams> {
 export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyWebhookParams>) {
 
     const { params } = await setupActivity<NotifyWebhookParams>(payload);
-    const { target_url, method, payload: requestPayload, headers } = params
+    const { webhook, method, headers: defaultHeaders } = params
+    // resolve the url and the api version of the webhook
+    let target_url: string, version: number | undefined;
+    if (typeof webhook === 'string') {
+        target_url = webhook;
+    } else {
+        target_url = webhook.url;
+        version = webhook.version;
+    }
 
     if (!target_url) throw new WorkflowParamNotFoundError('target_url');
 
-    const body = method === 'POST' ? JSON.stringify({
-        ...requestPayload,
-    }) : undefined
+    const hasBody = params.detail && method === 'POST'; //body is sent only for POST
+
+    const headers = {
+        ...defaultHeaders,
+    };
+    if (hasBody) {
+        headers['Content-Type'] = 'application/json';
+    }
+    const body = hasBody ? await createRequestBody(payload, params, version) : undefined
 
     log.info(`Notifying webhook at ${target_url}`);
     const res = await fetch(target_url, {
         method,
         body,
-        headers: {
-            'Content-Type': 'application/json',
-            ...headers
-        },
+        headers,
     }).catch(err => {
-        log.warn(`Failed to notify webhook ${target_url}: ${err}`);
-        throw new Error(`Failed to notify webhook ${target_url}: ${err}`);
+        log.error(`An error occurred while notifying webhook at ${target_url}`, { err });
+        throw err;
     });
 
     if (!res.ok) {
-        log.warn(`Failed to notify webhook ${target_url} - ${res.status}: ${res.statusText}`, { res });
-        throw new Error(`Failed to notify webhook ${target_url}: ${res.statusText}`);
+        log.warn(`Webhook endpoint ${target_url} returned an error - ${res.status} ${res.statusText}`, { fetchResponse: res });
+
+        // Try to get response payload for error message
+        let errorMessage = `Webhook Notification to ${target_url} failed with status: ${res.status} ${res.statusText}`;
+        try {
+            const responseText = await res.text();
+            if (responseText) {
+                errorMessage += ` - Response: ${responseText}`;
+            }
+        } catch (readError) {
+            // If we can't read the response, just use the basic error message
+            log.debug('Could not read response body for error', { readError });
+        }
+
+        throw new Error(errorMessage);
     }
 
     return { status: res.status, message: res.statusText, url: res.url }
 
 }
+
+
+
+// --------------------------------------
+// Data provider for webhooks
+// this allows to customize the payload sent to the webhook depending on the 
+// type of workflow and the api version of the webhook
+// --------------------------------------
+
+
+function getWorkflowName(workflowType: string): string {
+    // remove trailing Workflow or _Workflow case insensitive from the workflow type
+    return workflowType.replace(/_?workflow$/i, '');
+}
+
+async function createRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<string> {
+    if (api_version === undefined || Number(api_version) < ApiVersions.COMPLETION_RESULT_V1) {
+        return createOldRequestBody(payload, params);
+    } else {
+        return createLatestRequestBody(payload, params, api_version);
+    }
+}
+
+async function createLatestRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<string> {
+    const data = await createEventData(payload, params, api_version);
+    return JSON.stringify({
+        workflow_id: params.workflow_id,
+        workflow_name: getWorkflowName(params.workflow_type),
+        workflow_run_id: params.workflow_run_id,
+        event_name: params.event_name,
+        detail: data,
+    } satisfies WebhookNotificationPayload);
+}
+
+async function createEventData(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<any> {
+    const data = params.detail;
+    if (data && data.run_id && params.event_name === "workflow_completed" && params.workflow_type === 'ExecuteInteractionWorkflow') {
+        const client = getVersionedVertesiaClient(payload, api_version); //ensure client is initialized
+        // we replace the result property with the full execution run object
+        return await client.runs.retrieve(data.run_id);
+    }
+    return data;
+}
+
+
+function getVersionedVertesiaClient(payload: WorkflowExecutionBaseParams, version: string | number | undefined | null) {
+    // set the api version header
+    return new VertesiaClient(getVertesiaClientOptions(payload)).withApiVersion(version ? String(version) : null);
+}
+
+
+// ----------------- Compatibility code -----------------
+/* Before 2025-10-08 the notifyWebhook POST body was in the format:
+
+{
+    "workflowId": "generation:ExecuteInteractionWorkflow:WhatColor:ox8wu6t4",
+    "runId": "0199c2c6-818f-77eb-b931-c1ba8b9e5184",
+    "status": "completed",
+    "result": {
+        "run_id": "68e616274b0e9bb510462378",
+        "status": "completed",
+        "result": {"Color": "white"}
+    }
+}
+
+After Versions.COMPLETION_RESULT_V1  (20250925) when the completion result interface changed we improved the
+payload to the current format:
+
+{
+    "workflow_id": "generation:ExecuteInteractionWorkflow:WhatColor:bdedqjqj6",
+    "workflow_name": "ExecuteInteraction",
+    "workflow_run_id": "0199c2d4-6b1d-7cf2-a1e5-4cac6778091e",
+    "event_name": "workflow_completed",
+    "detail": ExecutionRun
+}
+
+where ExecutionRun contains a result property with the new completion result format.
+
+"result": [
+    {
+        "type": "json",
+        "value": {
+            "Color": "white"
+        }
+    }
+],
+
+*/
+
+//@ts-ignore
+async function createOldRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams): Promise<string> {
+    let data = params.detail;
+    if (data && data.run_id && params.event_name === "workflow_completed" && params.workflow_type === 'ExecuteInteractionWorkflow') {
+        const client = getVersionedVertesiaClient(payload, null); //ensure client is using no specific version
+        // Important Note: we cannot use client.runs.retrieve since it will transform the run result to the new format because of InteractionOutput
+        const run = await client.runs.get(data.run_id);
+        // since we use an unversioned client the run will be in old format so we don't need to tranform the result
+        const result = run.result;
+        data = {
+            workflowId: params.workflow_id,
+            runId: params.workflow_run_id,
+            status: params.event_name === 'workflow_completed' ? 'completed' : params.event_name,
+            result: {
+                run_id: run.id,
+                status: run.status,
+                result: result || null
+            }
+        };
+    }
+    return JSON.stringify(data || {});
+}

package/src/activities/rateLimiter.ts

@@ -0,0 +1,41 @@
+import { DSLActivityExecutionPayload, RateLimitRequestPayload } from "@vertesia/common";
+import { activityInfo, log } from "@temporalio/activity";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+
+export interface RateLimitParams {
+  interactionIdOrEndpoint: string;
+  environmentId?: string;
+  modelId?: string;
+}
+
+export interface RateLimitResult {
+  delayMs: number;
+}
+
+export async function checkRateLimit(payload: DSLActivityExecutionPayload<RateLimitParams>): Promise<RateLimitResult> {
+  const { client, params } = await setupActivity<RateLimitParams>(payload);
+  const { environmentId, modelId } = params;
+  
+  const result: RateLimitResult = {
+    delayMs: 0,
+  }
+
+  try {
+    // Call the studio-server endpoint to get rate limit delay using the Vertesia client
+    const info = activityInfo();
+    const requestPayload: RateLimitRequestPayload = {
+      interaction: params.interactionIdOrEndpoint,
+      workflow_run_id: info.workflowExecution.runId,
+      environment_id: environmentId,
+      model_id: modelId,
+    };
+    
+    const response = await client.interactions.requestSlot(requestPayload);
+    result.delayMs = response.delay_ms;
+  } catch (error) {
+    log.warn('Failed to call rate limit API:', {error});
+    throw error;
+  }
+
+  return result;
+}

package/src/conversion/image.ts

@@ -78,6 +78,12 @@ export async function imageResizer(
         const command = `convert`
         let args = [inputPath];
 
+        // Add JPEG shrink-on-load optimization
+        args.push("-define", `jpeg:size=${max_hw * 3}x${max_hw * 3}`);
+
+        // Remove metadata
+        args.push("-strip");
+
         // https://usage.imagemagick.org/filter/nicolas/#downsample
         // Add colorspace correction if enabled
         if (colorspaceCorrection) {
@@ -110,9 +116,6 @@ export async function imageResizer(
             }
         }
 
-        // 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}>`);
 

package/src/dsl/dsl-workflow.ts

@@ -7,6 +7,7 @@ import {
     log,
     patched,
     proxyActivities,
+    sleep,
     startChild,
     UntypedActivities,
 } from "@temporalio/workflow";
@@ -18,6 +19,7 @@ import {
     DSLWorkflowExecutionPayload,
     DSLWorkflowSpec,
     getDocumentIds,
+    getTenantId,
     WorkflowExecutionPayload
 } from "@vertesia/common";
 import ms, { StringValue } from 'ms';
@@ -25,6 +27,8 @@ import { HandleDslErrorParams } from "../activities/handleError.js";
 import * as activities from "../activities/index.js";
 import { WF_NON_RETRYABLE_ERRORS, WorkflowParamNotFoundError } from "../errors.js";
 import { Vars } from "./vars.js";
+import { RateLimitParams } from "../activities/rateLimiter.js";
+
 
 interface BaseActivityPayload extends WorkflowExecutionPayload {
     workflow_name: string;
@@ -172,6 +176,7 @@ async function startChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWorkfl
             AccountId: [payload.account_id],
             DocumentId: getDocumentIds(payload),
             ProjectId: [payload.project_id],
+            TenantId: [getTenantId(payload.account_id, payload.project_id)],
             InitiatedBy: payload.initiated_by ? [payload.initiated_by] : [],
         },
     });
@@ -204,6 +209,7 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
             AccountId: [payload.account_id],
             DocumentId: getDocumentIds(payload),
             ProjectId: [payload.project_id],
+            TenantId: [getTenantId(payload.account_id, payload.project_id)],
             InitiatedBy: payload.initiated_by ? [payload.initiated_by] : [],
         },
     });
@@ -218,6 +224,54 @@ async function executeChildWorkflow(step: DSLChildWorkflowStep, payload: DSLWork
     }
 }
 
+function buildRateLimitParams(activity: DSLActivitySpec, executionPayload: DSLActivityExecutionPayload<any>): RateLimitParams {
+    // resolve payload params
+    const vars = new Vars({
+        ...executionPayload.params, // imported params (doesn't contain expressions)
+        ...executionPayload.activity.params, // activity params (may contain expressions)
+    });
+    const params = vars.resolve();
+
+    let interactionId: string;
+
+    switch (activity.name) {
+        case "executeInteraction":
+            interactionId = params.interactionName;
+            break;
+
+        case "generateDocumentProperties":
+            interactionId = params.interactionName || "sys:ExtractInformation";
+            break;
+
+        case "identifyTextSections":
+            interactionId = params.interactionName || "sys:IdentifyTextSections";
+            break;
+
+        case "generateOrAssignContentType":
+            interactionId = params.interactionNames?.selectDocumentType || "sys:SelectDocumentType";
+            break;
+
+        case "chunkDocument":
+            interactionId = params.interactionName || "sys:ChunkDocument";
+            break;
+
+        default:
+            // For any other rate-limited activities, try to extract what we can
+            interactionId = params.interactionName;
+            break;
+    }
+
+    if (!interactionId) {
+        throw new Error(`No interaction ID could be determined for activity ${activity.name}`);
+    }
+
+    return {
+        interactionIdOrEndpoint: interactionId,
+        environmentId: params.environment,
+        modelId: params.model,
+    };
+}
+
 async function runActivity(activity: DSLActivitySpec, basePayload: BaseActivityPayload, vars: Vars, defaultProxy: ActivityInterfaceFor<UntypedActivities>, defaultOptions: ActivityOptions) {
     if (basePayload.debug_mode) {
         log.debug(`Workflow vars before executing activity ${activity.name}`, { vars: vars.resolve() });
@@ -245,6 +299,38 @@ async function runActivity(activity: DSLActivitySpec, basePayload: BaseActivityP
         });
     }
 
+    if (patched('system-activity-taskqueue')) {
+        // hack: do nothing, remove later
+        // https://github.com/vertesia/composableai/pull/544/files
+    }
+
+    // call rate limiter depending on the activity type
+    const rateLimitedActivities = [
+        "chunkDocument",
+        "executeInteraction",
+        "generateDocumentProperties",
+        "generateOrAssignContentType",
+        "identifyTextSections",
+    ];
+
+    if (activity.name && rateLimitedActivities.includes(activity.name)) {
+        log.info(`Applying rate limit for activity ${activity.name}`);
+        // Apply rate limiting logic here
+         // Check rate limit first - loop until no delay
+        const rateLimitParams = buildRateLimitParams(activity, executionPayload);
+
+        const rateLimitPayload = dslActivityPayload(basePayload, activity, rateLimitParams);
+        let rateLimitResult = await proxy.checkRateLimit(rateLimitPayload);
+    
+        while (rateLimitResult.delayMs > 0) {
+            log.info(`Rate limit delay applied: ${rateLimitResult.delayMs}ms`);
+            await sleep(rateLimitResult.delayMs);
+
+            // Check again after sleeping
+            rateLimitResult = await proxy.checkRateLimit(rateLimitPayload);
+        }
+    }
+
     const fn = proxy[activity.name];
     if (activity.parallel) {
         //TODO execute in parallel

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

@@ -129,6 +129,7 @@ describe('DSL Workflow with child workflows', () => {
                 AccountId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 DocumentId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 ProjectId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                TenantId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
                 InitiatedBy: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
             },
         });