@vertesia/workflow 0.42.2

package/package.json

@@ -0,0 +1,109 @@
+{
+  "name": "@vertesia/workflow",
+  "version": "0.42.2",
+  "type": "module",
+  "description": "Composable prompts workflow dsl",
+  "main": "./lib/esm/index.js",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "bin": {
+    "bundle-workflows": "./bin/bundle-workflows.mjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vertesia/composableai.git",
+    "directory": "zeno/workflow"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@temporalio/testing": "^1.11.5",
+    "@temporalio/worker": "^1.11.5",
+    "@types/jsonwebtoken": "^9.0.7",
+    "@types/node": "^22.5.1",
+    "@types/papaparse": "^5.3.15",
+    "@types/tmp": "^0.2.6",
+    "ts-dual-module": "^0.6.3",
+    "vitest": "^2.1.6",
+    "@smithy/types": "^3.7.2"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.693.0",
+    "@aws-sdk/client-textract": "^3.693.0",
+    "@aws-sdk/credential-providers": "^3.693.0",
+    "@becomposable/memory": "^0.43.0",
+    "@opendocsg/pdf2md": "0.2.0",
+    "@temporalio/activity": "^1.11.5",
+    "@temporalio/workflow": "^1.11.5",
+    "@tensorflow/tfjs-node": "^4.19.0",
+    "@types/json-schema": "^7.0.15",
+    "api-fetch-client": "^0.13.0",
+    "fast-deep-equal": "^3.1.3",
+    "jsonwebtoken": "^9.0.2",
+    "ms": "3.0.0-canary.1",
+    "node-web-stream-adapters": "^0.2.1",
+    "papaparse": "^5.4.1",
+    "seedrandom": "^3.0.5",
+    "sharp": "^0.33.4",
+    "tiktoken": "^1.0.15",
+    "tmp": "^0.2.3",
+    "yaml": "^2.6.0",
+    "@vertesia/common": "0.42.2",
+    "@llumiverse/core": "0.15.0",
+    "@vertesia/client": "0.42.2"
+  },
+  "ts_dual_module": {
+    "outDir": "lib",
+    "exports": {
+      "activities": "./activities",
+      "workflows": "./workflows",
+      "workflows-bundle": "./workflows-bundle.js",
+      "vars": "./vars"
+    }
+  },
+  "exports": {
+    ".": {
+      "types": "./lib/types/index.d.ts",
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js"
+    },
+    "./vars": {
+      "types": "./lib/types/vars.d.ts",
+      "import": "./lib/esm/vars.js",
+      "require": "./lib/cjs/vars.js"
+    },
+    "./activities": {
+      "types": "./lib/types/activities/index.d.ts",
+      "import": "./lib/esm/activities/index.js",
+      "require": "./lib/cjs/activities/index.js"
+    },
+    "./workflows": {
+      "types": "./lib/types/workflows.d.ts",
+      "import": "./lib/esm/workflows.js",
+      "require": "./lib/cjs/workflows.js"
+    },
+    "./workflows-bundle": {
+      "import": "./lib/workflows-bundle.js"
+    }
+  },
+  "types": "./lib/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "activities": [
+        "./lib/types/activities/index.d.ts"
+      ],
+      "workflows": [
+        "./lib/types/workflows.d.ts"
+      ],
+      "vars": [
+        "./lib/types/dsl/vars.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "test": "vitest run",
+    "build": "pnpm exec tsmod build && node ./bin/bundle-workflows.mjs lib/esm/workflows.js lib/workflows-bundle.js",
+    "clean": "rm -rf ./lib tsconfig.tsbuildinfo"
+  }
+}

package/src/activities/advanced/createDocumentTypeFromInteractionRun.ts

