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

package/src/activities/generateOrAssignContentType.ts

@@ -1,268 +1,256 @@
-import { ApplicationFailure, log } from "@temporalio/activity";
+import { ApplicationFailure, log } from '@temporalio/activity';
 import {
-  ContentObjectTypeItem,
-  CreateContentObjectTypePayload,
-  DSLActivityExecutionPayload,
-  DSLActivitySpec,
-  ImageRenditionFormat,
-} 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";
-
-export interface GenerateOrAssignContentTypeParams
-  extends InteractionExecutionParams {
-  typesHint?: string[];
-  /**
-   * truncate the input doc text to the specified max_tokens
-   */
-  truncate?: TruncateSpec;
-
-  /**
-   * The name of the interaction to execute
-   * @default SelectDocumentType
-   */
-  interactionNames?: {
-    selectDocumentType?: string;
-    generateMetadataModel?: string;
-  };
+    type ContentObjectTypeItem,
+    type CreateContentObjectTypePayload,
+    type DSLActivityExecutionPayload,
+    type DSLActivitySpec,
+    ImageRenditionFormat,
+} from '@vertesia/common';
+import { type ActivityContext, setupActivity } from '../dsl/setup/ActivityContext.js';
+import { type TruncateSpec, truncByMaxTokens } from '../utils/tokens.js';
+import { executeInteractionFromActivity, type InteractionExecutionParams } from './executeInteraction.js';
+
+const INT_SELECT_DOCUMENT_TYPE = 'sys:SelectDocumentType';
+const INT_GENERATE_METADATA_MODEL = 'sys:GenerateMetadataModel';
+
+interface RetryableError extends Error {
+    retryable?: boolean;
+}
+
+interface SelectDocumentTypeResult {
+    document_type?: string;
+}
+
+interface GeneratedDocumentTypeResult {
+    document_type?: string;
+    document_type_description?: string;
+    metadata_schema?: CreateContentObjectTypePayload['object_schema'];
+    is_chunkable?: boolean;
+    table_layout?: CreateContentObjectTypePayload['table_layout'];
+}
+
+function toRetryableError(error: unknown): RetryableError {
+    if (error instanceof Error) {
+        return error as RetryableError;
+    }
+    return new Error(String(error)) as RetryableError;
+}
+
+export interface GenerateOrAssignContentTypeParams extends InteractionExecutionParams {
+    typesHint?: string[];
+    /**
+     * truncate the input doc text to the specified max_tokens
+     */
+    truncate?: TruncateSpec;
+
+    /**
+     * The name of the interaction to execute
+     * @default SelectDocumentType
+     */
+    interactionNames?: {
+        selectDocumentType?: string;
+        generateMetadataModel?: string;
+    };
 }
 
