@vertesia/workflow 0.24.0-dev.202601221707

package/src/dsl/workflow.test.ts

@@ -0,0 +1,122 @@
+import * as protos from '@temporalio/proto';
+import { TestWorkflowEnvironment } from '@temporalio/testing';
+import { Worker } from '@temporalio/worker';
+import { ContentEventName, DSLActivityExecutionPayload, DSLActivitySpec, DSLWorkflowExecutionPayload } from '@vertesia/common';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { dslWorkflow } from './dsl-workflow.js';
+import { setupActivity } from "./setup/ActivityContext.js";
+
+async function sayHello(payload: DSLActivityExecutionPayload): Promise<string> {
+    const { params } = await setupActivity(payload);
+    return params.lang === 'fr' ? "Bonjour" : "Hello";
+}
+
+async function sayName(payload: DSLActivityExecutionPayload): Promise<string> {
+    const { params } = await setupActivity(payload);
+    return params.lang === 'fr' ? "Monde" : "World";
+}
+
+async function sayGreeting(payload: DSLActivityExecutionPayload): Promise<string> {
+    const { params } = await setupActivity(payload);
+    return `${params.hello}, ${params.name}!`;
+}
+
+
+const activities: DSLActivitySpec[] = [
+    {
+        name: 'sayHello',
+        output: 'hello',
+        import: ["lang"],
+    },
+    {
+        name: 'sayName',
+        output: 'name',
+        import: ["lang"],
+    },
+    {
+        name: 'sayGreeting',
+        import: ["hello", "name"],
+        condition: {
+            hello: { $null: false },
+            name: { $null: false }
+        },
+        output: 'result',
+    },
+]
+
+// ========== test env setup ==========
+
+
+describe('DSL Workflow', () => {
+
+    let testEnv: TestWorkflowEnvironment;
+
+    beforeAll(async () => {
+        testEnv = await TestWorkflowEnvironment.createLocal();
+        const { connection } = testEnv;
+        await connection.operatorService.addSearchAttributes({
+            namespace: 'default',
+            searchAttributes: {
+                AccountId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                DocumentId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                ProjectId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                TenantId: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+                InitiatedBy: protos.temporal.api.enums.v1.IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD,
+            },
+        });
+    });
+
+    afterAll(async () => {
+        await testEnv?.teardown();
+    });
+
+    it('successfully completes a mock workflow', async () => {
+        const { client, nativeConnection } = testEnv;
+        const taskQueue = 'test';
+
+        const lang = 'fr';
+
+        const worker = await Worker.create({
+            connection: nativeConnection,
+            taskQueue,
+            workflowsPath: new URL("./dsl-workflow.ts", import.meta.url).pathname,
+            activities: { sayHello, sayName, sayGreeting },
+        });
+
+        const payload: DSLWorkflowExecutionPayload = {
+            event: ContentEventName.create,
+            objectIds: ['123'],
+            vars: {},
+            account_id: '123',
+            project_id: '123',
+            timestamp: Date.now(),
+            wf_rule_name: 'test',
+            auth_token: process.env.VERTESIA_KEY || 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.signature',
+            config: {
+                studio_url: process.env.CP_STUDIO_URL || "http://localhost:8081",
+                store_url: process.env.CP_STORE_URL || "http://localhost:8082",
+            },
+            workflow: {
+                activities,
+                vars: {
+                    lang,
+                },
+                name: 'test',
+            }
+        }
+
+        let result = await worker.runUntil(client.workflow.execute(dslWorkflow, {
+            args: [payload],
+            workflowId: 'test',
+            taskQueue,
+        }));
+
+        expect(result).toBe('Bonjour, Monde!');
+
+    });
+
+
+
+
+
+});

package/src/dsl.ts

@@ -0,0 +1,3 @@
+export * from "./dsl/dslProxyActivities.js";
+export * from "./errors.js";
+export * from "./result-types.js";

package/src/errors.ts