@@ -0,0 +1,54 @@
+import { CreateContentObjectTypePayload, DSLActivityExecutionPayload, DSLActivitySpec, ExecutionRun } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+import { projectResult } from "../../dsl/projections.js";
+import { setupActivity } from "../../dsl/setup/ActivityContext.js";
+import { ActivityParamNotFound } from "../../errors.js";
+
+
+export interface CreateDocumentTypeFromInteractionRunParams {
+    /**
+     * The execution run object to use. Required.
+     * Not required in params since it is usually fetched
+     */
+    run: ExecutionRun,
+    /**
+     * If defined then update the object type with the created type
+     */
+    updateObjectId?: string;
+}
+
+export interface CreateDocumentTypeFromInteractionRun extends DSLActivitySpec<CreateDocumentTypeFromInteractionRunParams> {
+    name: 'createDocumentTypeFromInteractionRun';
+}
+
+export async function createDocumentTypeFromInteractionRun(payload: DSLActivityExecutionPayload) {
+    const { params, client } = await setupActivity<CreateDocumentTypeFromInteractionRunParams>(payload);
+
+    if (!params.run) {
+        throw new ActivityParamNotFound("run", payload.activity);
+    }
+
+    const genTypeRes = params.run.result;
+
+    if (!genTypeRes.document_type) {
+        log.error("No name generated for type: " + JSON.stringify(genTypeRes), genTypeRes);
+        throw new Error("No name generated for type");
+    }
+
+    log.info("Generated schema for type", genTypeRes.metadata_schema);
+    const typeData: CreateContentObjectTypePayload = {
+        name: genTypeRes.document_type,
+        object_schema: genTypeRes.metadata_schema,
+        is_chunkable: !!genTypeRes.is_chunkable,
+    }
+
+    const type = await client.types.create(typeData);
+
+    if (params.updateObjectId) {
+        await client.objects.update(params.updateObjectId, {
+            type: type.id,
+        });
+    }
+
+    return projectResult(payload, params, type, { id: type.id, name: type.name });
+}

package/src/activities/advanced/createOrUpdateDocumentFromInteractionRun.ts

@@ -0,0 +1,97 @@
+import { ContentObjectStatus, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+import { setupActivity } from "../../dsl/setup/ActivityContext.js";
+import { ActivityParamNotFound, NoDocumentFound } from "../../errors.js";
+interface CreateOrUpdateObjectFromInteractionRunParams {
+    /**
+     * The execution run object to use. Required.
+     * Not required in params since it is usually fetched
+     */
+    run_id?: string,
+    /**
+     * The document type to use. Required if update_existing_id is false.
+     * Not required in params since it is usually fetched
+     */
+    object_type?: string,
+
+    /**
+     * The id of the document to update. If not provided, a new document will be created
+     */
+    update_existing_id?: string,
+
+    fallback_name?: string, // a name to use if no one was generated by the interaction
+
+    parent?: string, // the parent object id
+}
+
+export interface CreateOrUpdateObjectFromInteractionRun extends DSLActivitySpec<CreateOrUpdateObjectFromInteractionRunParams> {
+    name: 'createOrUpdateDocumentFromInteractionRun';
+}
+
+export async function createOrUpdateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload) {
+    const { params, client } = await setupActivity<CreateOrUpdateObjectFromInteractionRunParams>(payload);
+
+    const runId = params.run_id;
+    const objectTypeName = params.object_type;
+
+    if (!runId) {
+        throw new ActivityParamNotFound("run_id", payload.activity);
+    }
+    if (!objectTypeName && !params.update_existing_id) {
+        throw new ActivityParamNotFound("object_type", payload.activity);
+    }
+
+    log.info("Creating document from interaction result", { runId, objectTypeName });
+
+    const run = await client.runs.retrieve(runId).catch((e) => {
+        throw new NoDocumentFound(`Error fetching run ${runId}: ${e.message}`);
+    });
+
+    const type = objectTypeName ?
+        await client.types.getTypeByName(objectTypeName).catch((e) => {
+            throw new NoDocumentFound(`Error fetching type ${objectTypeName}: ${e.message}`);
+        })
+        : undefined;
+
+
+    const result = run.result;
+    const resultIsObject = typeof result === 'object';
+    const inputData = run.parameters;
+
+    let name: string;
+    if (resultIsObject) {
+        name = result['name'] || result["title"] || inputData['name'] || params.fallback_name || 'Untitled';
+    } else {
+        name = inputData['name'] || params.fallback_name || 'Untitled';
+    }
+
+    const docPayload = {
+        name,
+        parent: params.parent ?? undefined,
+        properties: resultIsObject ? result : {},
+        text: !resultIsObject ? result : undefined,
+        type: type?.id,
+        status: ContentObjectStatus.completed,
+        generation_run_info: {
+            id: run.id,
+            date: new Date().toISOString(),
+            model: run.modelId,
+            target: resultIsObject ? 'properties' : 'text'
+        }
+    };
+
+    //create or update the document
+    let newDoc: boolean = false;
+    let doc = undefined;
+    if (params.update_existing_id) {
+        log.info(`Updating existing document ${params.update_existing_id}`);
+        doc = await client.objects.update(params.update_existing_id, docPayload);
+    } else {
+        log.info(`Creating new document of type ${objectTypeName}`);
+        doc = await client.objects.create(docPayload);
+        newDoc = true;
+    }
+
+    log.info(`Document ${objectTypeName + ' '}${doc.id}(${doc.name}) ${newDoc ? 'created' : 'updated'}`);
+    return { id: doc.id, isNew: newDoc, type: name }
+}

