@vertesia/workflow 0.50.1 → 0.52.0

package/src/conversion/image.test.ts

@@ -1,26 +1,118 @@
-import fs from 'fs';
-import path from 'path';
-import sharp from 'sharp';
-import { expect, test } from 'vitest';
-import { imageResizer } from '../conversion/image';
+import fs from "fs";
+import path from "path";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { expect, test, vi, describe } from "vitest";
 
+// Mock Temporal activity context
+vi.mock("@temporalio/activity", () => ({
+    log: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+    },
+}));
 
-test('should resize an image to a maximum height or width', async () => {
-  const max_hw = 1024;
-  const format: keyof sharp.FormatEnum = 'jpeg';
-  const imageFile = fs.readFileSync(path.join(__dirname, '../../fixtures', 'cat-picture.jpg'));
+// Import after mocking
+import { imageResizer } from "../conversion/image";
 
-  const resizer = imageResizer(max_hw, format);
+const execAsync = promisify(exec);
 
-  const resized = sharp(imageFile).pipe(resizer);
-  const buffer = await resized.toBuffer();
-  const metadata = await sharp(buffer).metadata();
+describe("ImageMagick image resizing", () => {
+    test("should resize an image to a maximum height or width using ImageMagick", async () => {
+        const max_hw = 1024;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
 
-  console.log(metadata);
-  resized.toFile('/tmp/cat-picture.jpg');
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
 
-  expect(metadata.width).to.be.lessThanOrEqual(max_hw);
-  expect(metadata.height).to.be.lessThanOrEqual(max_hw);
-  expect(metadata.format).to.equal(format);
+        // Call the imageResizer function with a file path
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format);
 
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to get metadata about the resized image
+        const { stdout } = await execAsync(`identify -format "%w %h %m" "${resizedImagePath}"`);
+        const [width, height, imageFormat] = stdout.trim().split(" ");
+
+        console.log({ width, height, imageFormat });
+
+        // Check dimensions
+        expect(parseInt(width)).to.be.lessThanOrEqual(max_hw);
+        expect(parseInt(height)).to.be.lessThanOrEqual(max_hw);
+
+        // Check format (JPEG)
+        expect(imageFormat.toLowerCase()).to.equal("jpeg");
+    });
+
+    test("should throw an error for non-existent input file", async () => {
+        const max_hw = 1024;
+        const format = "jpeg";
+        const nonExistentPath = path.join(__dirname, "non-existent-image.jpg");
+
+        // Verify file doesn't exist
+        expect(fs.existsSync(nonExistentPath)).toBe(false);
+
+        // Expect the function to throw an error
+        await expect(imageResizer(nonExistentPath, max_hw, format)).rejects.toThrow("Input file does not exist");
+    });
+
+    test("should throw error with empty format", async () => {
+        const max_hw = 1024;
+        const format = "";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Test for empty format validation
+        await expect(imageResizer(inputImagePath, max_hw, format)).rejects.toThrow("Invalid format");
+    });
+
+    test("should create progressive/interlaced image when enabled", async () => {
+        const max_hw = 800;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
+
+        // Call the imageResizer function with progressive=true
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format, true);
+
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to check if the image is interlaced
+        const { stdout } = await execAsync(`identify -format "%[interlace]" "${resizedImagePath}"`);
+        const interlaceMode = stdout.trim();
+
+        console.log({ interlaceMode });
+
+        // Check that interlace is enabled (should be 'JPEG' or 'Line' for progressive JPEG)
+        expect(["JPEG", "Line", "Plane"]).to.include(interlaceMode);
+    });
+
+    test("should create non-interlaced image when progressive is disabled", async () => {
+        const max_hw = 800;
+        const format = "jpeg";
+        const inputImagePath = path.join(__dirname, "../../fixtures", "cat-picture.jpg");
+
+        // Make sure the input file exists
+        expect(fs.existsSync(inputImagePath)).toBe(true);
+
+        // Call the imageResizer function with progressive=false
+        const resizedImagePath = await imageResizer(inputImagePath, max_hw, format, false);
+
+        // Make sure the output file exists
+        expect(fs.existsSync(resizedImagePath)).toBe(true);
+
+        // Use ImageMagick identify to check if the image is interlaced
+        const { stdout } = await execAsync(`identify -format "%[interlace]" "${resizedImagePath}"`);
+        const interlaceMode = stdout.trim().toLowerCase();
+
+        console.log({ interlaceMode });
+
+        // Check that interlace is disabled (should be 'none' or empty string)
+        expect(["none", ""]).to.include(interlaceMode);
+    });
 });

