@vertesia/workflow 0.24.0-dev.202601221707

package/package.json

@@ -0,0 +1,146 @@
+{
+  "name": "@vertesia/workflow",
+  "version": "0.24.0-dev.202601221707",
+  "type": "module",
+  "description": "Vertesia workflow DSL",
+  "main": "./lib/esm/index.js",
+  "files": [
+    "lib",
+    "src"
+  ],
+  "bin": {
+    "bundle-workflows": "./bin/bundle-workflows.mjs"
+  },
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "@smithy/types": "^3.7.2",
+    "@temporalio/proto": "^1.11.5",
+    "@temporalio/testing": "^1.11.5",
+    "@temporalio/worker": "^1.11.5",
+    "@types/jsonwebtoken": "^9.0.10",
+    "@types/node": "^22.13.5",
+    "@types/papaparse": "^5.5.1",
+    "@types/tmp": "^0.2.6",
+    "ts-dual-module": "^0.6.3",
+    "vitest": "^4.0.16"
+  },
+  "dependencies": {
+    "@aws-sdk/client-s3": "^3.948.0",
+    "@aws-sdk/client-textract": "^3.948.0",
+    "@aws-sdk/credential-providers": "^3.948.0",
+    "@temporalio/activity": "^1.11.5",
+    "@temporalio/workflow": "^1.11.5",
+    "@types/json-schema": "^7.0.15",
+    "fast-deep-equal": "^3.1.3",
+    "jsonwebtoken": "^9.0.3",
+    "mime": "^4.0.0",
+    "ms": "3.0.0-canary.1",
+    "node-web-stream-adapters": "^0.2.1",
+    "p-limit": "^6.2.0",
+    "papaparse": "^5.5.3",
+    "seedrandom": "^3.0.5",
+    "sharp": "^0.33.4",
+    "tiktoken": "^1.0.22",
+    "tmp": "^0.2.4",
+    "tmp-promise": "^3.0.3",
+    "yaml": "^2.6.0",
+    "@llumiverse/common": "0.24.0-dev.202601221707",
+    "@vertesia/client": "0.24.0-dev.202601221707",
+    "@vertesia/common": "0.24.0-dev.202601221707",
+    "@vertesia/api-fetch-client": "0.24.0-dev.202601221707",
+    "@vertesia/memory": "0.24.0-dev.202601221707"
+  },
+  "ts_dual_module": {
+    "outDir": "lib",
+    "exports": {
+      "activities": "./activities/index.js",
+      "dsl-activities": "./activities/index-dsl.js",
+      "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"
+    },
+    "./dsl-activities": {
+      "types": "./lib/types/activities/index-dsl.d.ts",
+      "import": "./lib/esm/activities/index-dsl.js",
+      "require": "./lib/cjs/activities/index-dsl.js"
+    },
+    "./workflows": {
+      "types": "./lib/types/workflows.d.ts",
+      "import": "./lib/esm/workflows.js",
+      "require": "./lib/cjs/workflows.js"
+    },
+    "./dsl": {
+      "types": "./lib/types/dsl.d.ts",
+      "import": "./lib/esm/dsl.js",
+      "require": "./lib/cjs/dsl.js"
+    },
+    "./workflows-bundle": {
+      "import": "./lib/workflows-bundle.js"
+    },
+    "./errors": {
+      "types": "./lib/types/errors.d.ts",
+      "import": "./lib/esm/errors.js",
+      "require": "./lib/cjs/errors.js"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/vertesia/composableai.git",
+    "directory": "packages/workflow"
+  },
+  "keywords": [
+    "vertesia",
+    "workflow",
+    "dsl",
+    "temporalio",
+    "llm",
+    "ai",
+    "agents",
+    "typescript"
+  ],
+  "types": "./lib/types/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "activities": [
+        "./lib/types/activities/index.d.ts"
+      ],
+      "dsl-activities": [
+        "./lib/types/activities/index-dsl.d.ts"
+      ],
+      "workflows": [
+        "./lib/types/workflows.d.ts"
+      ],
+      "dsl": [
+        "./lib/types/dsl.d.ts"
+      ],
+      "vars": [
+        "./lib/types/dsl/vars.d.ts"
+      ],
+      "errors": [
+        "./lib/types/errors.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,55 @@
+import { log } from "@temporalio/activity";
+import { InteractionOutput } from "@vertesia/client";
+import { CreateContentObjectTypePayload, DSLActivityExecutionPayload, DSLActivitySpec, ExecutionRun } from "@vertesia/common";
+import { projectResult } from "../../dsl/projections.js";
+import { setupActivity } from "../../dsl/setup/ActivityContext.js";
+import { ActivityParamNotFoundError } 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<CreateDocumentTypeFromInteractionRunParams>) {
+    const { params, client } = await setupActivity<CreateDocumentTypeFromInteractionRunParams>(payload);
+
+    if (!params.run) {
+        throw new ActivityParamNotFoundError("run", payload.activity);
+    }
+
+    const jsonResult = InteractionOutput.from(params.run.result).object();
+
+    if (!jsonResult.document_type) {
+        log.error("No name generated for type: " + JSON.stringify(jsonResult), jsonResult);
+        throw new Error("No name generated for type");
+    }
+
+    log.info("Generated schema for type", jsonResult.metadata_schema);
+    const typeData: CreateContentObjectTypePayload = {
+        name: jsonResult.document_type,
+        object_schema: jsonResult.metadata_schema,
+        is_chunkable: !!jsonResult.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,119 @@
+import { log } from "@temporalio/activity";
+import { ContentObjectStatus, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { setupActivity } from "../../dsl/setup/ActivityContext.js";
+import { ActivityParamNotFoundError, DocumentNotFoundError } 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,
+
+    /**
+     * The name of the object to use. If not provided, the name will be generated from the interaction result
+     */
+    fallback_name?: string, // a name to use if no one was generated by the interaction
+
+    /**
+     * The name of the parent object to use. If not provided, the document will be created at the root level
+     */
+    parent?: string, // the parent object id
+
+    /**
+     * The name of the property to use for the text. If not provided, the text will be set to the result of the interaction
+     */
+    update_text_from_property?: string,
+
+}
+
+export interface CreateOrUpdateObjectFromInteractionRun extends DSLActivitySpec<CreateOrUpdateObjectFromInteractionRunParams> {
+    name: 'createOrUpdateDocumentFromInteractionRun';
+}
+
+export async function createOrUpdateDocumentFromInteractionRun(payload: DSLActivityExecutionPayload<CreateOrUpdateObjectFromInteractionRunParams>) {
+    const { params, client } = await setupActivity<CreateOrUpdateObjectFromInteractionRunParams>(payload);
+
+    const runId = params.run_id;
+    const objectTypeName = params.object_type;
+
+    if (!runId) {
+        throw new ActivityParamNotFoundError("run_id", payload.activity);
+    }
+    if (!objectTypeName && !params.update_existing_id) {
+        throw new ActivityParamNotFoundError("object_type", payload.activity);
+    }
+
+    log.info("Creating document from interaction result", { runId, objectTypeName });
+
+    const run = await client.runs.retrieve(runId).catch((e) => {
+        throw new DocumentNotFoundError(`Error fetching run ${runId}: ${e.message}`);
+    });
+
+    const type = objectTypeName ?
+        await client.types.getTypeByName(objectTypeName).catch((e) => {
+            throw new DocumentNotFoundError(`Error fetching type ${objectTypeName}: ${e.message}`);
+        })
+        : undefined;
+
+
+    const result = run.result;
+    const inputData = run.parameters;
+
+    // Try to parse result as JSON, fallback to text if not valid JSON
+    let jsonResult: any = null;
+    try {
+        jsonResult = result.object();
+    } catch (e) {
+        log.info("Result is not valid JSON, will use text content instead", { error: e instanceof Error ? e.message : String(e) });
+    }
+
+    const name = jsonResult?.['name'] || jsonResult?.["title"] || inputData['name'] || params.fallback_name || undefined;
+
+    const docPayload = {
+        name,
+        parent: params.parent ?? undefined,
+        properties: jsonResult ? jsonResult : {},
+        text: !jsonResult ? result.text() : undefined,
+        type: type?.id,
+        status: ContentObjectStatus.completed,
+        generation_run_info: {
+            id: run.id,
+            date: new Date().toISOString(),
+            model: run.modelId,
+            target: jsonResult ? 'properties' : 'text'
+        }
+    };
+
+    if (params.update_text_from_property) {
+        const text = docPayload.properties[params.update_text_from_property];
+        if (text) {
+            docPayload.text = 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, { suppressWorkflows: true });
+    } 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,35 @@
+import { InteractionOutput } from "@vertesia/client";
+import { DSLActivityExecutionPayload, DSLActivitySpec, ExecutionRun } from "@vertesia/common";
+import { setupActivity } from "../../dsl/setup/ActivityContext.js";
+import { ActivityParamNotFoundError } 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<UpdateDocumentFromInteractionRunParams>) {
+    const { params, client, objectId } = await setupActivity<UpdateDocumentFromInteractionRunParams>(payload);
+
+    if (!params.run) {
+        throw new ActivityParamNotFoundError("run", payload.activity);
+    }
+
+    const docProps = InteractionOutput.from(params.run.result).object();
+
+    if (!docProps) {
+        return { status: "failed", error: "no-props" };
+    }
+
+    await client.objects.update(objectId, docProps, { suppressWorkflows: true });
+
+    return { status: "success" };
+}

package/src/activities/chunkDocument.ts

@@ -0,0 +1,146 @@
+import { log } from "@temporalio/activity";
+import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { DocPart } from "../utils/chunks.js";
+import { InteractionExecutionParams, executeInteractionFromActivity } from "./executeInteraction.js";
+
+const INT_CHUNK_DOCUMENT = "sys:ChunkDocument"
+
+
+
+export interface ChunkDocumentResult {
+    id: string
+    status: "completed" | "failed" | "skipped"
+    parts?: string[]
+    message?: string
+}
+
+export interface ChunkDocumentParams extends InteractionExecutionParams {
+
+    /**
+     * If true, force chunking even if the document is already chunked
+     */
+    force?: boolean;
+
+    /**
+     * The interaction name to use for chunking
+     * If not set, the default interaction will be used
+     */
+    interactionName?: string;
+
+    /**
+     * The object type to use for the document parts
+     * If not set, the type of the document will be used
+     */
+    docPartType?: string;
+
+    /**
+     * If true, create parts as document objects
+     */
+    createParts?: boolean;
+}
+
+export interface ChunkDocument extends DSLActivitySpec<ChunkDocumentParams> {
+    name: 'chunkDocument';
+}
+
+
+export async function chunkDocument(payload: DSLActivityExecutionPayload<ChunkDocumentParams>): 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 jsonResult = res.result.object();
+
+    const parts = jsonResult.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" }
+    }
+
+
+    /**
+     * Only create parts as document if the flag is set
+     */
+    if (params.createParts) {
+
+        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/copyParentArtifacts.ts

@@ -0,0 +1,162 @@
+import { log, activityInfo } from "@temporalio/activity";
+import { NodeStreamSource } from "@vertesia/client/node";
+import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import { Readable } from "stream";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+
+/**
+ * Directories in the agent workspace to copy from parent to child.
+ */
+const WORKSPACE_DIRECTORIES = ['scripts', 'files', 'skills', 'docs', 'out'];
+
+/**
+ * Files that should never be copied (child has its own).
+ */
+const EXCLUDED_FILES = ['conversation.json', 'tools.json'];
+
+export interface CopyParentArtifactsParams {
+    parent_run_id: string;
+}
+
+export interface CopyParentArtifacts extends DSLActivitySpec<CopyParentArtifactsParams> {
+    name: 'copyParentArtifacts';
+    projection?: never;
+}
+
+/**
+ * Copy workspace artifacts from parent workflow's agent space to current workflow's agent space.
+ *
+ * Copies: scripts/, files/, skills/, docs/, out/
+ * Excludes: conversation.json, tools.json
+ */
+export async function copyParentArtifacts(
+    payload: DSLActivityExecutionPayload<CopyParentArtifactsParams>
+): Promise<{ copied: number; files: string[] }> {
+    const { client, params } = await setupActivity<CopyParentArtifactsParams>(payload);
+    const childRunId = activityInfo().workflowExecution.runId;
+    const parentRunId = params.parent_run_id;
+
+    log.info(`Copying artifacts from parent ${parentRunId} to child ${childRunId}`);
+
+    // List all files in parent's agent space
+    const parentFiles = await client.files.listArtifacts(parentRunId);
+
+    if (parentFiles.length === 0) {
+        log.info("No artifacts in parent agent space");
+        return { copied: 0, files: [] };
+    }
+
+    const copiedFiles: string[] = [];
+
+    for (const fullPath of parentFiles) {
+        const relativePath = extractRelativePath(fullPath, parentRunId);
+        if (!relativePath) continue;
+
+        // Only copy workspace directories
+        const dir = relativePath.split('/')[0];
+        if (!WORKSPACE_DIRECTORIES.includes(dir)) continue;
+
+        // Skip excluded files
+        const fileName = relativePath.split('/').pop() || '';
+        if (EXCLUDED_FILES.includes(fileName)) continue;
+
+        try {
+            await copyArtifact(client, parentRunId, childRunId, relativePath);
+            copiedFiles.push(relativePath);
+        } catch (err: any) {
+            log.warn(`Failed to copy ${relativePath}: ${err.message}`);
+        }
+    }
+
+    log.info(`Copied ${copiedFiles.length} artifacts from parent`);
+    return { copied: copiedFiles.length, files: copiedFiles };
+}
+
+/**
+ * Extract relative path from full artifact storage path.
+ * Storage paths can be: "store_xxx/agents/{runId}/..." or "agents/{runId}/..."
+ */
+function extractRelativePath(fullPath: string, runId: string): string | null {
+    // Look for the pattern: agents/{runId}/
+    const marker = `/agents/${runId}/`;
+    const idx = fullPath.lastIndexOf(marker);
+    if (idx >= 0) {
+        return fullPath.slice(idx + marker.length);
+    }
+
+    // Also try without leading slash
+    const legacyPrefix = `agents/${runId}/`;
+    if (fullPath.startsWith(legacyPrefix)) {
+        return fullPath.slice(legacyPrefix.length);
+    }
+
+    // If path contains the runId, try to extract after it
+    const runIdIdx = fullPath.indexOf(runId);
+    if (runIdIdx >= 0) {
+        const afterRunId = fullPath.slice(runIdIdx + runId.length);
+        if (afterRunId.startsWith('/')) {
+            return afterRunId.slice(1);
+        }
+    }
+
+    return null;
+}
+
+/**
+ * Copy a single artifact from parent to child agent space
+ */
+async function copyArtifact(
+    client: any,
+    parentRunId: string,
+    childRunId: string,
+    relativePath: string
+): Promise<void> {
+    // Download from parent's agent space
+    const stream = await client.files.downloadArtifact(parentRunId, relativePath);
+
+    // Convert web stream to node stream for upload
+    const nodeStream = Readable.fromWeb(stream as any);
+
+    // Determine mime type from extension
+    const mimeType = getMimeType(relativePath);
+    const fileName = relativePath.split('/').pop() || relativePath;
+
+    // Upload to child's agent space at the same relative path
+    const source = new NodeStreamSource(
+        nodeStream,
+        fileName,
+        mimeType
+    );
+
+    await client.files.uploadArtifact(childRunId, relativePath, source);
+}
+
+/**
+ * Get mime type from file extension
+ */
+function getMimeType(filePath: string): string {
+    const ext = filePath.split('.').pop()?.toLowerCase();
+    const mimeTypes: Record<string, string> = {
+        'json': 'application/json',
+        'txt': 'text/plain',
+        'md': 'text/markdown',
+        'html': 'text/html',
+        'csv': 'text/csv',
+        'png': 'image/png',
+        'jpg': 'image/jpeg',
+        'jpeg': 'image/jpeg',
+        'gif': 'image/gif',
+        'svg': 'image/svg+xml',
+        'pdf': 'application/pdf',
+        'xml': 'application/xml',
+        'zip': 'application/zip',
+        'js': 'application/javascript',
+        'ts': 'application/typescript',
+        'py': 'text/x-python',
+        'sh': 'text/x-shellscript',
+        'bash': 'text/x-shellscript',
+        'yaml': 'text/yaml',
+        'yml': 'text/yaml',
+    };
+    return mimeTypes[ext || ''] || 'application/octet-stream';
+}