package/src/activities/advanced/updateDocumentFromInteractionRun.ts

@@ -0,0 +1,34 @@
+import { DSLActivityExecutionPayload, DSLActivitySpec, ExecutionRun } from "@vertesia/common";
+import { setupActivity } from "../../dsl/setup/ActivityContext.js";
+import { ActivityParamNotFound } from "../../errors.js";
+
+
+export interface UpdateDocumentFromInteractionRunParams {
+    /**
+     * The execution run object to use. Required.
+     * Not required in params since it is usually fetched
+     */
+    run?: ExecutionRun,
+}
+
+export interface UpdateDocumentFromInteractionRun extends DSLActivitySpec<UpdateDocumentFromInteractionRunParams> {
+    name: 'updateDocumentFromInteractionRun';
+}
+
+export async function updateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload) {
+    const { params, client, objectId } = await setupActivity<UpdateDocumentFromInteractionRunParams>(payload);
+
+    if (!params.run) {
+        throw new ActivityParamNotFound("run", payload.activity);
+    }
+
+    const docProps = params.run.result;
+
+    if (!docProps) {
+        return { status: "failed", error: "no-props" };
+    }
+
+    await client.objects.update(objectId, docProps);
+
+    return { status: "success" };
+}

package/src/activities/chunkDocument.ts

@@ -0,0 +1,124 @@
+import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { InteractionExecutionParams, executeInteractionFromActivity } from "./executeInteraction.js";
+
+const INT_CHUNK_DOCUMENT = "sys:ChunkDocument"
+
+interface DocPart {
+
+    line_number_start: number
+    line_number_end: number
+    name: string
+    type: string
+
+}
+
+export interface ChunkDocumentResult {
+    id: string
+    status: "completed" | "failed" | "skipped"
+    parts?: string[]
+    message?: string
+}
+
+export interface ChunkDocumentParams extends InteractionExecutionParams {
+    force?: boolean;
+    interactionName?: string;
+    docPartType?: string;
+}
+
+export interface ChunkDocument extends DSLActivitySpec<ChunkDocumentParams> {
+    name: 'chunkDocument';
+}
+
+
+export async function chunkDocument(payload: DSLActivityExecutionPayload): Promise<ChunkDocumentResult> {
+    const { params, client, objectId } = await setupActivity<ChunkDocumentParams>(payload);
+
+    const { force } = params;
+    const interactionName = params.interactionName ?? INT_CHUNK_DOCUMENT;
+
+    log.info(`Object ${objectId} chunking started`);
+
+    const document = await client.objects.retrieve(objectId, "+text");
+
+    const type = document.type ? await client.types.retrieve(document.type.id) : undefined;
+
+    if (!type?.is_chunkable) {
+        log.warn('Type is not chunkable for object ID: ' + objectId);
+        return { id: objectId, status: "skipped", message: "type not chunkable" }
+    }
+
+    //check if text is present
+    if (!document.text) {
+        log.warn('No text found for object ID: ' + objectId);
+        return { id: objectId, status: "failed", message: "no text found" }
+    }
+
+    if (!force && document.parts && document.parts.length > 0 && document.parts_etag === document.text_etag) {
+        log.info('Document already chunked for object ID: ' + objectId);
+        return { id: objectId, status: "skipped", message: "document already chunked with correct etag" }
+    }
+
+    //instrument the text with line numbers
+    const lines = document.text.split('\n')
+    const instrumented = lines.map((l, i) => `{%${i}%}${l}`).join('\n')
+
+    const res = await executeInteractionFromActivity(client, interactionName, params, {
+        objectId: objectId,
+        content: instrumented
+    });
+
+    const parts = res.result.parts as DocPart[];
+    if (!parts || parts.length === 0) {
+        log.warn('No parts found for object ID: ' + objectId, res);
+        return { id: objectId, status: "failed", parts: [], message: "no parts found" }
+    }
+
+    const partDocs = await Promise.all(parts.map(async (part, i) => {
+
+        const text = lines.filter((_l, i) => i >= part.line_number_start && i <= part.line_number_end).join('\n');
+
+        const location = () => {
+            let location = document.location;
+            if (location.endsWith('/')) {
+                location += document.name + "/" + part.type
+            }
+            location += '/' + document.name + "/" + part.type;
+            return location;
+        }
+
+        const docPart = await client.objects.create({
+            name: part.name,
+            parent: objectId,
+            text: text,
+            location: location(),
+            properties: {
+                part_number: i + 1,
+                etag: document.text_etag,
+                source_line_start: part.line_number_start,
+                source_line_end: part.line_number_end,
+                title: part.name
+            }
+        });
+        return docPart;
+    }));
+
+    //delete previous parts
+    if (document.parts && document.parts.length > 0) {
+        log.info('Deleting previous parts for object ID: ' + objectId, { parts: document.parts });
+        await Promise.all(document.parts.map(async (partId) => {
+            await client.objects.delete(partId);
+        }));
+    }
+
+    await client.objects.update(objectId, {
+        parts: partDocs.map(p => p.id),
+        parts_etag: document.text_etag
+    });
+
+    log.info(`Object ${objectId} chunking completed`, { parts: document.parts });
+
+    return { id: objectId, status: "completed", parts: document.parts }
+
+}