package/src/conversion/image.ts

@@ -1,22 +1,97 @@
-
-import sharp from "sharp";
-
+import { log } from "@temporalio/activity";
+import { execFile as execFileCallback } from "child_process";
+import fs from "fs";
+import { file } from "tmp-promise";
+import { promisify } from "util";
+const execFile = promisify(execFileCallback);
 
 /**
- * Resizes an image to a maximum height or width
- * @param max_hw 
- * @param format 
- * @returns 
+ * Resizes an image to a maximum height or width using ImageMagick
+ * with progressive loading when supported
+ * @param inputPath Input file path
+ * @param max_hw Maximum height or width
+ * @param format Output format
+ * @param progressive Enable progressive loading for supported formats (defaults to true)
+ * @returns Path to the resized image
  */
-export function imageResizer(max_hw: number, format: keyof sharp.FormatEnum) {
+export async function imageResizer(
+    inputPath: string,
+    max_hw: number,
+    format: string,
+    progressive: boolean = true,
+): Promise<string> {
+    const allowedFormats = ["jpg", "jpeg", "png", "webp"];
 
-    return sharp().resize({
-        width: max_hw,
-        height: max_hw,
-        fit: sharp.fit.inside,
-        withoutEnlargement: true,
+    if (!format || format.trim() === "") {
+        throw new Error(`Invalid format: ${format}.Supported : ${allowedFormats.join(", ")}`);
+    }
 
-    }).toFormat(format);
+    //check that max_hw is valid
+    if (!Number.isInteger(max_hw) || max_hw <= 0) {
+        throw new Error(`Invalid max_hw value: ${max_hw}`);
+    }
 
-}
+    //check that inputPath exists
+    if (!fs.existsSync(inputPath)) {
+        throw new Error(`Input file does not exist: ${inputPath}`);
+    }
+
+    // Create a temporary file
+    const { path: outputPath, cleanup } = await file({ postfix: `.${format}` });
+    try {
+        // Check if input file exists
+        if (!fs.existsSync(inputPath)) {
+            throw new Error(`Input file does not exist: ${inputPath}`);
+        }
+        // Validate max_hw
+        if (!Number.isInteger(max_hw) || max_hw <= 0) {
+            throw new Error(`Invalid max_hw value: ${max_hw}`);
+        }
+
+        // Progressive loading options
+        let conversionOption = "";
+
+        // Only add progressive option for formats that support it
+        if (progressive) {
+            // JPEG and some other formats support progressive loading
+            const lowerFormat = format.toLowerCase();
+            if (lowerFormat === "jpg" || lowerFormat === "jpeg") {
+                conversionOption = "-interlace JPEG";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            } else if (lowerFormat === "png") {
+                conversionOption = "-interlace PNG";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            } else if (lowerFormat === "gif") {
+                conversionOption = "-interlace GIF";
+                log.info(`Enabling interlaced ${lowerFormat.toUpperCase()} format`);
+            }
+        }
 
+        log.info(`Resizing image using ImageMagick: ${inputPath} -> ${outputPath}`);
+
+        const { stderr } = await execFile("convert", [
+            inputPath,
+            "-resize",
+            `${max_hw}x${max_hw}>`,
+            ...(conversionOption ? conversionOption.split(" ") : []),
+            outputPath,
+        ]);
+
+        if (stderr) {
+            log.warn(`ImageMagick warning: ${stderr}`);
+        }
+
+        // Verify output exists and has content
+        if (!fs.existsSync(outputPath) || fs.statSync(outputPath).size === 0) {
+            throw new Error(`ImageMagick conversion failed: output file not created or empty`);
+        }
+
+        return outputPath;
+    } catch (error) {
+        // Clean up the temporary file
+        await cleanup();
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        log.error(`Image conversion failed: ${errorMessage}`);
+        throw new Error(`Image conversion failed: ${errorMessage}`);
+    }
+}

