@vertesia/workflow 0.42.2

package/src/activities/generateEmbeddings.ts

@@ -0,0 +1,345 @@
+import { ComposableClient } from "@vertesia/client";
+import { ContentObject, DSLActivityExecutionPayload, DSLActivitySpec, ProjectConfigurationEmbeddings, SupportedEmbeddingTypes } from "@vertesia/common";
+import { EmbeddingsResult } from "@llumiverse/core";
+import { log } from "@temporalio/activity";
+import * as tf from '@tensorflow/tfjs-node';
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { NoDocumentFound } from '../errors.js';
+import { fetchBlobAsBase64, md5 } from "../utils/blobs.js";
+import { countTokens } from "../utils/tokens.js";
+
+
+export interface GenerateEmbeddingsParams {
+    model?: string;
+    environment?: string;
+    force?: boolean;
+    type: SupportedEmbeddingTypes;
+}
+
+export interface GenerateEmbeddings extends DSLActivitySpec<GenerateEmbeddingsParams> {
+    name: 'generateEmbeddings';
+}
+
+export async function generateEmbeddings(payload: DSLActivityExecutionPayload) {
+    const { params, client, objectId, fetchProject } = await setupActivity<GenerateEmbeddingsParams>(payload);
+    const { force, type } = params;
+
+    const projectData = await fetchProject();
+    const config = projectData?.configuration.embeddings[type];
+    if (!projectData) {
+        throw new NoDocumentFound('Project not found', [payload.project_id]);
+    }
+    if (!config) {
+        throw new NoDocumentFound('Embeddings configuration not found', [objectId])
+    }
+
+    if (!projectData) {
+        throw new NoDocumentFound('Project not found', [payload.project_id]);
+    }
+
+    if (!projectData?.configuration.embeddings[type]?.enabled) {
+        log.info(`Embeddings generation disabled for type ${type} on project: ${projectData.name} (${projectData.namespace})`, { config });
+        return { id: objectId, status: "skipped", message: `Embeddings generation disabled for type ${type}` }
+    }
+
+    log.info(`${type} embedding generation starting for object ${objectId}`, { force, config });
+
+    if (!config.environment) {
+        throw new Error('No environment found in project configuration. Set environment in project configuration to generate embeddings.');
+    }
+
+    const document = await client.objects.retrieve(objectId, "+text +parts +embeddings +tokens +properties");
+
+    if (!document) {
+        throw new NoDocumentFound('Document not found', [objectId]);
+    }
+
+    if (!document.content) {
+        throw new NoDocumentFound('Document content not found', [objectId]);
+    }
+
+    let res;
+
+    switch (type) {
+        case SupportedEmbeddingTypes.text:
+            res = await generateTextEmbeddings({
+                client,
+                config,
+                document,
+                type
+            })
+            break;
+        case SupportedEmbeddingTypes.properties:
+            res = await generateTextEmbeddings({
+                client,
+                config,
+                document,
+                type,
+            });
+            break;
+        case SupportedEmbeddingTypes.image:
+            res = await generateImageEmbeddings({
+                client,
+                config,
+                document,
+                type
+            });
+            break;
+        default:
+            res = { id: objectId, status: "failed", message: `unsupported embedding type: ${type}` }
+    }
+
+    return res;
+
+}
+
+
+interface ExecuteGenerateEmbeddingsParams {
+    document: ContentObject;
+    client: ComposableClient;
+    type: SupportedEmbeddingTypes;
+    config: ProjectConfigurationEmbeddings;
+    property?: string;
+    force?: boolean;
+}
+
+async function generateTextEmbeddings({ document, client, type, config }: ExecuteGenerateEmbeddingsParams) {
+    // if (!force && document.embeddings[type]?.etag === (document.text_etag ?? md5(document.text))) {
+    //     return { id: objectId, status: "skipped", message: "embeddings already generated" }
+    // }
+
+    if (!document) {
+        return { status: "error", message: "document is null or undefined" }
+    }
+
+    if (type !== SupportedEmbeddingTypes.text && type !== SupportedEmbeddingTypes.properties) {
+        return { id: document.id, status: "failed", message: `unsupported embedding type: ${type}` }
+    }
+
+    if (type === SupportedEmbeddingTypes.text && !document.text) {
+        return { id: document.id, status: "failed", message: "no text found" }
+    }
+    if (type === SupportedEmbeddingTypes.properties && !document?.properties) {
+        return { id: document.id, status: "failed", message: "no properties found" }
+    }
+
+    const { environment, model } = config;
+
+    // Count tokens if not already done
+    if (!document.tokens?.count && type === SupportedEmbeddingTypes.text) {
+        log.debug('Updating token count for document: ' + document.id);
+        const tokensData = countTokens(document.text!);
+        await client.objects.update(document.id, {
+            tokens: {
+                ...tokensData,
+                etag: document.text_etag ?? md5(document.text!)
+            }
+        });
+        document.tokens = {
+            ...tokensData,
+            etag: document.text_etag ?? md5(document.text!)
+        };
+    }
+
+    const maxTokens = config.max_tokens ?? 8000;
+
+    //generate embeddings for the main doc if document isn't too large
+    //if too large, we'll just generate embeddings for the parts
+    //then we can generate embeddings for the main document by averaging the tensors
+    log.info(`Generating ${type} embeddings for document ${document.id}`);
+    if (type === SupportedEmbeddingTypes.text && document.tokens?.count && document.tokens?.count > maxTokens) {
+        log.info('Document too large, generating embeddings for parts');
+
+        if (!document.parts || document.parts.length === 0) {
+            return { id: document.id, status: "skipped", message: "no parts found" }
+        }
+
+        const docParts = await Promise.all(document.parts?.map(async (partId) => client.objects.retrieve(partId, "+text +embeddings +properties +tokens")));
+        log.info(`Retrieved ${docParts.length} parts`)
+
+        const generatePartEmbeddings = async (part: ContentObject<any>, i: number) => {
+            try {
+                log.info(`Generating embeddings for part ${part.id}`, { text_len: part.text?.length })
+                if (!part.text) {
+                    return { id: part.id, number: i, result: null, status: "skipped", message: "no text found" }
+                }
+
+                if (part.tokens?.count && part.tokens.count > maxTokens) {
+                    log.info('Part too large, skipping embeddings generation for part', { part: part.id, tokens: part.tokens.count });
+                    return { id: part.id, number: i, result: null, message: "part too large" }
+                }
+
+                const e = await generateEmbeddingsFromStudio(part.text, environment, client, model).catch(e => {
+                    log.error('Error generating embeddings for part', { part: part.id, tokens: part.tokens, text_length: part.text?.length, error: e });
+                    return null;
+                });
+
+                if (!e || !e.values) {
+                    return { id: part.id, number: i, result: null, message: "no embeddings generated" }
+                }
+
+                log.info(`Embeddings generated for part ${part.id}, updating object in the store.`)
+                await client.objects.setEmbedding(part.id, SupportedEmbeddingTypes.text,
+                    {
+                        values: e.values,
+                        model: e.model,
+                        etag: part.text_etag
+                    }).catch(err => {
+                        log.info(`Error updating embeddings on part ${part.id}`);
+                        return { id: part.id, number: i, result: null, message: "error setting embeddings on part", error: err.message }
+                    })
+
+                log.info('Generated embeddings for part: ' + part.id);
+                return { id: part.id, number: i, result: e }
+            } catch (err: any) {
+                log.info(`Error generating ${type} embeddings for part ${part.id} of ${document.id}`, { error: err });
+                return { id: part.id, number: i, result: null, message: "error generating embeddings", error: err.message }
+            }
+        }
+
+        const promises = docParts.map((p, i) => generatePartEmbeddings(p, i))
+        const res = await Promise.all(promises);
+        // let i = 0;
+        // for (const p of docParts) {
+        //     log.info(`Processing part ${p.id}`)
+        //     const r = await generatePartEmbeddings(p, i++);
+        //     res.push(r)
+        // }
+
+
+        // Filter out parts without embeddings
+        const validEmbeddings = res.filter(item => item.result !== null) as { id: string, number: number, result: EmbeddingsResult }[];
+
+        // Compute the document-level embedding using TensorFlow for attention mechanism
+        log.info('Computing document-level embedding using TF');
+        const documentEmbedding = computeAttentionEmbedding(validEmbeddings.map(item => item.result.values));
+
+        // Save the document-level embedding
+        await client.objects.setEmbedding(document.id, type,
+            {
+                values: documentEmbedding,
+                model: "attention",
+                etag: document.text_etag
+            }
+        );
+        return { id: document.id, status: "completed", parts: docParts.map(i => i.id), len: documentEmbedding.length, part_embeddings: res.map(r => { return { id: r.id, status: r.status, error: r.error, message: r.message } }) }
+
+    } else {
+        log.info(`Generating ${type} embeddings for document`);
+
+        const res = await generateEmbeddingsFromStudio(JSON.stringify(document[type]), environment, client);
+        if (!res || !res.values) {
+            return { id: document.id, status: "failed", message: "no embeddings generated" }
+        }
+
+        log.info(`${type} embeddings generated for document ${document.id}`, { len: res.values.length });
+        await client.objects.setEmbedding(document.id, type,
+            {
+                values: res.values,
+                model: res.model,
+                etag: document.text_etag
+            }
+        );
+
+        return { id: document.id, type, status: "completed", len: res.values.length }
+
+    }
+
+}
+
+async function generateImageEmbeddings({ document, client, type, config }: ExecuteGenerateEmbeddingsParams) {
+
+    log.info('Generating image embeddings for document ' + document.id, { content: document.content });
+    if (!document.content?.type?.startsWith('image/') && !document.content?.type?.includes('pdf')) {
+        return { id: document.id, type, status: "failed", message: "content is not an image" }
+    }
+    const { environment, model } = config
+
+    const resRnd = await client.store.objects.getRendition(document.id, {
+        format: "image/png",
+        max_hw: 1024,
+        generate_if_missing: true
+    });
+
+    if (resRnd.status === 'generating') {
+        throw new Error("Rendition is generating, will retry later")
+    } else if (resRnd.status === "failed" || !resRnd.rendition) {
+        throw new NoDocumentFound("Rendition retrieval failed", [document.id])
+    }
+
+    if (!resRnd.rendition.content.source) {
+        throw new NoDocumentFound("No source found in rendition", [document.id])
+    }
+
+    const image = await fetchBlobAsBase64(client, resRnd.rendition.content.source);
+
+    const res = await client.environments.embeddings(environment, {
+        image,
+        model
+    }).then(res => res).catch(e => {
+        log.error('Error generating embeddings for image', { error: e })
+        throw e;
+    });
+
+    if (!res || !res.values) {
+        return { id: document.id, status: "failed", message: "no embeddings generated" }
+    }
+
+    await client.objects.setEmbedding(document.id, SupportedEmbeddingTypes.image,
+        {
+            values: res.values,
+            model: res.model,
+            etag: document.text_etag
+        }
+    );
+
+    return { id: document.id, type, status: "completed", len: res.values.length }
+
+}
+
+async function generateEmbeddingsFromStudio(text: string, env: string, client: ComposableClient, model?: string): Promise<EmbeddingsResult> {
+
+    log.info(`Generating embeddings for text of ${text.length} chars with environment ${env}`);
+
+    return client.environments.embeddings(env, {
+        text,
+        model
+    }).then(res => res).catch(e => {
+        log.error('Error generating embeddings for text', { error: e })
+        throw e;
+    });
+
+}
+
+function computeAttentionEmbedding(embeddingsArray: number[][], axis: number = 0) {
+    if (embeddingsArray.length === 0) return [];
+    log.info('Computing attention embedding for', { embeddingsArrays: embeddingsArray.map(a => a.length) });
+    const start = new Date().getTime();
+
+    // Convert embeddings array to TensorFlow tensor
+    const embeddingsTensor = tf.tensor(embeddingsArray);
+
+    // Initialize trainable attention weights
+    const attentionWeights = tf.variable(tf.randomNormal([embeddingsArray.length]), true);
+
+    // Compute attention scoresje sui
+    const attentionScores = tf.softmax(attentionWeights);
+
+    // Compute weighted sum of embeddings
+    const weightedEmbeddings = tf.mul(embeddingsTensor.transpose(), attentionScores).transpose();
+    const documentEmbeddingTensor = tf.sum(weightedEmbeddings, axis);
+
+    // Convert the result back to a JavaScript array
+    const documentEmbedding = documentEmbeddingTensor.arraySync() as number[];
+    const duration = (new Date().getTime() - start);
+    log.info(`Computed attention embeddings in ${duration}ms - array size: ${documentEmbedding.length}`, { length: documentEmbedding.length });
+
+    // Clean up tensors
+    embeddingsTensor.dispose();
+    attentionWeights.dispose();
+    attentionScores.dispose();
+    weightedEmbeddings.dispose();
+    documentEmbeddingTensor.dispose();
+
+    return documentEmbedding;
+}