-export interface GenerateOrAssignContentType
-  extends DSLActivitySpec<GenerateOrAssignContentTypeParams> {
-  name: "generateOrAssignContentType";
+export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrAssignContentTypeParams> {
+    name: 'generateOrAssignContentType';
 }
 
 export async function generateOrAssignContentType(
-  payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>,
+    payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>,
 ) {
-  const context =
-    await setupActivity<GenerateOrAssignContentTypeParams>(payload);
-  const { params, client, objectId } = context;
+    const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
+    const { params, client, objectId } = context;
 
-  const interactionName =
-    params.interactionNames?.selectDocumentType ?? INT_SELECT_DOCUMENT_TYPE;
+    const interactionName = params.interactionNames?.selectDocumentType ?? INT_SELECT_DOCUMENT_TYPE;
 
-  log.debug("SelectDocumentType for object: " + objectId, { payload });
+    log.debug(`SelectDocumentType for object: ${objectId}`, { payload });
 
-  const object = await client.objects.retrieve(objectId, "+text");
+    const object = await client.objects.retrieve(objectId, '+text');
+
+    //Expects object.type to be null on first ingestion of content
+    //User initiated Content Type change via the Composable UI,
+    //sets object.type to null when they let Composable choose for them.
+    //sets object.type to chosen type (thus non-null) when user picks a type.
+    if (object.type) {
+        log.warn(`Object ${objectId} has already a type. Skipping type creation.`);
+        return {
+            status: 'skipped',
+            message: `Object already has a type: ${object.type.name}`,
+        };
+    }
 
-  //Expects object.type to be null on first ingestion of content
-  //User initiated Content Type change via the Composable UI,
-  //sets object.type to null when they let Composable choose for them.
-  //sets object.type to chosen type (thus non-null) when user picks a type.
-  if (object.type) {
-    log.warn(`Object ${objectId} has already a type. Skipping type creation.`);
-    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"))
-  ) {
-    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.catalog.list({
-    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 || 30000)
-    : undefined;
-
-  const getImage = async () => {
     if (
-      object.content?.type?.includes("pdf") &&
-      object.text?.length &&
-      object.text?.length < 100
+        !object ||
+        (!object.text &&
+            !object.content?.type?.startsWith('image/') &&
+            !object.content?.type?.startsWith('application/pdf'))
     ) {
-      return "store:" + objectId;
-    }
-    if (!object.content?.type?.startsWith("image/")) {
-      return undefined;
+        log.info(`Object ${objectId} not found or text is empty and not an image`, {
+            object,
+        });
+        return { status: 'failed', error: 'no-text' };
     }
-    const res = await client.objects.getRendition(objectId, {
-      format: ImageRenditionFormat.jpeg,
-      generate_if_missing: true,
+
+    const types = await client.types.catalog.list({
+        schema: true,
     });
-    if (!res.renditions?.length && res.status === "generating") {
-      //throw to try again
-      throw new Error(`Rendition for object ${objectId} is in progress`);
-    } else if (res.renditions) {
-      return "store:" + objectId;
-    }
-  };
-
-  const fileRef = await getImage();
-
-  log.info(
-    "Execute SelectDocumentType interaction on content with \nexisting types - passing full types: " +
-    existing_types.filter((t) => !t.tags?.includes("system")),
-  );
-
-  let res;
-  try {
-    res = await executeInteractionFromActivity(
-      client,
-      interactionName,
-      params,
-      {
-        existing_types,
-        content,
-        image: fileRef,
-      },
-    );
-  } catch (error: any) {
-    log.error(`Failed to select document type`, { error, retryable: error.retryable });
-    
-    const isRetryable = error.retryable !== undefined 
-      ? error.retryable !== false
-      : undefined;
-    
-    if (isRetryable !== undefined) {
-      if (isRetryable) {
-        throw ApplicationFailure.create({
-          message: `Document type selection failed: ${error.message}`,
-          nonRetryable: false,
+
+    //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 || 30000) : undefined;
+
+    const getImage = async () => {
+        if (object.content?.type?.includes('pdf') && object.text?.length && object.text?.length < 100) {
+            return `store:${objectId}`;
+        }
+        if (!object.content?.type?.startsWith('image/')) {
+            return undefined;
+        }
+        const res = await client.objects.getRendition(objectId, {
+            format: ImageRenditionFormat.jpeg,
+            generate_if_missing: true,
         });
-      } else {
-        throw ApplicationFailure.create({
-          message: `Non-retryable document type selection failed: ${error.message}`,
-          nonRetryable: true,
+        if (!res.renditions?.length && res.status === 'generating') {
+            //throw to try again
+            throw new Error(`Rendition for object ${objectId} is in progress`);
+        } else if (res.renditions) {
+            return `store:${objectId}`;
+        }
+    };
+
+    const fileRef = await getImage();
+
+    log.info(
+        'Execute SelectDocumentType interaction on content with \nexisting types - passing full types: ' +
+            existing_types.filter((t) => !t.tags?.includes('system')),
+    );
+
+    let res: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
+    try {
+        res = await executeInteractionFromActivity(client, interactionName, params, {
+            existing_types,
+            content,
+            image: fileRef,
         });
-      }
+    } catch (error: unknown) {
+        const selectionError = toRetryableError(error);
+        log.error(`Failed to select document type`, { error: selectionError, retryable: selectionError.retryable });
+
+        const isRetryable = selectionError.retryable !== undefined ? selectionError.retryable !== false : undefined;
+
+        if (isRetryable !== undefined) {
+            if (isRetryable) {
+                throw ApplicationFailure.create({
+                    message: `Document type selection failed: ${selectionError.message}`,
+                    nonRetryable: false,
+                });
+            } else {
+                throw ApplicationFailure.create({
+                    message: `Non-retryable document type selection failed: ${selectionError.message}`,
+                    nonRetryable: true,
+                });
+            }
+        }
+
+        throw error;
     }
-    
-    throw error;
-  }
 
-  const jsonResult = res.result.object();
+    const jsonResult = res.result.object<SelectDocumentTypeResult>();
 
-  log.info("Selected Content Type Result: " + JSON.stringify(jsonResult));
+    log.debug(`Selected Content Type Result: ${JSON.stringify(jsonResult)}`);
 
+    //if type is not identified or not present in the database, generate a new type
+    let selectedType: { id: string; name: string } | undefined;
 
-  //if type is not identified or not present in the database, generate a new type
-  let selectedType: { id: string; name: string } | undefined = undefined;
+    selectedType = types.find((t) => t.name === jsonResult.document_type);
 
-  selectedType = types.find((t) => t.name === jsonResult.document_type);
+    if (!selectedType) {
+        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 };
+    }
 
-  if (!selectedType) {
-    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 };
-  }
-
-  if (!selectedType) {
-    log.error("Type not found: ", res.result);
-    throw new Error("Type not found: " + jsonResult.document_type);
-  }
-
-  //update object with selected type
-  await client.objects.update(objectId, {
-    type: selectedType.id,
-  });
-
-  return {
-    id: selectedType.id,
-    name: selectedType.name,
-    isNew: !types.find((t) => t.name === selectedType.name),
-  };
+    if (!selectedType) {
+        log.error('Type not found: ', res.result);
+        throw new Error(`Type not found: ${jsonResult.document_type}`);
+    }
+
+    //update object with selected type
+    await client.objects.update(objectId, {
+        type: selectedType.id,
+    });
+
+    return {
+        id: selectedType.id,
+        name: selectedType.name,
+        isNew: !types.find((t) => t.name === selectedType.name),
+    };
 }
 
 async function generateNewType(
-  context: ActivityContext<GenerateOrAssignContentTypeParams>,
-  existing_types: ContentObjectTypeItem[],
-  content?: string,
-  fileRef?: string,
+    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;
-
-  let genTypeRes;
-  try {
-    genTypeRes = await executeInteractionFromActivity(
-      client,
-      interactionName,
-      params,
-      {
-        existing_types,
-        content: content,
-        human_context: project?.configuration?.human_context ?? undefined,
-        image: fileRef ? fileRef : undefined,
-      },
-    );
-  } catch (error: any) {
-    log.error(`Failed to generate new document type`, { error, retryable: error.retryable });
-    
-    const isRetryable = error.retryable !== undefined 
-      ? error.retryable !== false
-      : undefined;
-    
-    if (isRetryable !== undefined) {
-      if (isRetryable) {
-        throw ApplicationFailure.create({
-          message: `Document type generation failed: ${error.message}`,
-          nonRetryable: false,
+    const { client, params } = context;
+
+    const project = await context.fetchProject();
+    const interactionName = params.interactionNames?.generateMetadataModel ?? INT_GENERATE_METADATA_MODEL;
+
+    let genTypeRes: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
+    try {
+        genTypeRes = await executeInteractionFromActivity(client, interactionName, params, {
+            existing_types,
+            content: content,
+            human_context: project?.configuration?.human_context ?? undefined,
+            image: fileRef ? fileRef : undefined,
         });
-      } else {
-        throw ApplicationFailure.create({
-          message: `Non-retryable document type generation failed: ${error.message}`,
-          nonRetryable: true,
+    } catch (error: unknown) {
+        const generationError = toRetryableError(error);
+        log.error(`Failed to generate new document type`, {
+            error: generationError,
+            retryable: generationError.retryable,
         });
-      }
+
+        const isRetryable = generationError.retryable !== undefined ? generationError.retryable !== false : undefined;
+
+        if (isRetryable !== undefined) {
+            if (isRetryable) {
+                throw ApplicationFailure.create({
+                    message: `Document type generation failed: ${generationError.message}`,
+                    nonRetryable: false,
+                });
+            } else {
+                throw ApplicationFailure.create({
+                    message: `Non-retryable document type generation failed: ${generationError.message}`,
+                    nonRetryable: true,
+                });
+            }
+        }
+
+        throw error;
     }
-    
-    throw error;
-  }
 
-  const jsonResult = genTypeRes.result.object();
+    const jsonResult = genTypeRes.result.object<GeneratedDocumentTypeResult>();
 
-  if (!jsonResult.document_type) {
-    log.error("No name generated for type", genTypeRes);
-    throw new Error("No name generated for type");
-  }
+    if (!jsonResult.document_type) {
+        log.error('No name generated for type', genTypeRes);
+        throw new Error('No name generated for type');
+    }
 
-  log.info("Generated schema for type", jsonResult.metadata_schema);
-  const typeData: CreateContentObjectTypePayload = {
-    name: jsonResult.document_type,
-    description: jsonResult.document_type_description,
-    object_schema: jsonResult.metadata_schema,
-    is_chunkable: jsonResult.is_chunkable,
-    table_layout: jsonResult.table_layout,
-  };
+    log.info('Generated schema for type', jsonResult.metadata_schema);
+    const typeData: CreateContentObjectTypePayload = {
+        name: jsonResult.document_type,
+        description: jsonResult.document_type_description,
+        object_schema: jsonResult.metadata_schema,
+        is_chunkable: jsonResult.is_chunkable,
+        table_layout: jsonResult.table_layout,
+    };
 
-  const type = await client.types.create(typeData);
+    const type = await client.types.create(typeData);
 
-  return type;
+    return type;
 }

package/src/activities/getObjectFromStore.ts

@@ -1,8 +1,7 @@
-import { ContentObject, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
-import { DocumentNotFoundError } from "../errors.js";
-import { projectResult } from "../dsl/projections.js";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-
+import type { ContentObject, DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
+import { projectResult } from '../dsl/projections.js';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError } from '../errors.js';
 
 export interface GetObjectParams {
     select?: string;
@@ -17,7 +16,9 @@ export interface GetObject extends DSLActivitySpec<GetObjectParams> {
  * @param objectId
  * @param status
  */
-export async function getObjectFromStore(payload: DSLActivityExecutionPayload<GetObjectParams>): Promise<ContentObject> {
+export async function getObjectFromStore(
+    payload: DSLActivityExecutionPayload<GetObjectParams>,
+): Promise<ContentObject> {
     const { client, params, objectId } = await setupActivity<GetObjectParams>(payload);
 
     let obj: ContentObject;
@@ -31,11 +32,11 @@ export async function getObjectFromStore(payload: DSLActivityExecutionPayload<Ge
         throw err;
     }
 
-    const projection = projectResult(payload, params, obj, obj);
+    const projection = projectResult(payload, params, obj, obj) as Partial<ContentObject>;
 
     return {
+        ...obj,
         ...projection,
         id: obj.id,
-    }
-
-}
+    };
+}

package/src/activities/handleError.ts

@@ -1,6 +1,6 @@
-import { ContentObjectStatus, DSLActivityExecutionPayload } from "@vertesia/common";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { log } from "@temporalio/activity"
+import { log } from '@temporalio/activity';
+import { ContentObjectStatus, type DSLActivityExecutionPayload } from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
 
 export interface HandleDslErrorParams {
     errorMessage: string;
@@ -10,15 +10,16 @@ export async function handleDslError(payload: DSLActivityExecutionPayload<Handle
     const { client, params, objectId } = await setupActivity<HandleDslErrorParams>(payload);
 
     const isIntake = [
-        "StandardDocumentIntake",
-        "StandardImageIntake",
-        "StandardMediaContainerIntake",
-        "StandardVideoIntake",
-        "StandardAudioIntake",
-        "StandardDocPartIntake",
+        'StandardDocumentIntake',
+        'StandardImageIntake',
+        'StandardMediaContainerIntake',
+        'StandardVideoIntake',
+        'StandardAudioIntake',
+        'StandardDocPartIntake',
     ].includes(payload.workflow_name);
     if (!isIntake) {
-        log.warn(`Workflow execution failed, but no error handler registered for this workflow: ${payload.workflow_name}`,
+        log.warn(
+            `Workflow execution failed, but no error handler registered for this workflow: ${payload.workflow_name}`,
             { error: params.errorMessage },
         );
         return;
@@ -27,7 +28,18 @@ export async function handleDslError(payload: DSLActivityExecutionPayload<Handle
     try {
         await client.objects.update(objectId, { status: ContentObjectStatus.failed });
     } catch (e) {
-        log.error("Failed to handle error", { error: e });
+        // Recovery path: the upstream workflow has already failed (and that
+        // original error is logged by the completion interceptor). What's
+        // happening here is that we *also* couldn't mark the content object
+        // as failed. Stay at error so it remains in dashboards — recurring
+        // recovery failures are a real signal — but enrich the message so
+        // it's clearly distinct from the upstream error rather than reading
+        // like a duplicate.
+        log.error(`Recovery failed: could not update object ${objectId} status to failed`, {
+            error: e,
+            upstreamError: params.errorMessage,
+            workflow_name: payload.workflow_name,
+        });
     }
     return;
 }

package/src/activities/index-dsl.ts

@@ -1,32 +1,32 @@
 // Export here DSL activities
-export { executeRemoteActivity } from "./executeRemoteActivity.js";
-export { resolveRemoteActivities } from "./resolveRemoteActivities.js";
-export type { RemoteActivityInfo, RemoteActivityMap } from "./resolveRemoteActivities.js";
-export { createDocumentTypeFromInteractionRun } from "./advanced/createDocumentTypeFromInteractionRun.js";
-export { createOrUpdateDocumentFromInteractionRun } from "./advanced/createOrUpdateDocumentFromInteractionRun.js";
-export { updateDocumentFromInteractionRun } from "./advanced/updateDocumentFromInteractionRun.js";
-export { chunkDocument } from "./chunkDocument.js";
-export { createPdfDocumentFromSource } from "./createDocumentFromOther.js";
-export { executeInteraction } from "./executeInteraction.js";
-export { extractDocumentText } from "./extractDocumentText.js";
-export { generateDocumentProperties } from "./generateDocumentProperties.js";
-export { generateEmbeddings } from "./generateEmbeddings.js";
-export { generateOrAssignContentType } from "./generateOrAssignContentType.js";
-export { getObjectFromStore } from "./getObjectFromStore.js";
-export { handleDslError } from "./handleError.js";
-export { prepareAudio } from "./media/prepareAudio.js";
-export { prepareVideo } from "./media/prepareVideo.js";
-export { probeMediaStreams } from "./media/probeMediaStreams.js";
-export type { ProbeMediaStreamsResult } from "./media/probeMediaStreams.js";
-export { convertPdfToStructuredText } from "./media/processPdfWithTextract.js";
-export { saveGladiaTranscription } from "./media/saveGladiaTranscription.js";
-export { transcribeMedia } from "./media/transcribeMediaWithGladia.js";
-export type { TranscriptMediaResult } from "./media/transcribeMediaWithGladia.js";
-export { mergeChildArtifacts } from "./mergeChildArtifacts.js";
-export { notifyWebhook } from "./notifyWebhook.js";
-export { checkRateLimit } from "./rateLimiter.js";
-export { generateImageRendition } from "./renditions/generateImageRendition.js";
-export { generateVideoRendition } from "./renditions/generateVideoRendition.js";
-export { setDocumentStatus } from "./setDocumentStatus.js";
-export { loadChildWorkflowSpec } from "./loadChildWorkflowSpec.js";
 
+export { createDocumentTypeFromInteractionRun } from './advanced/createDocumentTypeFromInteractionRun.js';
+export { createOrUpdateDocumentFromInteractionRun } from './advanced/createOrUpdateDocumentFromInteractionRun.js';
+export { updateDocumentFromInteractionRun } from './advanced/updateDocumentFromInteractionRun.js';
+export { chunkDocument } from './chunkDocument.js';
+export { createPdfDocumentFromSource } from './createDocumentFromOther.js';
+export { executeInteraction } from './executeInteraction.js';
+export { executeRemoteActivity } from './executeRemoteActivity.js';
+export { extractDocumentText } from './extractDocumentText.js';
+export { generateDocumentProperties } from './generateDocumentProperties.js';
+export { generateEmbeddings } from './generateEmbeddings.js';
+export { generateOrAssignContentType } from './generateOrAssignContentType.js';
+export { getObjectFromStore } from './getObjectFromStore.js';
+export { handleDslError } from './handleError.js';
+export { loadChildWorkflowSpec } from './loadChildWorkflowSpec.js';
+export { prepareAudio } from './media/prepareAudio.js';
+export { prepareVideo } from './media/prepareVideo.js';
+export type { ProbeMediaStreamsResult } from './media/probeMediaStreams.js';
+export { probeMediaStreams } from './media/probeMediaStreams.js';
+export { convertPdfToStructuredText } from './media/processPdfWithTextract.js';
+export { saveGladiaTranscription } from './media/saveGladiaTranscription.js';
+export type { TranscriptMediaResult } from './media/transcribeMediaWithGladia.js';
+export { transcribeMedia } from './media/transcribeMediaWithGladia.js';
+export { mergeChildArtifacts } from './mergeChildArtifacts.js';
+export { notifyWebhook } from './notifyWebhook.js';
+export { checkRateLimit } from './rateLimiter.js';
+export { generateImageRendition } from './renditions/generateImageRendition.js';
+export { generateVideoRendition } from './renditions/generateVideoRendition.js';
+export type { RemoteActivityInfo, RemoteActivityMap } from './resolveRemoteActivities.js';
+export { resolveRemoteActivities } from './resolveRemoteActivities.js';
+export { setDocumentStatus } from './setDocumentStatus.js';

package/src/activities/index.ts

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