@vertesia/workflow 0.65.0 → 0.67.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "0.65.0",
+  "version": "0.67.0",
   "type": "module",
   "description": "Composable prompts workflow dsl",
   "main": "./lib/esm/index.js",
@@ -39,8 +39,10 @@
     "@vertesia/memory": "^0.43.0",
     "fast-deep-equal": "^3.1.3",
     "jsonwebtoken": "^9.0.2",
+    "mime": "^4.0.0",
     "ms": "3.0.0-canary.1",
     "node-web-stream-adapters": "^0.2.1",
+    "p-limit": "^6.2.0",
     "papaparse": "^5.4.1",
     "seedrandom": "^3.0.5",
     "sharp": "^0.33.4",
@@ -48,11 +50,10 @@
     "tmp": "^0.2.3",
     "tmp-promise": "^3.0.3",
     "yaml": "^2.6.0",
-    "mime": "^4.0.0",
-    "@llumiverse/common": "0.18.0",
-    "@vertesia/common": "0.65.0",
-    "@vertesia/client": "0.65.0",
-    "@vertesia/api-fetch-client": "0.65.0"
+    "@vertesia/client": "0.67.0",
+    "@vertesia/api-fetch-client": "0.67.0",
+    "@llumiverse/common": "0.20.0",
+    "@vertesia/common": "0.67.0"
   },
   "ts_dual_module": {
     "outDir": "lib",

package/src/activities/generateOrAssignContentType.ts

@@ -202,6 +202,7 @@ async function generateNewType(
   log.info("Generated schema for type", genTypeRes.result.metadata_schema);
   const typeData: CreateContentObjectTypePayload = {
     name: genTypeRes.result.document_type,
+    description: genTypeRes.result.document_type_description,
     object_schema: genTypeRes.result.metadata_schema,
     is_chunkable: genTypeRes.result.is_chunkable,
     table_layout: genTypeRes.result.table_layout,

package/src/activities/renditions/generateImageRendition.ts

@@ -4,96 +4,113 @@ import { setupActivity } from "../../dsl/setup/ActivityContext.js";
 import { DocumentNotFoundError, WorkflowParamNotFoundError } from "../../errors.js";
 import { saveBlobToTempFile } from "../../utils/blobs.js";
 import {
-  ImageRenditionParams,
-  uploadRenditionPages,
+    ImageRenditionParams,
+    uploadRenditionPages,
 } from "../../utils/renditions.js";
 
-interface GenerateImageRenditionParams extends ImageRenditionParams {}
+interface GenerateImageRenditionParams extends ImageRenditionParams { }
 
 export interface GenerateImageRendition
-  extends DSLActivitySpec<GenerateImageRenditionParams> {
-  name: "generateImageRendition";
+    extends DSLActivitySpec<GenerateImageRenditionParams> {
+    name: "generateImageRendition";
 }
 
 export async function generateImageRendition(
-  payload: DSLActivityExecutionPayload<GenerateImageRenditionParams>,
+    payload: DSLActivityExecutionPayload<GenerateImageRenditionParams>,
 ) {
-  const {
-    client,
-    objectId,
-    params: originParams,
-  } = await setupActivity<GenerateImageRenditionParams>(payload);
-
-  // Fix: Use maxHeightWidth if max_hw is not provided
-  const params = {
-    ...originParams,
-    max_hw: originParams.max_hw || (originParams as any).maxHeightWidth || 1024, // Default to 1024 if both are missing
-    format: originParams.format || (originParams as any).format_output || "png", // Default to png if format is missing
-  };
-
-  log.info(`Generating image rendition for ${objectId}`, {
-    originParams,
-    params,
-  });
-
-  const inputObject = await client.objects.retrieve(objectId).catch((err) => {
-    log.error(`Failed to retrieve document ${objectId}`, { err });
-    if (err.message.includes("not found")) {
-      throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
+    const {
+        client,
+        objectId,
+        params: originParams,
+    } = await setupActivity<GenerateImageRenditionParams>(payload);
+
+    // Fix: Use maxHeightWidth if max_hw is not provided
+    const params = {
+        ...originParams,
+        max_hw: originParams.max_hw || (originParams as any).maxHeightWidth || 1024, // Default to 1024 if both are missing
+        format: originParams.format || (originParams as any).format_output || "png", // Default to png if format is missing
+    };
+
+    log.info(`Generating image rendition for ${objectId}`, {
+        originParams,
+        params,
+    });
+
+    const inputObject = await client.objects.retrieve(objectId).catch((err) => {
+        log.error(`Failed to retrieve document ${objectId}`, { err });
+        if (err.message.includes("not found")) {
+            throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
+        }
+        throw err;
+    });
+
+    if (!inputObject) {
+        log.error(`Document ${objectId} not found`);
+        throw new DocumentNotFoundError(`Document ${objectId} not found`, [objectId]);
     }
-    throw err;
-  });
-
-  if (!params.format) {
-    log.error(`Format not found`);
-    throw new WorkflowParamNotFoundError(`format`);
-  }
-
-  if (!inputObject.content?.source) {
-    log.error(`Document ${objectId} has no source`);
-    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}`,
-    );
-    throw new DocumentNotFoundError(
-      `Document ${objectId} is not an image or a video: ${inputObject.content.type}`,
-      [objectId],
+
+    if (!inputObject.content?.source) {
+        log.error(`Document ${objectId} has no etag or source`);
+        throw new DocumentNotFoundError(`Document ${objectId} has no etag or source`, [objectId]);
+    }
+
+    if (!params.format) {
+        log.error(`Format not found`);
+        throw new WorkflowParamNotFoundError(`format`);
+    }
+
+    if (!inputObject.content?.source) {
+        log.error(`Document ${objectId} has no source`);
+        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}`,
+        );
+        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[] = [];
+
+    const imageFile = await saveBlobToTempFile(
+        client,
+        inputObject.content.source,
     );
-  }
-
-  //array of rendition files to upload
-  let renditionPages: string[] = [];
-
-  const imageFile = await saveBlobToTempFile(
-    client,
-    inputObject.content.source,
-  );
-  log.info(`Image ${objectId} copied to ${imageFile}`);
-  renditionPages.push(imageFile);
-
-  const uploaded = await uploadRenditionPages(
-    client,
-    objectId,
-    [imageFile],
-    params,
-  );
-
-  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`,
+    log.info(`Image ${objectId} copied to ${imageFile}`);
+    renditionPages.push(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;
+
+    const uploaded = await uploadRenditionPages(
+        client,
+        contentEtag,
+        [imageFile],
+        params,
     );
-  }
 
-  return {
-    uploads: uploaded.map((u) => u),
-    format: params.format,
-    status: "success",
-  };
+    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",
+    };
 }

package/src/activities/renditions/generateVideoRendition.ts

@@ -271,10 +271,15 @@ export async function generateVideoRendition(
         }
     }
 
+    if (!inputObject.content?.etag) {
+        log.warn(`Document ${objectId} has no etag, using object id as etag`);
+    }
+    const etag = inputObject.content.etag ?? inputObject.id;
+
     // Update the final upload call to handle multiple thumbnails
     const uploaded = await uploadRenditionPages(
         client,
-        objectId,
+        etag,
         renditionPages,
         params,
     );

package/src/errors.ts

@@ -1,20 +1,6 @@
 import { ApplicationFailure } from "@temporalio/workflow";
 import { DSLActivitySpec, DSLWorkflowSpec } from "@vertesia/common";
 
-/**
- * @deprecated Use {@link DocumentNotFoundError} instead.
- */
-export class NoDocumentFound extends Error {
-    constructor(
-        message: string,
-        public ids?: string[],
-    ) {
-        super(message);
-        this.name = "NoDocumentFound";
-        this.ids = ids;
-    }
-}
-
 export class DocumentNotFoundError extends ApplicationFailure {
     constructor(message: string, public ids?: string[]) {
         super(
@@ -25,19 +11,6 @@ export class DocumentNotFoundError extends ApplicationFailure {
     }
 }
 
-/**
- * @deprecated Use {@link ActivityParamNotFoundError} instead.
- */
-export class ActivityParamNotFound extends Error {
-    constructor(
-        public paramName: string,
-        public activity: DSLActivitySpec,
-    ) {
-        super(`Required parameter ${paramName} not found in activity ${activity.name}`);
-        this.name = "ActivityParamNotFound";
-    }
-}
-
 export class ActivityParamNotFoundError extends ApplicationFailure {
     constructor(
         public paramName: string,
@@ -51,20 +24,6 @@ export class ActivityParamNotFoundError extends ApplicationFailure {
     }
 }
 
-/**
- * @deprecated Use {@link ActivityParamInvalidError} instead.
- */
-export class ActivityParamInvalid extends Error {
-    constructor(
-        public paramName: string,
-        public activity: DSLActivitySpec,
-        reason?: string,
-    ) {
-        super(`${paramName} in activity ${activity.name} is invalid${reason ? ` ${reason}` : ""}`);
-        this.name = "ActivityParamInvalid";
-    }
-}
-
 export class ActivityParamInvalidError extends ApplicationFailure {
     constructor(
         public paramName: string,
@@ -79,19 +38,6 @@ export class ActivityParamInvalidError extends ApplicationFailure {
     }
 }
 
-/**
- * @deprecated Use {@link WorkflowParamNotFoundError} instead.
- */
-export class WorkflowParamNotFound extends Error {
-    constructor(
-        public paramName: string,
-        public workflow?: DSLWorkflowSpec,
-    ) {
-        super(`Required parameter ${paramName} not found in workflow ${workflow?.name}`);
-        this.name = "WorkflowParamNotFound";
-    }
-}
-
 export class WorkflowParamNotFoundError extends ApplicationFailure {
     constructor(
         public paramName: string,
@@ -106,12 +52,8 @@ export class WorkflowParamNotFoundError extends ApplicationFailure {
 }
 
 export const WF_NON_RETRYABLE_ERRORS = [
-    "NoDocumentFound",
     "DocumentNotFoundError",
-    "ActivityParamInvalid",
     "ActivityParamInvalidError",
-    "ActivityParamNotFound",
     "ActivityParamNotFoundError",
-    "WorkflowParamNotFound",
     "WorkflowParamNotFoundError",
 ];

package/src/index.ts

@@ -33,5 +33,6 @@ export * from "./utils/client.js";
 export * from "./utils/memory.js";
 export * from "./utils/tokens.js";
 export * from "./utils/renditions.js";
+export * from "./utils/storage.js";
 
 export * from "./conversion/image.js";

package/src/utils/renditions.ts

@@ -1,10 +1,10 @@
 import { log } from "@temporalio/activity";
-import { imageResizer } from "../conversion/image.js";
-import fs from "fs";
 import { VertesiaClient } from "@vertesia/client";
 import { NodeStreamSource } from "@vertesia/client/node";
 import { ImageRenditionFormat } from "@vertesia/common";
-import path from "path";
+import fs from "fs";
+import pLimit from 'p-limit';
+import { imageResizer } from "../conversion/image.js";
 
 export interface ImageRenditionParams {
     max_hw: number; //maximum size of the longest side of the image
@@ -19,10 +19,10 @@ export interface ImageRenditionParams {
  * @returns
  */
 export function getRenditionsPath(
-    objectId: string,
+    contentEtag: string,
     params: ImageRenditionParams,
 ) {
-    const path = `renditions/${objectId}/${params.max_hw}`;
+    const path = `renditions/${contentEtag}/${params.max_hw}`;
     return path;
 }
 
@@ -30,15 +30,15 @@ export function getRenditionsPath(
  * Get a specific page path for a rendition
  */
 export function getRenditionPagePath(
-    objectId: string,
+    contentEtag: string,
     params: ImageRenditionParams,
-    pageNumber: number | string = 1,
+    pageNumber: number | string = 0,
 ) {
-    //if number, pad to 5 char
+    //if number, pad to 4 char
     if (typeof pageNumber === "number") {
-        pageNumber = String(pageNumber).padStart(5, "0");
+        pageNumber = String(pageNumber).padStart(4, "0");
     }
-    const path = getRenditionsPath(objectId, params);
+    const path = getRenditionsPath(contentEtag, params);
     const pagePath = `${path}/${pageNumber}.${params.format}`;
     return pagePath;
 }
@@ -48,21 +48,24 @@ export function getRenditionPagePath(
  */
 export async function uploadRenditionPages(
     client: VertesiaClient,
-    objectId: string,
+    contentEtag: string,
     files: string[],
     params: ImageRenditionParams,
+    concurrency?: number,
 ) {
     log.info(
-        `Uploading rendition for ${objectId} with ${files.length} pages (max_hw: ${params.max_hw}, format: ${params.format})`,
+        `Uploading rendition for etag ${contentEtag} with ${files.length} pages (max_hw: ${params.max_hw}, format: ${params.format})`,
         { files },
     );
-    const uploads = files.map(async (file, i) => {
-        const filename = path.basename(file).split(".")[0];
-        const pageId = getRenditionPagePath(objectId, params, filename);
+
+    const limit = pLimit(concurrency ?? 20);
+
+    const uploads = files.map((file, i) => limit(async () => {
+        const pageId = getRenditionPagePath(contentEtag, params, i);
         let resizedImagePath = null;
 
         try {
-            log.info(`Resizing image for ${objectId} page ${i}`, {
+            log.info(`Resizing image for ${contentEtag} page ${i}`, {
                 file,
                 params,
             });
@@ -85,7 +88,7 @@ export async function uploadRenditionPages(
             );
 
             log.info(
-                `Uploading rendition for ${objectId} page ${i} with max_hw: ${params.max_hw} and format: ${params.format}`,
+                `Uploading rendition for ${contentEtag} page ${i} with max_hw: ${params.max_hw} and format: ${params.format}`,
                 {
                     resizedImagePath,
                     fileId,
@@ -98,7 +101,7 @@ export async function uploadRenditionPages(
                 .uploadFile(source)
                 .catch((err) => {
                     log.error(
-                        `Failed to upload rendition for ${objectId} page ${i}`,
+                        `Failed to upload rendition for ${contentEtag} page ${i}`,
                         {
                             error: err,
                             errorMessage: err.message,
@@ -107,18 +110,18 @@ export async function uploadRenditionPages(
                     );
                     return Promise.reject(`Upload failed: ${err.message}`);
                 });
-            log.info(`Rendition uploaded for ${objectId} page ${i}`, {
+            log.info(`Rendition uploaded for ${contentEtag} page ${i}`, {
                 result,
             });
 
             return result;
         } catch (err: any) {
-            log.error(`Failed to upload rendition for ${objectId} page ${i}`, {
+            log.error(`Failed to upload rendition for ${contentEtag} page ${i}`, {
                 error: err,
             });
             return Promise.reject(`Upload failed: ${err.message}`);
         }
-    });
+    }));
 
     return Promise.all(uploads);
 }

package/src/utils/storage.ts

@@ -0,0 +1,61 @@
+import { activityInfo, log } from "@temporalio/activity";
+import { ApplicationFailure } from "@temporalio/workflow";
+import { VertesiaClient } from "@vertesia/client";
+import { NodeStreamSource } from "@vertesia/client/node";
+import { basename } from "path";
+import { Readable } from "stream";
+import mime from "mime";
+import { fetchBlobAsBuffer } from "../utils/blobs.js";
+
+
+export const agentStoragePath = (runId: string) => `agents/${runId}`;
+
+/**
+ *
+ * Save an artifact generated by an agent to cloud storage
+ *
+ * @param client
+ * @param name
+ * @param fileContent
+ * @param mimeType
+ * @returns
+ */
+export async function saveAgentArtifact(
+    client: VertesiaClient,
+    name: string,
+    fileContent: Readable,
+    mimeType: string = "application/json",
+) {
+    const { runId } = activityInfo().workflowExecution;
+    const ext = mime.getExtension(mimeType);
+    if (!name) {
+        throw ApplicationFailure.nonRetryable(`Name is required`);
+    }
+
+    //create the file path and append extension if needed
+    const filePath = agentStoragePath(runId) + "/" + name + (ext && !name.endsWith(ext) ? "." + ext : "");
+    log.info(`Storing agent artifact ${filePath} for run ${runId}`);
+
+    try {
+        const source = new NodeStreamSource(fileContent, `${runId}-${basename(filePath)}`, mimeType, filePath);
+        return await client.files.uploadFile(source);
+    } catch (err: any) {
+        log.error(`Failed to save agent artifact for run ${runId}`, {
+            err,
+            file: filePath,
+        });
+        throw ApplicationFailure.nonRetryable(
+            `Failed to save agent artifact for run ${runId}`,
+            "SaveAgentArtifactError",
+            {
+                error: err,
+            },
+        );
+    }
+}
+
+export async function fetchAgentArtifact(client: VertesiaClient, name: string) {
+    const { runId } = activityInfo().workflowExecution;
+    const filePath = agentStoragePath(runId) + "/" + name;
+    return fetchBlobAsBuffer(client, filePath);
+}