package/src/activities/generateImageRendition.ts

@@ -0,0 +1,134 @@
+import { DSLActivityExecutionPayload, DSLActivitySpec, RenditionProperties } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+import fs from 'fs';
+import sharp, { FormatEnum } from "sharp";
+import { imageResizer } from "../conversion/image.js";
+import { pdfToImages } from "../conversion/mutool.js";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { NoDocumentFound, WorkflowParamNotFound } from "../errors.js";
+import { fetchBlobAsBuffer, saveBlobToTempFile } from "../utils/blobs.js";
+import { NodeStreamSource } from "../utils/memory.js";
+interface GenerateImageRenditionParams {
+    max_hw: number; //maximum size of the longuest side of the image
+    format: keyof FormatEnum; //format of the output image
+    multi_page?: boolean; //if true, generate a multi-page rendition
+}
+
+
+export interface GenerateImageRendition extends DSLActivitySpec<GenerateImageRenditionParams> {
+
+    name: 'generateImageRendition';
+
+}
+
+
+export async function generateImageRendition(payload: DSLActivityExecutionPayload) {
+    const { client, objectId, params } = await setupActivity<GenerateImageRenditionParams>(payload);
+
+    const supportedNonImageInputTypes = ['application/pdf']
+    const inputObject = await client.objects.retrieve(objectId).catch((err) => {
+        log.error(`Failed to retrieve document ${objectId}`, err);
+        if (err.response?.status === 404) {
+            throw new NoDocumentFound(`Document ${objectId} not found`, [objectId]);
+        }
+        throw err;
+    });
+    const renditionType = await client.types.getTypeByName('Rendition');
+
+    if (!params.format) {
+        log.error(`Format not found`);
+        throw new WorkflowParamNotFound(`format`);
+    }
+
+    if (!renditionType) {
+        log.error(`Rendition type not found`);
+        throw new NoDocumentFound(`Rendition type not found`, [objectId]);
+    }
+
+    if (!inputObject.content?.source) {
+        log.error(`Document ${objectId} has no source`);
+        throw new NoDocumentFound(`Document ${objectId} has no source`, [objectId]);
+    }
+
+    if (!inputObject.content.type || (!inputObject.content.type?.startsWith('image/') && !supportedNonImageInputTypes.includes(inputObject.content.type))) {
+        log.error(`Document ${objectId} is not an image`);
+        throw new NoDocumentFound(`Document ${objectId} is not an image or pdf: ${inputObject.content.type}`, [objectId]);
+    }
+
+    //array of rendition files to upload
+    let renditionPages: string[] = [];
+
+    //if PDF, convert to pages
+    if (inputObject.content.type === 'application/pdf') {
+        const pdfBuffer = await fetchBlobAsBuffer(client, inputObject.content.source);
+        const pages = await pdfToImages(pdfBuffer);
+        if (!pages.length) {
+            log.error(`Failed to convert pdf to image`);
+            throw new Error(`Failed to convert pdf to image`);
+        }
+        renditionPages = [...pages];
+    } else if (inputObject.content.type.startsWith('image/')) {
+        const tmpFile = await saveBlobToTempFile(client, inputObject.content.source);
+        const filestats = fs.statSync(tmpFile);
+        log.info(`Image ${objectId} copied to ${tmpFile}`, { filestats });
+        renditionPages.push(tmpFile);
+    }
+
+    //generate rendition name, pass an index for multi parts
+    const getRenditionName = (index: number = 0) => {
+        const name = `renditions/${objectId}/${params.max_hw}/${index}.${params.format}`;
+        return name;
+    }
+
+    if (!renditionPages || !renditionPages.length) {
+        log.error(`Failed to generate rendition for ${objectId}`);
+        throw new Error(`Failed to generate rendition for ${objectId}`);
+    }
+
+    log.info(`Uploading rendition for ${objectId} with ${renditionPages.length} pages (max_hw: ${params.max_hw}, format: ${params.format})`, { renditionPages });
+    const uploads = renditionPages.map(async (page, i) => {
+        const pageId = getRenditionName(i);
+        const resized = sharp(page).pipe(imageResizer(params.max_hw, params.format));
+
+        const source = new NodeStreamSource(
+            resized,
+            pageId.replace('renditions/', '').replace('/', '_'),
+            'image/' + params.format,
+            pageId,
+        )
+
+        log.info(`Uploading rendition for ${objectId} page ${i} with max_hw: ${params.max_hw} and format: ${params.format}`);
+        return client.objects.upload(source).catch((err) => {
+            log.error(`Failed to upload rendition for ${objectId} page ${i}`, err);
+            return Promise.resolve(null);
+        });
+    });
+
+    const uploaded = await Promise.all(uploads);
+    if (!uploaded || !uploaded.length || !uploaded[0]) {
+        log.error(`Failed to upload rendition for ${objectId}`);
+        throw new Error(`Failed to upload rendition for ${objectId}`);
+    }
+
+
+    log.info(`Creating rendition for ${objectId} with max_hw: ${params.max_hw} and format: ${params.format}`, { uploaded });
+    const rendition = await client.objects.create({
+        name: inputObject.name + ` [Rendition ${params.max_hw}]`,
+        type: renditionType.id,
+        parent: inputObject.id,
+        content: uploaded[0],
+        properties: {
+            mime_type: 'image/' + params.format,
+            source_etag: inputObject.content.source,
+            height: params.max_hw,
+            width: params.max_hw,
+            multipart: uploaded.length > 1,
+            total_parts: uploaded.length
+        } satisfies RenditionProperties
+    });
+
+    log.info(`Rendition ${rendition.id} created for ${objectId}`, { rendition });
+
+    return { id: rendition.id, format: params.format, status: "success" };
+
+}