@@ -0,0 +1,101 @@
+import { ApplicationFailure } from "@temporalio/workflow";
+import { DSLActivitySpec, DSLWorkflowSpec } from "@vertesia/common";
+
+export class DocumentNotFoundError extends ApplicationFailure {
+    constructor(message: string, public ids?: string[]) {
+        super(
+            message,
+            "DocumentNotFoundError",
+            true, // non-retryable
+        )
+    }
+}
+
+export class ActivityParamNotFoundError extends ApplicationFailure {
+    constructor(
+        public paramName: string,
+        public activity: DSLActivitySpec,
+    ) {
+        super(
+            `Required parameter ${paramName} not found in activity ${activity.name}`,
+            "ActivityParamNotFoundError",
+            true, // non-retryable
+        );
+    }
+}
+
+export class ActivityParamInvalidError extends ApplicationFailure {
+    constructor(
+        public paramName: string,
+        public activity: DSLActivitySpec,
+        reason?: string,
+    ) {
+        super(
+            `${paramName} in activity ${activity.name} is invalid${reason ? ` ${reason}` : ""}`,
+            "ActivityParamInvalidError",
+            true, // non-retryable
+        );
+    }
+}
+
+export class WorkflowParamNotFoundError extends ApplicationFailure {
+    constructor(
+        public paramName: string,
+        public workflow?: DSLWorkflowSpec,
+    ) {
+        super(
+            `Required parameter ${paramName} not found in workflow ${workflow?.name}`,
+            "WorkflowParamNotFoundError",
+            true, // non-retryable
+        );
+    }
+}
+
+export class ResourceExhaustedError extends ApplicationFailure {
+    constructor(
+        public statusCode: number = 429,
+        message?: string,
+    ) {
+        super(
+            message || "Resource exhausted - rate limit exceeded",
+            "ResourceExhaustedError",
+            true, // non-retryable
+        );
+    }
+}
+
+export class InvalidContentTypeError extends ApplicationFailure {
+    constructor(
+        public objectId: string,
+        public expectedType: string,
+        public actualType: string,
+    ) {
+        super(
+            `Document ${objectId} has invalid content type. Expected ${expectedType}, got ${actualType}`,
+            "InvalidContentTypeError",
+            true, // non-retryable
+        );
+    }
+}
+
+export class TokenExpiredError extends ApplicationFailure {
+    constructor(
+        public statusCode: number,
+        message?: string,
+    ) {
+        super(
+            message || "Token expired: Authentication required",
+            "TokenExpiredError",
+            true, // non-retryable
+        );
+    }
+}
+
+export const WF_NON_RETRYABLE_ERRORS = [
+    "DocumentNotFoundError",
+    "ActivityParamInvalidError",
+    "ActivityParamNotFoundError",
+    "WorkflowParamNotFoundError",
+    "InvalidContentTypeError",
+    "TokenExpiredError",
+];

package/src/index.ts

@@ -0,0 +1,41 @@
+/**
+ * 1. Activities are exported through the '/activities' named export in package.json.
+ * Modify the `./activities/index.ts` if you want to modify activity exports
+ * 2. Workflows are exported through the '/workflows' named export in package.json.
+ * Modify the `./workflows.ts` file if you want to modify workflow exports
+ * 3. Here we export the API to be used to validate workflows and the types required to create workflow TS definitions.
+ */
+
+//TODO remove this - it is only for backward compat - iot is used from old workflows
+export { dslWorkflow } from "./dsl/dsl-workflow.js";
+export * from "./iterative-generation/iterativeGenerationWorkflow.js";
+
+export * from "./activities/advanced/createDocumentTypeFromInteractionRun.js";
+export * from "./activities/advanced/createOrUpdateDocumentFromInteractionRun.js";
+export * from "./activities/advanced/updateDocumentFromInteractionRun.js";
+export * from "./activities/chunkDocument.js";
+export * from "./activities/executeInteraction.js";
+export * from "./activities/extractDocumentText.js";
+export * from "./activities/generateDocumentProperties.js";
+export * from "./activities/generateEmbeddings.js";
+export * from "./activities/renditions/generateImageRendition.js";
+export * from "./activities/renditions/generateVideoRendition.js";
+export * from "./activities/generateOrAssignContentType.js";
+export * from "./activities/notifyWebhook.js";
+export * from "./activities/rateLimiter.js";
+export * from "./activities/setDocumentStatus.js";
+export * from "./iterative-generation/activities/index.js";
+export * from "./activities/media/prepareVideo.js";
+export * from "./activities/media/prepareAudio.js";
+
+export * from "./dsl/setup/ActivityContext.js";
+export * from "./errors.js";
+export * from "./result-types.js";
+export * from "./utils/blobs.js";
+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/iterative-generation/activities/extractToc.ts

