@vertesia/workflow 0.24.0-dev.202601221707

package/src/utils/renditions.ts

@@ -0,0 +1,127 @@
+import { log } from "@temporalio/activity";
+import { VertesiaClient } from "@vertesia/client";
+import { NodeStreamSource } from "@vertesia/client/node";
+import { ImageRenditionFormat } from "@vertesia/common";
+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
+    format: ImageRenditionFormat;
+}
+
+/**
+ * Get the path for all files for a rendition
+ * @param objectId
+ * @param params
+ * @param pageNumber
+ * @returns
+ */
+export function getRenditionsPath(
+    contentEtag: string,
+    params: ImageRenditionParams,
+) {
+    const path = `renditions/${contentEtag}/${params.max_hw}`;
+    return path;
+}
+
+/**
+ * Get a specific page path for a rendition
+ */
+export function getRenditionPagePath(
+    contentEtag: string,
+    params: ImageRenditionParams,
+    pageNumber: number | string = 0,
+) {
+    //if number, pad to 4 char
+    if (typeof pageNumber === "number") {
+        pageNumber = String(pageNumber).padStart(4, "0");
+    }
+    const path = getRenditionsPath(contentEtag, params);
+    const pagePath = `${path}/${pageNumber}.${params.format}`;
+    return pagePath;
+}
+
+/**
+ * Upload Rendition page to the cloud
+ */
+export async function uploadRenditionPages(
+    client: VertesiaClient,
+    contentEtag: string,
+    files: string[],
+    params: ImageRenditionParams,
+    concurrency?: number,
+) {
+    log.info(
+        `Uploading rendition for etag ${contentEtag} with ${files.length} pages (max_hw: ${params.max_hw}, format: ${params.format})`,
+        { files },
+    );
+
+    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 ${contentEtag} page ${i}`, {
+                file,
+                params,
+            });
+            // Resize the image using ImageMagick
+            resizedImagePath = await imageResizer(
+                file,
+                params.max_hw,
+                params.format,
+            );
+
+            // Create a read stream from the resized image file
+            const fileStream = fs.createReadStream(resizedImagePath);
+            const format = "image/" + params.format;
+            const fileId = pageId.split("/").pop() ?? pageId;
+            const source = new NodeStreamSource(
+                fileStream,
+                fileId,
+                format,
+                pageId,
+            );
+
+            log.info(
+                `Uploading rendition for ${contentEtag} page ${i} with max_hw: ${params.max_hw} and format: ${params.format}`,
+                {
+                    resizedImagePath,
+                    fileId,
+                    format,
+                    pageId,
+                },
+            );
+
+            const result = await client.files
+                .uploadFile(source)
+                .catch((err) => {
+                    log.error(
+                        `Failed to upload rendition for ${contentEtag} page ${i}`,
+                        {
+                            error: err,
+                            errorMessage: err.message,
+                            stack: err.stack,
+                        },
+                    );
+                    return Promise.reject(`Upload failed: ${err.message}`);
+                });
+            log.info(`Rendition uploaded for ${contentEtag} page ${i}`, {
+                result,
+            });
+
+            return result;
+        } catch (err: any) {
+            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,60 @@
+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 : "");
+
+    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);
+}

package/src/utils/tokens.ts

@@ -0,0 +1,44 @@
+
+import { TiktokenEncoding, get_encoding } from "tiktoken";
+
+
+export type TruncateSpec = number | {
+    max_tokens: number;
+    encoding?: TiktokenEncoding;
+}
+
+export function truncByMaxTokens(content: string, by: TruncateSpec) {
+    let encoding: TiktokenEncoding;
+    let maxTokens: number;
+    if (typeof by === 'number') {
+        maxTokens = by;
+        encoding = "cl100k_base";
+    } else {
+        maxTokens = by.max_tokens;
+        encoding = by.encoding || "cl100k_base";
+    }
+    const enc = get_encoding(encoding);
+    let tokens = enc.encode(content);
+    if (tokens.length > maxTokens) {
+        tokens = tokens.slice(0, maxTokens);
+        return new TextDecoder().decode(enc.decode(tokens));
+    } else {
+        return content;
+    }
+}
+
+export function countTokens(text: string, encoding: TiktokenEncoding = 'cl100k_base') {
+
+    const encoder = get_encoding(encoding);
+    if (!encoder) {
+        throw new Error(`Unknown encoding ${encoding}`);
+    }
+
+    const tokens = encoder.encode(text);
+
+    return {
+        count: tokens.length,
+        encoding: encoding,
+    };
+
+}

package/src/vars.ts

@@ -0,0 +1,3 @@
+// exported as a named export /vars
+export * from "./dsl/validation.js";
+export * from "./dsl/vars.js";

package/src/workflows.ts

@@ -0,0 +1,7 @@
+/**
+ * Export workflows to be registered on temporal workers
+ */
+export { dslWorkflow } from "./dsl/dsl-workflow.js";
+export { iterativeGenerationWorkflow } from "./iterative-generation/iterativeGenerationWorkflow.js";
+export { notifyWebhookWorkflow } from "./system/notifyWebhookWorkflow.js";
+export { recalculateEmbeddingsWorkflow } from "./system/recalculateEmbeddingsWorkflow.js";