@vertesia/workflow 1.2.0 → 1.3.0-dev.20260620.091720Z

package/src/activities/notifyWebhook.ts

@@ -1,9 +1,15 @@
-import { log } from "@temporalio/activity";
-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";
+import { log } from '@temporalio/activity';
+import { VertesiaClient } from '@vertesia/client';
+import {
+    ApiVersions,
+    type DSLActivityExecutionPayload,
+    type DSLActivitySpec,
+    type WebHookSpec,
+    type 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 {
     webhook: string | WebHookSpec; //URL to send the notification to
@@ -11,29 +17,35 @@ export interface NotifyWebhookParams {
     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 
+    detail?: Record<string, unknown>; // 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
     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>,
+    workflow_id: string;
+    workflow_name: string;
+    workflow_run_id: string;
+    event_name: string;
+    detail?: unknown;
 }
 
 export interface NotifyWebhook extends DSLActivitySpec<NotifyWebhookParams> {
     name: 'notifyWebhook';
 }
 
+export interface NotifyWebhookResult {
+    status: number;
+    message: string;
+    url: string;
+}
 
-export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyWebhookParams>) {
-
+export async function notifyWebhook(
+    payload: DSLActivityExecutionPayload<NotifyWebhookParams>,
+): Promise<NotifyWebhookResult> {
     const { params } = await setupActivity<NotifyWebhookParams>(payload);
-    const { webhook, method, headers: defaultHeaders } = 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') {
@@ -53,20 +65,22 @@ export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyW
     if (hasBody) {
         headers['Content-Type'] = 'application/json';
     }
-    const body = hasBody ? await createRequestBody(payload, params, version) : undefined
+    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,
-    }).catch(err => {
+    }).catch((err) => {
         log.error(`An error occurred while notifying webhook at ${target_url}`, { err });
         throw err;
     });
 
     if (!res.ok) {
-        log.warn(`Webhook endpoint ${target_url} returned an error - ${res.status} ${res.statusText}`, { fetchResponse: res });
+        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}`;
@@ -83,25 +97,25 @@ export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyW
         throw new Error(errorMessage);
     }
 
-    return { status: res.status, message: res.statusText, url: res.url }
-
+    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 
+// 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> {
+async function createRequestBody(
+    payload: WorkflowExecutionBaseParams<unknown>,
+    params: NotifyWebhookParams,
+    api_version: number | undefined,
+): Promise<string> {
     if (api_version === undefined || Number(api_version) < ApiVersions.COMPLETION_RESULT_V1) {
         return createOldRequestBody(payload, params);
     } else {
@@ -109,7 +123,11 @@ async function createRequestBody(payload: WorkflowExecutionBaseParams, params: N
     }
 }
 
-async function createLatestRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<string> {
+async function createLatestRequestBody(
+    payload: WorkflowExecutionBaseParams<unknown>,
+    params: NotifyWebhookParams,
+    api_version: number | undefined,
+): Promise<string> {
     const data = await createEventData(payload, params, api_version);
     return JSON.stringify({
         workflow_id: params.workflow_id,
@@ -120,23 +138,29 @@ async function createLatestRequestBody(payload: WorkflowExecutionBaseParams, par
     } satisfies WebhookNotificationPayload);
 }
 
-async function createEventData(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams, api_version: number | undefined): Promise<any> {
+async function createEventData(
+    payload: WorkflowExecutionBaseParams<unknown>,
+    params: NotifyWebhookParams,
+    api_version: number | undefined,
+): Promise<unknown> {
     const data = params.detail;
-    if (data && data.run_id && params.event_name === "workflow_completed" && params.workflow_type === 'ExecuteInteractionWorkflow') {
+    const runId = typeof data?.run_id === 'string' ? data.run_id : undefined;
+    if (runId && 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 await client.runs.retrieve(runId);
     }
     return data;
 }
 
-
-function getVersionedVertesiaClient(payload: WorkflowExecutionBaseParams, version: string | number | undefined | null) {
+function getVersionedVertesiaClient(
+    payload: WorkflowExecutionBaseParams<unknown>,
+    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:
 
@@ -175,13 +199,16 @@ where ExecutionRun contains a result property with the new completion result for
 
 */
 
-//@ts-ignore
-async function createOldRequestBody(payload: WorkflowExecutionBaseParams, params: NotifyWebhookParams): Promise<string> {
+async function createOldRequestBody(
+    payload: WorkflowExecutionBaseParams<unknown>,
+    params: NotifyWebhookParams,
+): Promise<string> {
     let data = params.detail;
-    if (data && data.run_id && params.event_name === "workflow_completed" && params.workflow_type === 'ExecuteInteractionWorkflow') {
+    const runId = typeof data?.run_id === 'string' ? data.run_id : undefined;
+    if (runId && 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);
+        const run = await client.runs.get<{ id: string; status: string; result?: unknown }>(runId);
         // 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 = {
@@ -191,8 +218,8 @@ async function createOldRequestBody(payload: WorkflowExecutionBaseParams, params
             result: {
                 run_id: run.id,
                 status: run.status,
-                result: result || null
-            }
+                result: result || null,
+            },
         };
     } else {
         // Always include workflow metadata in old format, even when detail is undefined
@@ -200,8 +227,8 @@ async function createOldRequestBody(payload: WorkflowExecutionBaseParams, params
             workflowId: params.workflow_id,
             runId: params.workflow_run_id,
             status: params.event_name === 'workflow_completed' ? 'completed' : params.event_name,
-            result: data || null
+            result: data || null,
         };
     }
     return JSON.stringify(data);
-}
+}

package/src/activities/rateLimiter.ts

@@ -1,41 +1,42 @@
-import { DSLActivityExecutionPayload, RateLimitRequestPayload } from "@vertesia/common";
-import { activityInfo, log } from "@temporalio/activity";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { activityInfo, log } from '@temporalio/activity';
+import type { DSLActivityExecutionPayload, RateLimitRequestPayload } from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { activityWorkflowExecution } from '../utils/activity-info.js';
 
 export interface RateLimitParams {
-  interactionIdOrEndpoint: string;
-  environmentId?: string;
-  modelId?: string;
+    interactionIdOrEndpoint: string;
+    environmentId?: string;
+    modelId?: string;
 }
 
 export interface RateLimitResult {
-  delayMs: number;
+    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,
-  }
+    const { client, params } = await setupActivity<RateLimitParams>(payload);
+    const { environmentId, modelId } = params;
 
-  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 result: RateLimitResult = {
+        delayMs: 0,
     };
-    
-    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;
-}
+    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: activityWorkflowExecution(info).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/activities/renditions/generateImageRendition.ts

@@ -1,34 +1,31 @@
-import { log } from "@temporalio/activity";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
-import { setupActivity } from "../../dsl/setup/ActivityContext.js";
-import { DocumentNotFoundError, WorkflowParamNotFoundError } from "../../errors.js";
-import { saveBlobToTempFile } from "../../utils/blobs.js";
-import {
-    ImageRenditionParams,
-    uploadRenditionPages,
-} from "../../utils/renditions.js";
-
-interface GenerateImageRenditionParams extends ImageRenditionParams { }
-
-export interface GenerateImageRendition
-    extends DSLActivitySpec<GenerateImageRenditionParams> {
-    name: "generateImageRendition";
+import fs from 'node:fs';
+import { log } from '@temporalio/activity';
+import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
+import { setupActivity } from '../../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError, WorkflowParamNotFoundError } from '../../errors.js';
+import { saveBlobToTempFile } from '../../utils/blobs.js';
+import { type ImageRenditionParams, uploadRenditionPages } from '../../utils/renditions.js';
+
+interface GenerateImageRenditionParams extends ImageRenditionParams {}
+
+interface LegacyImageRenditionParams {
+    maxHeightWidth?: number;
+    format_output?: ImageRenditionParams['format'];
 }
 
-export async function generateImageRendition(
-    payload: DSLActivityExecutionPayload<GenerateImageRenditionParams>,
-) {
-    const {
-        client,
-        objectId,
-        params: originParams,
-    } = await setupActivity<GenerateImageRenditionParams>(payload);
+export interface GenerateImageRendition extends DSLActivitySpec<GenerateImageRenditionParams> {
+    name: 'generateImageRendition';
+}
+
+export async function generateImageRendition(payload: DSLActivityExecutionPayload<GenerateImageRenditionParams>) {
+    const { client, objectId, params: originParams } = await setupActivity<GenerateImageRenditionParams>(payload);
 
     // Fix: Use maxHeightWidth if max_hw is not provided
+    const legacyParams = originParams as LegacyImageRenditionParams;
     const params = {
         ...originParams,
-        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
+        max_hw: originParams.max_hw || legacyParams.maxHeightWidth || 1596, // Default to 1596 if both are missing
+        format: originParams.format || legacyParams.format_output || 'png', // Default to png if format is missing
     };
 
     log.debug(`Generating image rendition for ${objectId}`, {
@@ -36,9 +33,10 @@ export async function generateImageRendition(
         params,
     });
 
-    const inputObject = await client.objects.retrieve(objectId).catch((err) => {
+    const inputObject = await client.objects.retrieve(objectId).catch((err: unknown) => {
+        const message = err instanceof Error ? err.message : String(err);
         log.error(`Failed to retrieve document ${objectId}`, { err });
-        if (err.message.includes("not found")) {
+        if (message.includes('not found')) {
             throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
         }
         throw err;
@@ -59,53 +57,45 @@ export async function generateImageRendition(
         throw new DocumentNotFoundError(`Document ${objectId} has no source`, [objectId]);
     }
 
-    if (
-        !inputObject.content.type ||
-        !inputObject.content.type?.startsWith("image/")
-    ) {
-        log.error(
-            `Document ${objectId} is not an image or a video: ${inputObject.content.type}`,
-        );
+    if (!inputObject.content.type?.startsWith('image/')) {
+        log.error(`Document ${objectId} is not an image or a video: ${inputObject.content.type}`);
         throw new DocumentNotFoundError(
             `Document ${objectId} is not an image or a video: ${inputObject.content.type}`,
             [objectId],
         );
     }
 
-    //array of rendition files to upload
-    let renditionPages: string[] = [];
+    let imageFile: string | undefined;
 
-    const imageFile = await saveBlobToTempFile(
-        client,
-        inputObject.content.source,
-    );
-    log.debug(`Image ${objectId} copied to ${imageFile}`);
-    renditionPages.push(imageFile);
+    try {
+        imageFile = await saveBlobToTempFile(client, inputObject.content.source);
+        log.debug(`Image ${objectId} copied to ${imageFile}`);
 
+        //IF no etag, log and use use object id as etag
+        if (!inputObject.content.etag) {
+            log.warn(`Document ${objectId} has no etag, using object id as etag`);
+        }
+        const contentEtag = inputObject.content.etag ?? inputObject.id;
 
-    //IF no etag, log and use use object id as etag
-    if (!inputObject.content.etag) {
-        log.warn(`Document ${objectId} has no etag, using object id as etag`);
-    }
-    const contentEtag = inputObject.content.etag ?? inputObject.id;
+        const uploaded = await uploadRenditionPages(client, contentEtag, [imageFile], params);
 
-    const uploaded = await uploadRenditionPages(
-        client,
-        contentEtag,
-        [imageFile],
-        params,
-    );
+        if (!uploaded?.length || !uploaded[0]) {
+            log.error(`Failed to upload rendition for ${objectId}`, { uploaded });
+            throw new Error(`Failed to upload rendition for ${objectId} - upload object is empty`);
+        }
 
-    if (!uploaded || !uploaded.length || !uploaded[0]) {
-        log.error(`Failed to upload rendition for ${objectId}`, { uploaded });
-        throw new Error(
-            `Failed to upload rendition for ${objectId} - upload object is empty`,
-        );
+        return {
+            uploads: uploaded.map((u) => u),
+            format: params.format,
+            status: 'success',
+        };
+    } finally {
+        if (imageFile) {
+            try {
+                await fs.promises.unlink(imageFile);
+            } catch (err) {
+                log.warn(`Failed to clean temporary image file for ${objectId}`, { err });
+            }
+        }
     }
-
-    return {
-        uploads: uploaded.map((u) => u),
-        format: params.format,
-        status: "success",
-    };
 }