@@ -0,0 +1,63 @@
+import { log } from "@temporalio/activity";
+import { WorkflowExecutionPayload } from "@vertesia/common";
+import { parse as parseYaml } from "yaml";
+import { getVertesiaClient } from "../../utils/client.js";
+import {
+    buildAndPublishMemoryPack,
+    loadMemoryPack,
+} from "../../utils/memory.js";
+import {
+    IterativeGenerationPayload,
+    OutputMemoryMeta,
+    Toc,
+    TocIndex,
+} from "../types.js";
+import { tocIndex } from "../utils.js";
+
+/**
+ * This activity is called if the toc was provided in the payload. Otherwise
+ * the generateToc is called.
+ *
+ * @param payload
+ */
+export async function it_gen_extractToc(
+    payload: WorkflowExecutionPayload,
+): Promise<TocIndex | null> {
+    const vars = payload.vars as IterativeGenerationPayload;
+    const memory = vars.memory;
+    const client = await getVertesiaClient(payload);
+
+    const inMemory = await loadMemoryPack(client, `${memory}/input`);
+    let tocJson: string | null = null;
+    let tocYaml: string | null = null;
+    let toc: any;
+    tocJson = await inMemory.getEntryText("toc.json");
+    if (!tocJson) {
+        tocYaml = await inMemory.getEntryText("toc.yaml");
+        if (tocYaml) {
+            toc = parseYaml(tocYaml) as Toc;
+        }
+    } else {
+        toc = JSON.parse(tocJson) as Toc;
+    }
+    if (!toc) {
+        log.info(`Nothing to extract: no TOC found in the input memory pack.`);
+        return null; // no toc found
+    }
+
+    log.info(`Found a TOC in the input memory pack`);
+
+    await buildAndPublishMemoryPack(
+        client,
+        `${vars.memory}/output`,
+        async () => {
+            return {
+                toc,
+                lastProcessedPart: undefined, // the part index (a number array)
+                previouslyGenerated: "",
+            } as OutputMemoryMeta;
+        },
+    );
+
+    return tocIndex(toc);
+}

package/src/iterative-generation/activities/finalizeOutput.ts

@@ -0,0 +1,100 @@
+import { log } from "@temporalio/activity";
+import { WorkflowExecutionPayload } from "@vertesia/common";
+import { getVertesiaClient } from "../../utils/client.js";
+import { expandVars } from "../../utils/expand-vars.js";
+import {
+    buildAndPublishMemoryPack,
+    loadMemoryPack,
+} from "../../utils/memory.js";
+import {
+    IterativeGenerationPayload,
+    Section,
+    SECTION_ID_PLACEHOLDER,
+    TocSection,
+} from "../types.js";
+
+export async function it_gen_finalizeOutput(
+    payload: WorkflowExecutionPayload,
+): Promise<string> {
+    const vars = payload.vars as IterativeGenerationPayload;
+
+    const memory = vars.memory;
+    const client = await getVertesiaClient(payload);
+    const inMemory = await loadMemoryPack(client, `${memory}/input`);
+    const outMemory = await loadMemoryPack(client, `${memory}/output`);
+
+    const content = await outMemory.getEntryText("content.json");
+    if (!content) {
+        log.info(`Nothing to do. No content.json file found`);
+        return "No content.json file found";
+    }
+
+    log.info(`Creating the final output memory pack.`);
+
+    const inMeta = await inMemory.getMetadata();
+    let tocName = "toc.json";
+    let toc = await inMemory.getEntryText(tocName);
+    if (!toc) {
+        tocName = "toc.yaml";
+        toc = await inMemory.getEntryText(tocName);
+    }
+    if (!toc) {
+        const outMeta = await outMemory.getMetadata();
+        tocName = "toc.json";
+        toc = JSON.stringify(outMeta.toc);
+    }
+    const sections = JSON.parse(content) as Section[];
+
+    await buildAndPublishMemoryPack(
+        client,
+        `${memory}/output`,
+        async ({ copyText }) => {
+            // copy the input toc file if any
+            if (toc) {
+                copyText(toc, tocName);
+            }
+            // copy the raw JSON content
+            copyText(content, "content.json");
+            if (vars.section_file_pattern) {
+                log.info(
+                    `Saving sections to files using pattern: ${vars.section_file_pattern}`,
+                );
+                // save sections to files
+                for (const section of sections) {
+                    let content = section.content;
+                    if (vars.section_file_header) {
+                        content =
+                            getSectionFileHeader(
+                                section,
+                                vars.section_file_header,
+                            ) +
+                            "\n\n" +
+                            content;
+                    }
+                    copyText(
+                        content,
+                        getSectionFileName(section, vars.section_file_pattern),
+                    );
+                }
+            }
+            return {
+                ...inMeta,
+                vars,
+            };
+        },
+    );
+
+    return `Processing done. Extracted files to: ${vars.section_file_pattern}`;
+}
+
+function getSectionFileHeader(section: TocSection, header: string): string {
+    const date = new Date().toISOString();
+    return expandVars(header, {
+        section,
+        date,
+    });
+}
+
+function getSectionFileName(section: TocSection, pattern: string): string {
+    return pattern.replace(SECTION_ID_PLACEHOLDER, section.id);
+}

