@vertesia/workflow 0.47.0 → 0.49.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "0.47.0",
+  "version": "0.49.0",
   "type": "module",
   "description": "Composable prompts workflow dsl",
   "main": "./lib/esm/index.js",
@@ -49,9 +49,9 @@
     "tiktoken": "^1.0.15",
     "tmp": "^0.2.3",
     "yaml": "^2.6.0",
-    "@vertesia/client": "0.47.0",
-    "@vertesia/common": "0.47.0",
-    "@llumiverse/core": "0.15.0"
+    "@llumiverse/core": "0.15.0",
+    "@vertesia/client": "0.49.0",
+    "@vertesia/common": "0.49.0"
   },
   "ts_dual_module": {
     "outDir": "lib",

package/src/activities/advanced/createDocumentTypeFromInteractionRun.ts

@@ -21,7 +21,7 @@ export interface CreateDocumentTypeFromInteractionRun extends DSLActivitySpec<Cr
     name: 'createDocumentTypeFromInteractionRun';
 }
 
-export async function createDocumentTypeFromInteractionRun(payload: DSLActivityExecutionPayload) {
+export async function createDocumentTypeFromInteractionRun(payload: DSLActivityExecutionPayload<CreateDocumentTypeFromInteractionRunParams>) {
     const { params, client } = await setupActivity<CreateDocumentTypeFromInteractionRunParams>(payload);
 
     if (!params.run) {

package/src/activities/advanced/createOrUpdateDocumentFromInteractionRun.ts

@@ -28,7 +28,7 @@ export interface CreateOrUpdateObjectFromInteractionRun extends DSLActivitySpec<
     name: 'createOrUpdateDocumentFromInteractionRun';
 }
 
-export async function createOrUpdateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload) {
+export async function createOrUpdateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload<CreateOrUpdateObjectFromInteractionRunParams>) {
     const { params, client } = await setupActivity<CreateOrUpdateObjectFromInteractionRunParams>(payload);
 
     const runId = params.run_id;

package/src/activities/advanced/updateDocumentFromInteractionRun.ts

@@ -15,7 +15,7 @@ export interface UpdateDocumentFromInteractionRun extends DSLActivitySpec<Update
     name: 'updateDocumentFromInteractionRun';
 }
 
-export async function updateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload) {
+export async function updateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload<UpdateDocumentFromInteractionRunParams>) {
     const { params, client, objectId } = await setupActivity<UpdateDocumentFromInteractionRunParams>(payload);
 
     if (!params.run) {

package/src/activities/chunkDocument.ts

@@ -32,7 +32,7 @@ export interface ChunkDocument extends DSLActivitySpec<ChunkDocumentParams> {
 }
 
 
-export async function chunkDocument(payload: DSLActivityExecutionPayload): Promise<ChunkDocumentResult> {
+export async function chunkDocument(payload: DSLActivityExecutionPayload<ChunkDocumentParams>): Promise<ChunkDocumentResult> {
     const { params, client, objectId } = await setupActivity<ChunkDocumentParams>(payload);
 
     const { force } = params;

package/src/activities/createDocumentFromOther.ts

@@ -27,7 +27,7 @@ export interface CreatePdfDocumentFromSource extends DSLActivitySpec<CreatePdfDo
  * Create a new PDF by extrracting pages from a source PDF
  * @returns
  */
-export async function createPdfDocumentFromSource(payload: DSLActivityExecutionPayload) {
+export async function createPdfDocumentFromSource(payload: DSLActivityExecutionPayload<CreatePdfDocumentFromSourceParams>) {
     const { client, objectId, params } = await setupActivity<CreatePdfDocumentFromSourceParams>(payload);
     const inputObject = await client.objects.retrieve(objectId);
 

package/src/activities/executeInteraction.ts

@@ -93,7 +93,7 @@ export interface ExecuteInteraction extends DSLActivitySpec<ExecuteInteractionPa
     name: 'executeInteraction';
 }
 
-export async function executeInteraction(payload: DSLActivityExecutionPayload) {
+export async function executeInteraction(payload: DSLActivityExecutionPayload<ExecuteInteractionParams>) {
     const {
         client, params
     } = await setupActivity<ExecuteInteractionParams>(payload);

package/src/activities/extractDocumentText.ts

@@ -15,14 +15,13 @@ const JSON: DSLActivitySpec = {
 }
 
 // doesn't have any own param
-export type ExtractDocumentTextParams = never;
-
+export interface ExtractDocumentTextParams { };
 export interface ExtractDocumentText extends DSLActivitySpec<ExtractDocumentTextParams> {
     name: 'extractDocumentText';
     projection?: never;
 }
 
-export async function extractDocumentText(payload: DSLActivityExecutionPayload): Promise<TextExtractionResult> {
+export async function extractDocumentText(payload: DSLActivityExecutionPayload<ExtractDocumentTextParams>): Promise<TextExtractionResult> {
     const { client, objectId } = await setupActivity(payload);
 
     const r = await client.objects.find({

package/src/activities/generateDocumentProperties.ts

@@ -20,7 +20,7 @@ export interface GenerateDocumentProperties extends DSLActivitySpec<GenerateDocu
     name: 'generateDocumentProperties';
 }
 
-export async function generateDocumentProperties(payload: DSLActivityExecutionPayload) {
+export async function generateDocumentProperties(payload: DSLActivityExecutionPayload<GenerateDocumentPropertiesParams>) {
     const context = await setupActivity<GenerateDocumentPropertiesParams>(payload);
     const { params, client, objectId } = context;
     const interactionName = params.interactionName ?? INT_EXTRACT_INFORMATION;

package/src/activities/generateEmbeddings.ts

@@ -20,7 +20,7 @@ export interface GenerateEmbeddings extends DSLActivitySpec<GenerateEmbeddingsPa
     name: 'generateEmbeddings';
 }
 
-export async function generateEmbeddings(payload: DSLActivityExecutionPayload) {
+export async function generateEmbeddings(payload: DSLActivityExecutionPayload<GenerateEmbeddingsParams>) {
     const { params, client, objectId, fetchProject } = await setupActivity<GenerateEmbeddingsParams>(payload);
     const { force, type } = params;
 

package/src/activities/generateImageRendition.ts

@@ -22,7 +22,7 @@ export interface GenerateImageRendition extends DSLActivitySpec<GenerateImageRen
 }
 
 
-export async function generateImageRendition(payload: DSLActivityExecutionPayload) {
+export async function generateImageRendition(payload: DSLActivityExecutionPayload<GenerateImageRenditionParams>) {
     const { client, objectId, params } = await setupActivity<GenerateImageRenditionParams>(payload);
 
     const supportedNonImageInputTypes = ['application/pdf']

package/src/activities/generateOrAssignContentType.ts

@@ -1,5 +1,5 @@
-import { CreateContentObjectTypePayload, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
 import { log } from "@temporalio/activity";
+import { 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";
@@ -28,7 +28,7 @@ export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrA
     name: 'generateOrAssignContentType';
 }
 
-export async function generateOrAssignContentType(payload: DSLActivityExecutionPayload) {
+export async function generateOrAssignContentType(payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>) {
     const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
     const { params, client, objectId } = context;
 
@@ -119,7 +119,7 @@ export async function generateOrAssignContentType(payload: DSLActivityExecutionP
     };
 }
 
-async function generateNewType(context: ActivityContext, existing_types: string[], content?: string, fileRef?: string) {
+async function generateNewType(context: ActivityContext<GenerateOrAssignContentTypeParams>, existing_types: string[], content?: string, fileRef?: string) {
     const { client, params } = context;
 
     const project = await context.fetchProject();

package/src/activities/getObjectFromStore.ts

@@ -16,7 +16,7 @@ export interface GetObject extends DSLActivitySpec<GetObjectParams> {
  * @param objectId
  * @param status
  */
-export async function getObjectFromStore(payload: DSLActivityExecutionPayload): Promise<ContentObject> {
+export async function getObjectFromStore(payload: DSLActivityExecutionPayload<GetObjectParams>): Promise<ContentObject> {
     const { client, params, objectId } = await setupActivity<GetObjectParams>(payload);
 
     const obj = await client.objects.retrieve(objectId, params.select);

package/src/activities/index-dsl.ts

@@ -0,0 +1,17 @@
+// Export here DSL activities
+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 { generateImageRendition } from "./generateImageRendition.js";
+export { generateOrAssignContentType } from "./generateOrAssignContentType.js";
+export { getObjectFromStore } from "./getObjectFromStore.js";
+export { convertPdfToStructuredText } from "./media/processPdfWithTextract.js";
+export { transcribeMedia } from "./media/transcribeMediaWithGladia.js";
+export { notifyWebhook } from "./notifyWebhook.js";
+export { setDocumentStatus } from "./setDocumentStatus.js";

package/src/activities/index.ts

@@ -1,21 +1,5 @@
 /**
  * Here we export all activities to be registered with the temporal worker
  */
-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 { generateImageRendition } from "./generateImageRendition.js";
-export { generateOrAssignContentType } from "./generateOrAssignContentType.js";
-export { getObjectFromStore } from "./getObjectFromStore.js";
-export { convertPdfToStructuredText } from "./media/processPdfWithTextract.js";
-export { transcribeMedia } from "./media/transcribeMediaWithGladia.js";
-export { notifyWebhook } from "./notifyWebhook.js";
-export { setDocumentStatus } from "./setDocumentStatus.js";
-
+export * from "./index-dsl.js";
 export * from "../iterative-generation/activities/index.js";

package/src/activities/media/processPdfWithTextract.ts

@@ -37,7 +37,7 @@ export interface StructuredTextResult extends TextExtractionResult {
 
 
 
-export async function convertPdfToStructuredText(payload: DSLActivityExecutionPayload): Promise<StructuredTextResult> {
+export async function convertPdfToStructuredText(payload: DSLActivityExecutionPayload<ConvertPdfToStructuredTextParams>): Promise<StructuredTextResult> {
 
 
     const { params, client, objectId } = await setupActivity<ConvertPdfToStructuredTextParams>(payload);

package/src/activities/media/transcribeMediaWithGladia.ts

@@ -21,7 +21,7 @@ export interface TranscriptMediaResult extends TextExtractionResult {
 
 const GLADIA_URL = "https://api.gladia.io/v2";
 
-export async function transcribeMedia(payload: DSLActivityExecutionPayload): Promise<TranscriptMediaResult> {
+export async function transcribeMedia(payload: DSLActivityExecutionPayload<TranscriptMediaParams>): Promise<TranscriptMediaResult> {
 
     const { params, client, objectId } = await setupActivity<TranscriptMediaParams>(payload);
 

package/src/activities/notifyWebhook.ts

@@ -16,7 +16,7 @@ export interface NotifyWebhook extends DSLActivitySpec<NotifyWebhookParams> {
 }
 
 
-export async function notifyWebhook(payload: DSLActivityExecutionPayload) {
+export async function notifyWebhook(payload: DSLActivityExecutionPayload<NotifyWebhookParams>) {
 
     const { params } = await setupActivity<NotifyWebhookParams>(payload);
     const { target_url, method, payload: requestPayload, headers } = params
@@ -46,6 +46,6 @@ export async function notifyWebhook(payload: DSLActivityExecutionPayload) {
         throw new Error(`Failed to notify webhook ${target_url}: ${res.statusText}`);
     }
 
-    return {status: res.status, message: res.statusText, url: res.url }
+    return { status: res.status, message: res.statusText, url: res.url }
 
 }

package/src/activities/setDocumentStatus.ts

@@ -15,7 +15,7 @@ export interface SetDocumentStatus extends DSLActivitySpec<SetDocumentStatusPara
  * @param objectId
  * @param status
  */
-export async function setDocumentStatus(payload: DSLActivityExecutionPayload) {
+export async function setDocumentStatus(payload: DSLActivityExecutionPayload<SetDocumentStatusParams>) {
     const { client, params, objectId } = await setupActivity<SetDocumentStatusParams>(payload);
 
     const res = await client.objects.update(objectId, { status: params.status });

package/src/dsl/dsl-workflow.ts

@@ -16,12 +16,12 @@ interface BaseActivityPayload extends WorkflowExecutionPayload {
     debug_mode?: boolean;
 }
 
-function dslActivityPayload(basePayload: BaseActivityPayload, activity: DSLActivitySpec, params: Record<string, any> = {}) {
+function dslActivityPayload<ParamsT extends Record<string, any>>(basePayload: BaseActivityPayload, activity: DSLActivitySpec, params: ParamsT) {
     return {
         ...basePayload,
         activity,
-        params,
-    } as DSLActivityExecutionPayload
+        params: params || {},
+    } as DSLActivityExecutionPayload<ParamsT>
 }
 
 export async function dslWorkflow(payload: DSLWorkflowExecutionPayload) {

package/src/dsl/dslProxyActivities.ts

@@ -0,0 +1,38 @@
+import { ActivityOptions, proxyActivities } from "@temporalio/workflow";
+import { DSLActivityExecutionPayload, WorkflowExecutionPayload } from "@vertesia/common";
+
+export interface DslActivityFunction<ParamsT extends Record<string, any> = any, ReturnT = any> {
+    (payload: DSLActivityExecutionPayload<ParamsT>): Promise<ReturnT>;
+}
+
+export interface DslSimplifiedActivityFunction<ParamsT = any, ReturnT = any> {
+    (payload: WorkflowExecutionPayload, params: ParamsT): Promise<ReturnT>;
+}
+
+export function dslProxyActivities<
+    ActivitiesT extends Record<string, DslActivityFunction<any, any>>
+>(workflowName: string, options: ActivityOptions = {}) {
+    type DslActivities = {
+        [K in keyof ActivitiesT]: ActivitiesT[K] extends DslActivityFunction<infer ParamsT, infer ReturnT>
+        ? DslSimplifiedActivityFunction<ParamsT, ReturnT>
+        : never;
+    };
+
+    const activities = proxyActivities<ActivitiesT>(options) as ActivitiesT;
+
+    return new Proxy({}, {
+        get(_target, prop) {
+            const activityFn = activities[prop as keyof ActivitiesT] as DslActivityFunction;
+            return (payload: WorkflowExecutionPayload, params: any) => {
+                return activityFn({
+                    ...payload,
+                    activity: {
+                        name: prop as string,
+                    },
+                    workflow_name: workflowName,
+                    params,
+                });
+            };
+        },
+    }) as unknown as DslActivities;
+}

package/src/dsl/projections.ts

@@ -51,7 +51,7 @@ function runProjection(obj: any, vars: Vars) {
     return obj; // return the value as is
 }
 
-export function projectResult(payload: DSLActivityExecutionPayload, params: Record<string, any>, result: any, fallback: any) {
+export function projectResult<TParams extends Record<string, any>>(payload: DSLActivityExecutionPayload<TParams>, params: Record<string, any>, result: any, fallback: any) {
     return payload.activity.projection ? makeProjection(payload.activity.projection, params, result) : fallback;
 }
 

package/src/dsl/setup/ActivityContext.ts

@@ -13,11 +13,11 @@ registerFetchProviderFactory(DocumentProvider.ID, DocumentProvider.factory);
 registerFetchProviderFactory(DocumentTypeProvider.ID, DocumentTypeProvider.factory);
 registerFetchProviderFactory(InteractionRunProvider.ID, InteractionRunProvider.factory);
 
-export class ActivityContext<T extends Record<string, any> = Record<string, any>> {
+export class ActivityContext<ParamsT extends Record<string, any>> {
     client: VertesiaClient;
     _project?: Promise<Project | undefined>;
 
-    constructor(public payload: DSLActivityExecutionPayload, client: VertesiaClient, public params: T) {
+    constructor(public payload: DSLActivityExecutionPayload<ParamsT>, client: VertesiaClient, public params: ParamsT) {
         this.client = client;
         this.fetchProject = this.fetchProject.bind(this);
     }
@@ -45,7 +45,7 @@ export class ActivityContext<T extends Record<string, any> = Record<string, any>
 }
 
 
-export async function setupActivity<T extends Record<string, any> = Record<string, any>>(payload: DSLActivityExecutionPayload) {
+export async function setupActivity<ParamsT extends Record<string, any>>(payload: DSLActivityExecutionPayload<ParamsT>) {
 
     const isDebugMode = !!payload.debug_mode;
 
@@ -93,10 +93,10 @@ export async function setupActivity<T extends Record<string, any> = Record<strin
         }
     }
 
-    const params = vars.resolve() as T;
+    const params = vars.resolve() as ParamsT;
     log.info(`Activity ${payload.activity.name} setup complete`, { params });
 
-    return new ActivityContext<T>(payload, client, params);
+    return new ActivityContext<ParamsT>(payload, client, params);
 }
 
 

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

@@ -5,17 +5,25 @@ import { afterAll, beforeAll, describe, expect, test } from 'vitest';
 import { dslWorkflow } from './dsl-workflow.js';
 import { setupActivity } from './setup/ActivityContext.js';
 
-async function sayHelloFromParent(payload: DSLActivityExecutionPayload) {
+interface SayHelloParams {
+    name: string;
+}
+interface PrepareResultParams {
+    parent: string;
+    child: string;
+}
+
+async function sayHelloFromParent(payload: DSLActivityExecutionPayload<SayHelloParams>) {
     const { params } = await setupActivity(payload);
     return `Parent: Hello, ${params.name}!`;
 }
 
-async function sayHelloFromDSLChild(payload: DSLActivityExecutionPayload) {
+async function sayHelloFromDSLChild(payload: DSLActivityExecutionPayload<SayHelloParams>) {
     const { params } = await setupActivity(payload);
     return `DSL Child: Hello, ${params.name}!`;
 }
 
-async function prepareResult(payload: DSLActivityExecutionPayload) {
+async function prepareResult(payload: DSLActivityExecutionPayload<PrepareResultParams>) {
     const { params } = await setupActivity(payload);
     return [params.parent, params.child]
 }

package/src/dsl/workflow-fetch.test.ts

@@ -8,6 +8,9 @@ import { setupActivity } from "./setup/ActivityContext.js";
 import { DataProvider } from './setup/fetch/DataProvider.js';
 import { registerFetchProviderFactory } from './setup/fetch/index.js';
 
+interface SayMessageParams {
+    message: string;
+}
 
 class DocumentTestProvider extends DataProvider {
 
@@ -35,7 +38,7 @@ class DocumentTestProvider extends DataProvider {
 registerFetchProviderFactory(DocumentTestProvider.ID, DocumentTestProvider.factory);
 
 
-async function sayMessage(payload: DSLActivityExecutionPayload): Promise<string> {
+async function sayMessage(payload: DSLActivityExecutionPayload<SayMessageParams>): Promise<string> {
     const { params } = await setupActivity(payload);
     return params.message;
 }

package/src/index.ts

@@ -25,3 +25,4 @@ export * from "./activities/notifyWebhook.js";
 export * from "./iterative-generation/activities/index.js";
 
 export * from "./result-types.js";
+export * from "./dsl/dslProxyActivities.js";

package/src/system/generateObjectText.ts

@@ -1,15 +1,15 @@
 
-import { DSLWorkflowExecutionPayload } from "@vertesia/common";
-import { log, proxyActivities } from "@temporalio/workflow";
-import { GetObject } from "../activities/getObjectFromStore.js";
-import * as activities from "../activities/index.js";
+import { log } from "@temporalio/workflow";
+import { WorkflowExecutionPayload } from "@vertesia/common";
+import * as activities from "../activities/index-dsl.js";
+import { dslProxyActivities } from "../dsl/dslProxyActivities.js";
 import { NoDocumentFound } from "../errors.js";
 import { TextExtractionResult } from "../index.js";
 
 const {
     getObjectFromStore,
     extractDocumentText
-} = proxyActivities<typeof activities>({
+} = dslProxyActivities<typeof activities>("generateTextWorkflow", {
     startToCloseTimeout: "5 minute",
     retry: {
         initialInterval: '5s',
@@ -23,7 +23,7 @@ const {
 const {
     transcribeMedia,
     convertPdfToStructuredText
-} = proxyActivities<typeof activities>({
+} = dslProxyActivities<typeof activities>("generateTextWorkflow", {
     startToCloseTimeout: "30 minute",
     retry: {
         initialInterval: '30s',
@@ -35,19 +35,12 @@ const {
 });
 
 
-export async function generateObjectText(payload: DSLWorkflowExecutionPayload): Promise<TextExtractionResult> {
+export async function generateObjectText(payload: WorkflowExecutionPayload): Promise<TextExtractionResult> {
 
     const { objectIds } = payload;
     const objectId = objectIds[0];
 
-    const object = await getObjectFromStore({
-        ...payload,
-        activity: {
-            name: "getObject",
-        } satisfies GetObject,
-        params: {},
-        workflow_name: "Generate Text",
-    });
+    const object = await getObjectFromStore(payload, {});
 
     if (!object.content?.source) {
         throw new NoDocumentFound(`No source or mimetype found for object ${objectId}`, objectIds);
@@ -63,16 +56,9 @@ export async function generateObjectText(payload: DSLWorkflowExecutionPayload):
     }
     log.info(`Converting file type ${mimetype} to text with ${converter.name}`);
 
-    const res = await converter.activity(payload)({
-        ...payload,
-        activity: {
-            name: converter.name,
-        },
-        params: converter.params,
-        workflow_name: "Generate Text",
-    });
+    const res = await converter.activity(payload)(payload, converter.params);
 
-    log.info("Generated text for object", {res, objectId});
+    log.info("Generated text for object", { res, objectId });
     return res;
 
 }
@@ -81,8 +67,8 @@ export async function generateObjectText(payload: DSLWorkflowExecutionPayload):
 const ConverterActivity = [
     {
         type: /application\/pdf/,
-        activity: (payload: DSLWorkflowExecutionPayload) => {
-            const useTextractForPDF = payload.vars?.useTextractForPdf?? false;
+        activity: (payload: WorkflowExecutionPayload) => {
+            const useTextractForPDF = payload.vars?.useTextractForPdf ?? false;
             return useTextractForPDF ? convertPdfToStructuredText : extractDocumentText;
         },
         name: "ConvertPdfToStructuredText",

package/src/system/notifyWebhookWorkflow.ts

@@ -1,11 +1,12 @@
 
-import { ContentEventName, DSLWorkflowExecutionPayload } from "@vertesia/common";
-import { log, proxyActivities } from "@temporalio/workflow";
-import * as activities from "../activities/index.js";
+import { log } from "@temporalio/workflow";
+import { ContentEventName, WorkflowExecutionPayload } from "@vertesia/common";
+import * as activities from "../activities/index-dsl.js";
+import { dslProxyActivities } from "../dsl/dslProxyActivities.js";
 
 const {
     notifyWebhook
-} = proxyActivities<typeof activities>({
+} = dslProxyActivities<typeof activities>("notifyWebhookWorkflow", {
     startToCloseTimeout: "5 minute",
     retry: {
         initialInterval: '5s',
@@ -17,10 +18,7 @@ const {
 });
 
 
-interface NotifyWebhookWorkflowParams extends DSLWorkflowExecutionPayload {
-}
-
-export async function notifyWebhookWorkflow(payload: NotifyWebhookWorkflowParams): Promise<any> {
+export async function notifyWebhookWorkflow(payload: WorkflowExecutionPayload): Promise<any> {
 
     const { objectIds, vars } = payload;
     const notifications = [];
@@ -33,23 +31,16 @@ export async function notifyWebhookWorkflow(payload: NotifyWebhookWorkflowParams
     }
 
     for (const ep of endpoints) {
-        const n = notifyWebhook({
-            ...payload,
-            activity: {
-                name: "notifyWebhook",
-            } ,
-            params: {
-                target_url: ep,
-                method: 'POST',
-                payload: {
-                    object_ids: objectIds,
-                    event: eventName,
-                    data: vars.webhook_data ?? undefined,
-                    vars
-                }
-            },
-            workflow_name: "Notify Webhook",
-        } ).then(res => {
+        const n = notifyWebhook(payload, {
+            target_url: ep,
+            method: 'POST',
+            payload: {
+                object_ids: objectIds,
+                event: eventName,
+                data: vars.webhook_data ?? undefined,
+                vars
+            }
+        }).then(res => {
             log.info(`Webhook notified at ${ep} with response code: ${res.status}`, { res });
             return res;
         });

package/src/system/recalculateEmbeddingsWorkflow.ts

@@ -1,13 +1,12 @@
-import { proxyActivities } from "@temporalio/workflow";
 
-import { DSLActivitySpec, DSLWorkflowExecutionPayload, SupportedEmbeddingTypes } from "@vertesia/common";
-import { GenerateEmbeddings } from "../activities/generateEmbeddings.js";
-import * as activities from "../activities/index.js";
+import { SupportedEmbeddingTypes, WorkflowExecutionPayload } from "@vertesia/common";
+import * as activities from "../activities/index-dsl.js";
+import { dslProxyActivities } from "../dsl/dslProxyActivities.js";
 import { NoDocumentFound } from "../errors.js";
 
 const {
     generateEmbeddings,
-} = proxyActivities<typeof activities>({
+} = dslProxyActivities<typeof activities>("recalculateEmbeddingsWorkflow", {
     startToCloseTimeout: "5 minute",
     retry: {
         initialInterval: '10s',
@@ -18,25 +17,15 @@ const {
     },
 });
 
-export async function recalculateEmbeddingsWorkflow(payload: DSLWorkflowExecutionPayload) {
+export async function recalculateEmbeddingsWorkflow(payload: WorkflowExecutionPayload) {
 
     const embeddings = [];
 
     for (const type of Object.values(SupportedEmbeddingTypes)) {
-        const activityConfig: DSLActivitySpec = {
-            name: 'generateEmbeddings',
-            params: {
-                force: true,
-                type
-            },
-        } satisfies GenerateEmbeddings;
-
-        embeddings.push(generateEmbeddings({
-            ...payload,
-            params: {},
-            workflow_name: 'recalculateEmbeddingsWorkflow',
-            activity: activityConfig,
-        }));
+        embeddings.push(generateEmbeddings(payload, {
+            force: true,
+            type
+        }))
     }
 
     const res = await Promise.all(embeddings);

package/src/utils/blobs.ts

@@ -10,7 +10,7 @@ export async function fetchBlobAsStream(client: VertesiaClient, blobUri: string)
     try {
         return await client.files.downloadFile(blobUri);
     } catch (err: any) {
-        throw new NoDocumentFound(`Blob ${blobUri} not found`, []);
+        throw new NoDocumentFound(`Failed to download blob ${blobUri}: ${err.message}`, []);
     }
 }
 export async function fetchBlobAsBuffer(client: VertesiaClient, blobUri: string): Promise<Buffer> {