package/src/activities/createDocumentFromOther.ts

@@ -0,0 +1,92 @@
+import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { log } from "@temporalio/activity";
+import fs from 'fs';
+import { pdfExtractPages } from "../conversion/mutool.js";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { NoDocumentFound } from "../errors.js";
+import { saveBlobToTempFile } from "../utils/blobs.js";
+import { NodeStreamSource } from "../utils/memory.js";
+
+interface CreatePdfDocumentFromSourceParams {
+
+    target_object_type: string; //type of the object to create
+    title: string; //title of the object to create
+    filename?: string; //filename of the object to create
+    pages: number[]; //pages to extract into the new document
+    parent?: string; //set the new document as child of the source document
+
+}
+
+
+export interface CreatePdfDocumentFromSource extends DSLActivitySpec<CreatePdfDocumentFromSourceParams> {
+    name: 'createPdfDocumentFromSource';
+}
+
+
+/**
+ * Create a new PDF by extrracting pages from a source PDF
+ * @returns
+ */
+export async function createPdfDocumentFromSource(payload: DSLActivityExecutionPayload) {
+    const { client, objectId, params } = await setupActivity<CreatePdfDocumentFromSourceParams>(payload);
+    const inputObject = await client.objects.retrieve(objectId);
+
+    const { pages, filename, title } = params;
+    log.info(`Creating PDF from source`, { objectId, pages, filename, title });
+
+    if (!pages || pages.length === 0) {
+        log.error(`No pages provided`);
+        throw new Error(`No pages provided`);
+    }
+
+    if (!inputObject) {
+        log.error(`Document ${objectId} not found`);
+        throw new NoDocumentFound(`Document ${objectId} 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('application/pdf'))) {
+        log.error(`Document ${objectId} is not an image`);
+        throw new NoDocumentFound(`Document ${objectId} is not an image or pdf: ${inputObject.content.type}`, [objectId]);
+    }
+
+    const targetType = await client.types.getTypeByName(params.target_object_type);
+    if (!targetType) {
+        log.error(`Type ${params.target_object_type} not found`);
+        throw new NoDocumentFound(`Type ${params.target_object_type} not found`);
+    }
+
+    const tmpFile = await saveBlobToTempFile(client, inputObject.content.source, ".pdf");
+    const newPdf = await pdfExtractPages(tmpFile, pages);
+    log.info(`PDF created from pages ${pages.join(', ')} `, { newPdf });
+    const name = `pages-${pages.join('-')}.pdf`;
+
+    const sourceToUpload = new NodeStreamSource(
+        fs.createReadStream(newPdf),
+        name,
+        "application/pdf"
+    )
+
+    log.info(`Uploading file ${newPdf} `);
+    const upload = await client.objects.upload(sourceToUpload);
+    log.info(`File uploaded ${upload.source} `);
+
+    const newObject = await client.objects.create({
+        type: targetType.id,
+        name: title || targetType.name,
+        parent: objectId,
+        content: {
+            source: upload.source,
+            name: upload.name,
+            type: 'application/pdf'
+        }
+    });
+
+    return { newObjectId: newObject.id, uploadedFile: upload.name };
+
+
+}