package/src/activities/generateOrAssignContentType.ts

@@ -0,0 +1,152 @@
+import { CreateContentObjectTypePayload, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+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;
+    }
+}
+
+export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrAssignContentTypeParams> {
+    name: 'generateOrAssignContentType';
+}
+
+export async function generateOrAssignContentType(payload: DSLActivityExecutionPayload) {
+    const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
+    const { params, client, objectId } = context;
+
+    const interactionName = params.interactionNames?.selectDocumentType ?? INT_SELECT_DOCUMENT_TYPE;
+
+
+    log.info("SelectDocumentType for object: " + objectId, { payload });
+
+    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 };
+    }
+
+    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.list();
+
+    //make a list of all existing types, and add hints if any
+    const existing_types = types.map(t => t.name).filter(n => !["DocumentPart", "Rendition"].includes(n));
+    if (params.typesHint) {
+        const newHints = params.typesHint.filter((t: string) => !existing_types.includes(t));
+        existing_types.push(...newHints);
+    }
+
+    const content = object.text ? truncByMaxTokens(object.text, params.truncate || 4000) : 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, { max_hw: 1024, format: "image/png", generate_if_missing: true });
+        if (!res.rendition && res.status === "generating") {
+            //throw to try again
+            throw new Error(`Rendition for object ${objectId} is in progress`);
+        } else if (res.rendition) {
+            return "store:" + objectId;
+        }
+    }
+
+    const fileRef = await getImage();
+
+    log.info("Execute SelectDocumentType interaction on content with \nexisting types: " + existing_types.join(","));
+
+    const res = await executeInteractionFromActivity(client, interactionName, params, {
+        existing_types, content, image: fileRef
+    });
+
+    log.info("Selected Content Type Result: " + JSON.stringify(res.result));
+
+    //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 === res.result.document_type);
+
+    if (!selectedType) {
+        log.warn("Document type not idenfified: 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: " + res.result.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, existing_types: string[], content?: string, fileRef?: string) {
+    const { client, params } = context;
+
+    const project = await context.fetchProject();
+    const interactionName = params.interactionNames?.generateMetadataModel ?? INT_GENERATE_METADATA_MODEL;
+
+    const genTypeRes = await executeInteractionFromActivity(client, interactionName, params, {
+        existing_types: existing_types,
+        content: content,
+        human_context: project?.configuration?.human_context ?? undefined,
+        image: fileRef ? fileRef : undefined
+    });
+
+
+    if (!genTypeRes.result.document_type) {
+        log.error("No name generated for type", genTypeRes);
+        throw new Error("No name generated for type");
+    }
+
+    log.info("Generated schema for type", genTypeRes.result.metadata_schema);
+    const typeData: CreateContentObjectTypePayload = {
+        name: genTypeRes.result.document_type,
+        object_schema: genTypeRes.result.metadata_schema,
+        is_chunkable: genTypeRes.result.is_chunkable,
+    }
+
+    const type = await client.types.create(typeData);
+
+    return type;
+
+}

package/src/activities/getObjectFromStore.ts

@@ -0,0 +1,31 @@
+import { ContentObject, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { projectResult } from "../dsl/projections.js";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+
+
+export interface GetObjectParams {
+    select?: string;
+}
+
+export interface GetObject extends DSLActivitySpec<GetObjectParams> {
+    name: 'getObject';
+}
+
+/**
+ * We are using a union type for the status parameter since typescript enumbs breaks the workflow code generation
+ * @param objectId
+ * @param status
+ */
+export async function getObjectFromStore(payload: DSLActivityExecutionPayload): Promise<ContentObject> {
+    const { client, params, objectId } = await setupActivity<GetObjectParams>(payload);
+
+    const obj = await client.objects.retrieve(objectId, params.select);
+
+    const projection = projectResult(payload, params, obj, obj);
+
+    return {
+        ...projection,
+        id: obj.id,
+    }
+
+}

package/src/activities/index.ts

@@ -0,0 +1,21 @@
+/**
+ * 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 "../iterative-generation/activities/index.js";