package/src/iterative-generation/activities/generatePart.ts

@@ -0,0 +1,123 @@
+import { ApplicationFailure } from "@temporalio/workflow";
+import { WorkflowExecutionPayload } from "@vertesia/common";
+import { MemoryPack } from "@vertesia/memory";
+import { getVertesiaClient } from "../../utils/client.js";
+import {
+    buildAndPublishMemoryPack,
+    loadMemoryPack,
+} from "../../utils/memory.js";
+import {
+    IterativeGenerationPayload,
+    OutputMemoryMeta,
+    Section,
+    TocPart,
+    TocSection,
+} from "../types.js";
+import { executeWithVars, expectMemoryIsConsistent } from "../utils.js";
+
+export async function it_gen_generatePart(
+    payload: WorkflowExecutionPayload,
+    path: number[],
+) {
+    const vars = payload.vars as IterativeGenerationPayload;
+    const client = await getVertesiaClient(payload);
+    const memory = vars.memory;
+
+    const [sectionIndex, partIndex] = path;
+    const outMemory = await loadMemoryPack(client, `${memory}/output`);
+    const meta = (await outMemory.getMetadata()) as OutputMemoryMeta;
+
+    // the section we build is the section at the given index
+    const section: TocSection = meta.toc.sections[sectionIndex];
+    if (!section) {
+        throw ApplicationFailure.nonRetryable(
+            "Section not found in the TOC",
+            "SectionNotFound",
+            { memory, path },
+        );
+    }
+    let part: TocPart | undefined;
+    if (partIndex !== undefined) {
+        part = section.parts?.[partIndex];
+        if (!part) {
+            throw ApplicationFailure.nonRetryable(
+                "Part not found in the TOC section",
+                "PartNotFound",
+                { memory, path },
+            );
+        }
+    }
+
+    expectMemoryIsConsistent(meta, path);
+
+    const content = await loadGeneratedContent(outMemory);
+
+    let previously_generated = getPreviouslyGeneratedContent(
+        content,
+        !part,
+        vars.remembrance_strategy,
+    );
+
+    if (!part) {
+        // a new section
+        content.push({
+            id: section.id,
+            name: section.name,
+            description: section.description,
+            content: "",
+        });
+    } else if (!content.length) {
+        throw ApplicationFailure.nonRetryable(
+            "content.json is empty while generating a part",
+            "InvalidIterationState",
+            { memory, path },
+        );
+    }
+
+    const interaction = vars.iterative_interaction || vars.interaction;
+    const r = await executeWithVars(client, interaction, vars, {
+        iteration: {
+            toc: meta.toc,
+            previously_generated,
+            section: section.name,
+            part: part?.name,
+            path: path,
+        },
+    });
+
+    const result = r.result.text();
+    content[content.length - 1].content += result;
+    meta.lastProcessedPart = path;
+    await buildAndPublishMemoryPack(
+        client,
+        `${memory}/output`,
+        async ({ copyText }) => {
+            copyText(JSON.stringify(content, null, 2), "content.json");
+            return meta;
+        },
+    );
+}
+
+async function loadGeneratedContent(memory: MemoryPack): Promise<Section[]> {
+    const content = await memory.getEntryText("content.json");
+    return content ? JSON.parse(content) : [];
+}
+
+function getPreviouslyGeneratedContent(
+    sections: Section[],
+    isNewSection: boolean,
+    strategy?: "document" | "section" | "none",
+): string {
+    switch (strategy) {
+        case "document":
+            return sections
+                .map((section: Section) => section.content || "")
+                .join("\n\n");
+        case "none":
+            return "";
+        default:
+            return isNewSection
+                ? ""
+                : sections[sections.length - 1]?.content || "";
+    }
+}