package/src/conversion/pandoc.test.ts

@@ -9,14 +9,16 @@ let testEnv: TestWorkflowEnvironment;
 let activityContext: MockActivityEnvironment;
 
 beforeAll(async () => {
-  testEnv = await TestWorkflowEnvironment.createLocal();
-  activityContext = new MockActivityEnvironment();
+    testEnv = await TestWorkflowEnvironment.createLocal();
+    activityContext = new MockActivityEnvironment();
 });
 
 
 // Add more test cases for other file types (ODT, DOCX) if needed
 test('should convert docx to markdown', async () => {
-  const docx = fs.readFileSync(path.join(__dirname, '../../fixtures', 'us-ciia.docx'));
-  const result = await activityContext.run(manyToMarkdown, Buffer.from(docx), 'docx');
-  expect(result).to.include('confidential');
+    const filepath = path.join(__dirname, '../../fixtures', 'us-ciia.docx');
+    console.log("Converting file from", filepath);
+    const docx = fs.readFileSync(filepath);
+    const result = await activityContext.run(manyToMarkdown, Buffer.from(docx), 'docx');
+    expect(result).to.include('confidential');
 });

package/src/dsl/dslProxyActivities.ts

@@ -1,12 +1,12 @@
 import { ActivityOptions, proxyActivities } from "@temporalio/workflow";
-import { DSLActivityExecutionPayload, WorkflowExecutionPayload } from "@vertesia/common";
+import { DSLActivityExecutionPayload, WorkflowExecutionBaseParams, WorkflowExecutionPayload } from "@vertesia/common";
 
 export interface DslActivityFunction<ParamsT extends Record<string, any> = any, ReturnT = any> {
     (payload: DSLActivityExecutionPayload<ParamsT>): Promise<ReturnT>;
 }
 
 export interface DslSimplifiedActivityFunction<ParamsT = any, ReturnT = any> {
-    (payload: WorkflowExecutionPayload, params: ParamsT): Promise<ReturnT>;
+    (payload: WorkflowExecutionBaseParams, params: ParamsT): Promise<ReturnT>;
 }
 
 export function dslProxyActivities<

package/src/dsl/setup/ActivityContext.ts

@@ -1,13 +1,17 @@
+import { log, activityInfo } from "@temporalio/activity";
 import { VertesiaClient } from "@vertesia/client";
-import { DSLActivityExecutionPayload, DSLWorkflowExecutionPayload, Project, WorkflowExecutionPayload } from "@vertesia/common";
-import { log } from "@temporalio/activity";
+import {
+    DSLActivityExecutionPayload,
+    DSLWorkflowExecutionPayload,
+    Project,
+    WorkflowExecutionPayload,
+} from "@vertesia/common";
 import { NoDocumentFound, WorkflowParamNotFound } from "../../errors.js";
-import { getClient } from "../../utils/client.js";
+import { getProjectFromToken } from "../../utils/auth.js";
+import { getVertesiaClient } from "../../utils/client.js";
 import { Vars } from "../vars.js";
 import { getFetchProvider, registerFetchProviderFactory } from "./fetch/index.js";
 import { DocumentProvider, DocumentTypeProvider, InteractionRunProvider } from "./fetch/providers.js";
-import { getProjectFromToken } from "../../utils/auth.js";
-
 
 registerFetchProviderFactory(DocumentProvider.ID, DocumentProvider.factory);
 registerFetchProviderFactory(DocumentTypeProvider.ID, DocumentTypeProvider.factory);
@@ -17,7 +21,11 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     client: VertesiaClient;
     _project?: Promise<Project | undefined>;
 