package/src/iterative-generation/activities/generateToc.ts

@@ -0,0 +1,116 @@
+import { WorkflowExecutionPayload } from "@vertesia/common";
+import { getVertesiaClient } from "../../utils/client.js";
+import { buildAndPublishMemoryPack } from "../../utils/memory.js";
+import {
+    IterativeGenerationPayload,
+    OutputMemoryMeta,
+    Toc,
+    TocIndex,
+} from "../types.js";
+import { executeWithVars, tocIndex } from "../utils.js";
+
+const defaultTocSchema = {
+    type: "object",
+    properties: {
+        sections: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    id: {
+                        type: "string",
+                        description:
+                            "the id of the section, can be a filename if working on a file, a slug if working on a document or path, or a unique identifier if working on a model.",
+                    },
+                    operation: {
+                        type: "string",
+                        enum: ["create", "update", "delete"],
+                        description:
+                            "The operation to perform on the section, create, update or delete. If update, you will be requested later to provide the list of change operation to perform.",
+                    },
+                    name: {
+                        type: "string",
+                        description:
+                            "The name or title of the section, should be the path in the OpenAPI spec, of the title of the section/part.",
+                    },
+                    description: {
+                        type: "string",
+                    },
+                    instructions: {
+                        type: "string",
+                    },
+                    parts: {
+                        type: "array",
+                        description:
+                            "when the section is too large, you can split it into parts, each part should have a title and description. Use it to split the section into subsection. When doing an API documentation, you can do one part for each path. When generating code, you can do one part for each method. When generating an OpenAPI spec, you can do one part for each operation.",
+                        items: {
+                            type: "object",
+                            properties: {
+                                id: {
+                                    type: "string",
+                                    description:
+                                        "the id of the part, can be a filename if working on a file, a slug if working on a document or path, or a unique identifier if working on a model.",
+                                },
+                                name: {
+                                    type: "string",
+                                    description:
+                                        "The name or title of the part, should be the path in the OpenAPI spec, of the title of the section/part.",
+                                },
+                                /*
+                                "description": {
+                                    "type": "string"
+                                },
+                                */
+                                instructions: {
+                                    type: "string",
+                                },
+                            },
+                            required: ["id", "name"],
+                        },
+                    },
+                },
+                required: ["id", "name", "operation"],
+            },
+        },
+    },
+    required: ["sections"],
+};
+
+export async function it_gen_generateToc(
+    payload: WorkflowExecutionPayload,
+): Promise<TocIndex> {
+    const vars = payload.vars as IterativeGenerationPayload;
+
+    const schema = vars.toc_schema || defaultTocSchema;
+
+    const client = await getVertesiaClient(payload);
+
+    const run = await executeWithVars(
+        client,
+        vars.interaction,
+        vars,
+        undefined,
+        schema,
+    );
+
+    //Parse the CompletionResult[] to get a Toc object
+    const jsonResults = run.result.object();
+
+    const toc: Toc = {
+        sections: jsonResults.sections
+    };
+
+    await buildAndPublishMemoryPack(
+        client,
+        `${vars.memory}/output`,
+        async () => {
+            return {
+                toc,
+                lastProcessedPart: undefined, // the part index (a number array)
+                previouslyGenerated: "",
+            } satisfies OutputMemoryMeta;
+        },
+    );
+
+    return tocIndex(toc);
+}

package/src/iterative-generation/activities/index.ts

@@ -0,0 +1,4 @@
+export { it_gen_generateToc } from './generateToc.js';
+export { it_gen_generatePart } from './generatePart.js';
+export { it_gen_extractToc } from './extractToc.js';
+export { it_gen_finalizeOutput } from './finalizeOutput.js'