-    constructor(public payload: DSLActivityExecutionPayload<ParamsT>, client: VertesiaClient, public params: ParamsT) {
+    constructor(
+        public payload: DSLActivityExecutionPayload<ParamsT>,
+        client: VertesiaClient,
+        public params: ParamsT,
+    ) {
         this.client = client;
         this.fetchProject = this.fetchProject.bind(this);
     }
@@ -29,24 +37,54 @@ export class ActivityContext<ParamsT extends Record<string, any>> {
     get objectId() {
         const objectId = this.payload.objectIds && this.payload.objectIds[0];
         if (!objectId) {
-            log.error('No objectId found in payload');
-            throw new WorkflowParamNotFound('objectIds[0]', (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow);
+            log.error("No objectId found in payload");
+            throw new WorkflowParamNotFound(
+                "objectIds[0]",
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
+            );
         }
         return objectId;
     }
 
+    get activityInfo() {
+        return activityInfo();
+    }
+
+    get runId() {
+        const runId = activityInfo().workflowExecution.runId;
+        if (!runId) {
+            log.error("No runId found in activityInfo");
+            throw new WorkflowParamNotFound(
+                "runId",
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
+            );
+        }
+        return runId;
+    }
+
+    get workflowId() {
+        const workflowId = activityInfo().workflowExecution.workflowId;
+        if (!workflowId) {
+            log.error("No workflowId found in activityInfo");
+            throw new WorkflowParamNotFound(
+                "workflowId",
+                (this.payload as WorkflowExecutionPayload as DSLWorkflowExecutionPayload).workflow,
+            );
+        }
+        return workflowId;
+    }
+
     fetchProject() {
         if (!this._project) {
             this._project = _fetchProject(this.client, this.payload);
         }
         return this._project;
     }
-
 }
 
-
-export async function setupActivity<ParamsT extends Record<string, any>>(payload: DSLActivityExecutionPayload<ParamsT>) {
-
+export async function setupActivity<ParamsT extends Record<string, any>>(
+    payload: DSLActivityExecutionPayload<ParamsT>,
+) {
     const isDebugMode = !!payload.debug_mode;
 
     const vars = new Vars({
@@ -56,13 +94,17 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
 
     //}
     if (isDebugMode) {
-        log.info(`Setting up activity ${payload.activity.name}`, { config: payload.config, activity: payload.activity, params: payload.params, vars });
+        log.info(`Setting up activity ${payload.activity.name}`, {
+            config: payload.config,
+            activity: payload.activity,
+            params: payload.params,
+            vars,
+        });
     }
 
-    const client = getClient(payload);
+    const client = getVertesiaClient(payload);
     const fetchSpecs = payload.activity.fetch;
     if (fetchSpecs) {
-
         const keys = Object.keys(fetchSpecs);
         if (keys.length > 0) {
             // create a new Vars instance to store the fetched data
@@ -74,7 +116,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
                     fetchSpec = { ...fetchSpec, query };
                 }
 
-                const provider = await getFetchProvider(client, fetchSpec);
+                const provider = getFetchProvider(client, fetchSpec);
 
                 log.info(`Fetching data for ${key} with provider ${provider.name}`, { fetchSpec });
                 const result = await provider.fetch(fetchSpec);
@@ -84,7 +126,7 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
                     } else {
                         vars.setValue(key, result);
                     }
-                } else if (fetchSpec.on_not_found === 'throw') {
+                } else if (fetchSpec.on_not_found === "throw") {
                     throw new NoDocumentFound("No documents found for: " + JSON.stringify(fetchSpec));
                 } else {
                     vars.setValue(key, null);
@@ -94,12 +136,11 @@ export async function setupActivity<ParamsT extends Record<string, any>>(payload
     }
 
     const params = vars.resolve() as ParamsT;
-    log.info(`Activity ${payload.activity.name} setup complete`, { params });
+    log.info(`Activity ${payload.activity.name} setup complete`);
 
     return new ActivityContext<ParamsT>(payload, client, params);
 }
 
-
 async function _fetchProject(client: VertesiaClient, payload: WorkflowExecutionPayload) {
     const project = await getProjectFromToken(payload.auth_token);
     return project ? await client.projects.retrieve(project.id) : undefined;

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

@@ -1,24 +1,45 @@
 import { DSLActivitySpec, DSLWorkflowSpec } from "@vertesia/common";
 
-
 export class NoDocumentFound extends Error {
-    constructor(message: string, public ids?: string[]) {
+    constructor(
+        message: string,
+        public ids?: string[],
+    ) {
         super(message);
         this.name = "NoDocumentFound";
-        this.ids = ids
+        this.ids = ids;
     }
 }
 
 export class ActivityParamNotFound extends Error {
-    constructor(public paramName: string, public activity: DSLActivitySpec) {
+    constructor(
+        public paramName: string,
+        public activity: DSLActivitySpec,
+    ) {
         super(`Required parameter ${paramName} not found in activity ${activity.name}`);
         this.name = "ActivityParamNotFound";
     }
 }
 
+export class ActivityParamInvalid extends Error {
+    constructor(
+        public paramName: string,
+        public activity: DSLActivitySpec,
+        reason?: string,
+    ) {
+        super(`${paramName} in activity ${activity.name} is invalid${reason ? ` ${reason}` : ""}`);
+        this.name = "ActivityParamInvalid";
+    }
+}
+
 export class WorkflowParamNotFound extends Error {
-    constructor(public paramName: string, public workflow?: DSLWorkflowSpec) {
+    constructor(
+        public paramName: string,
+        public workflow?: DSLWorkflowSpec,
+    ) {
         super(`Required parameter ${paramName} not found in workflow ${workflow?.name}`);
         this.name = "WorkflowParamNotFound";
     }
-}
+}
+
+export const WF_NON_RETRYABLE_ERRORS = ["NoDocumentFound", "ActivityParamNotFound", "WorkflowParamNotFound"];

package/src/index.ts

@@ -20,9 +20,16 @@ export * from "./activities/generateDocumentProperties.js";
 export * from "./activities/generateEmbeddings.js";
 export * from "./activities/generateImageRendition.js";
 export * from "./activities/generateOrAssignContentType.js";
-export * from "./activities/setDocumentStatus.js";
 export * from "./activities/notifyWebhook.js";
+export * from "./activities/setDocumentStatus.js";
 export * from "./iterative-generation/activities/index.js";
 
+export * from "./dsl/setup/ActivityContext.js";
+export * from "./errors.js";
 export * from "./result-types.js";
-export * from "./dsl/dslProxyActivities.js";
+export * from "./utils/blobs.js";
+export * from "./utils/client.js";
+export * from "./utils/memory.js";
+export * from "./utils/tokens.js";
+
+export * from "./conversion/image.js";

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

@@ -1,10 +1,10 @@
+import { log } from "@temporalio/activity";
 import { WorkflowExecutionPayload } from "@vertesia/common";
 import { parse as parseYaml } from "yaml";
-import { getClient } from "../../utils/client.js";
+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";
-import { log } from "@temporalio/activity";
 
 /**
  * This activity is called if the toc was provided in the payload. Otherwise
@@ -15,7 +15,7 @@ import { log } from "@temporalio/activity";
 export async function it_gen_extractToc(payload: WorkflowExecutionPayload): Promise<TocIndex | null> {
     const vars = payload.vars as IterativeGenerationPayload;
     const memory = vars.memory;
-    const client = getClient(payload);
+    const client = getVertesiaClient(payload);
 
     const inMemory = await loadMemoryPack(client, `${memory}/input`);
     let tocJson: string | null = null;

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

@@ -1,6 +1,6 @@
-import { WorkflowExecutionPayload } from "@vertesia/common";
 import { log } from "@temporalio/activity";
-import { getClient } from "../../utils/client.js";
+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";
@@ -9,7 +9,7 @@ export async function it_gen_finalizeOutput(payload: WorkflowExecutionPayload):
     const vars = payload.vars as IterativeGenerationPayload;
 
     const memory = vars.memory;
-    const client = getClient(payload);
+    const client = getVertesiaClient(payload);
     const inMemory = await loadMemoryPack(client, `${memory}/input`);
     const outMemory = await loadMemoryPack(client, `${memory}/output`);
 

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

@@ -1,14 +1,14 @@
+import { ApplicationFailure } from "@temporalio/workflow";
 import { WorkflowExecutionPayload } from "@vertesia/common";
 import { MemoryPack } from "@vertesia/memory";
-import { ApplicationFailure } from "@temporalio/workflow";
-import { getClient } from "../../utils/client.js";
+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 = getClient(payload);
+    const client = getVertesiaClient(payload);
     const memory = vars.memory;
 
     const [sectionIndex, partIndex] = path;

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

@@ -1,5 +1,5 @@
 import { WorkflowExecutionPayload } from "@vertesia/common";
-import { getClient } from "../../utils/client.js";
+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";
@@ -80,7 +80,7 @@ export async function it_gen_generateToc(payload: WorkflowExecutionPayload): Pro
 
     const schema = vars.toc_schema || defaultTocSchema;
 
-    const client = getClient(payload);
+    const client = getVertesiaClient(payload);
 
     const run = await executeWithVars(client, vars.interaction, vars, undefined, schema);
 

package/src/iterative-generation/iterativeGenerationWorkflow.ts

@@ -1,6 +1,7 @@
 import { WorkflowExecutionPayload } from "@vertesia/common";
 
 import { log, proxyActivities } from "@temporalio/workflow";
+import { WF_NON_RETRYABLE_ERRORS } from "../errors.js";
 import * as activities from "./activities/index.js";
 import { IterativeGenerationPayload, PartIndex, SECTION_ID_PLACEHOLDER } from "./types.js";
 
@@ -16,7 +17,7 @@ const {
         backoffCoefficient: 2,
         maximumAttempts: 20,
         maximumInterval: 100 * 30 * 1000, //ms
-        nonRetryableErrorTypes: [],
+        nonRetryableErrorTypes: WF_NON_RETRYABLE_ERRORS,
     },
 });
 

package/src/iterative-generation/utils.ts

@@ -2,15 +2,16 @@ import { VertesiaClient } from "@vertesia/client";
 import { ExecutionRun } from "@vertesia/common";
 import { ApplicationFailure } from "@temporalio/workflow";
 import { OutputMemoryMeta, PartIndex, Toc, TocIndex, TocSection } from "./types.js";
+import { ModelOptions, TextFallbackOptions } from "@llumiverse/core";
 
+//TODO: For whole file, support for options beyond max_tokens and temperature and multiple modalities.
 export interface ExecuteOptions {
     interaction: string;
     memory: string;
     memory_mapping?: Record<string, any>;
     environment?: string;
     model?: string;
-    max_tokens?: number;
-    temperature?: number;
+    model_options?: ModelOptions;
     result_schema?: Record<string, any>;
 }
 
@@ -24,8 +25,7 @@ export async function execute<T = any>(client: VertesiaClient, options: ExecuteO
         config: {
             environment: options.environment,
             model: options.model,
-            max_tokens: options.max_tokens,
-            temperature: options.temperature,
+            model_options: options.model_options,
         }
     });
 }
@@ -36,14 +36,18 @@ export function executeWithVars<T = any>(client: VertesiaClient, interaction: st
     } else {
         mapping = vars.input_mapping;
     }
+    const model_options: TextFallbackOptions = {
+        _option_id: "text-fallback",
+        max_tokens: vars.max_tokens,
+        temperature: vars.temperature
+    }
     return execute(client, {
         interaction: interaction,
         memory: `${vars.memory}/input`,
         memory_mapping: mapping,
         environment: vars.environment,
         model: vars.model,
-        max_tokens: vars.max_tokens,
-        temperature: vars.temperature,
+        model_options: model_options,
         result_schema: result_schema
     });
 }