@vertesia/workflow 1.2.0 → 1.3.0-dev.20260620.061059Z

package/src/activities/chunkDocument.ts

@@ -1,22 +1,34 @@
-import { ApplicationFailure, 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";
+import { ApplicationFailure, log } from '@temporalio/activity';
+import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import type { DocPart } from '../utils/chunks.js';
+import { executeInteractionFromActivity, type InteractionExecutionParams } from './executeInteraction.js';
 
-const INT_CHUNK_DOCUMENT = "sys:ChunkDocument"
+const INT_CHUNK_DOCUMENT = 'sys:ChunkDocument';
 
+interface RetryableError extends Error {
+    retryable?: boolean;
+}
+
+interface ChunkDocumentInteractionResult {
+    parts?: DocPart[];
+}
 
+function toRetryableError(error: unknown): RetryableError {
+    if (error instanceof Error) {
+        return error as RetryableError;
+    }
+    return new Error(String(error)) as RetryableError;
+}
 
 export interface ChunkDocumentResult {
-    id: string
-    status: "completed" | "failed" | "skipped"
-    parts?: string[]
-    message?: string
+    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
      */
@@ -44,8 +56,9 @@ export interface ChunkDocument extends DSLActivitySpec<ChunkDocumentParams> {
     name: 'chunkDocument';
 }
 
-
-export async function chunkDocument(payload: DSLActivityExecutionPayload<ChunkDocumentParams>): Promise<ChunkDocumentResult> {
+export async function chunkDocument(
+    payload: DSLActivityExecutionPayload<ChunkDocumentParams>,
+): Promise<ChunkDocumentResult> {
     const { params, client, objectId } = await setupActivity<ChunkDocumentParams>(payload);
 
     const { force } = params;
@@ -53,121 +66,118 @@ export async function chunkDocument(payload: DSLActivityExecutionPayload<ChunkDo
 
     log.info(`Object ${objectId} chunking started`);
 
-    const document = await client.objects.retrieve(objectId, "+text");
+    const document = await client.objects.retrieve(objectId, '+text');
 
-    const type = document.type
-        ? await client.types.catalog.resolve(document.type)
-        : undefined;
+    const type = document.type ? await client.types.catalog.resolve(document.type) : undefined;
 
     if (!type?.is_chunkable) {
-        log.warn('Type is not chunkable for object ID: ' + objectId);
-        return { id: objectId, status: "skipped", message: "type not 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" }
+        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" }
+        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 lines = document.text.split('\n');
+    const instrumented = lines.map((l, i) => `{%${i}%}${l}`).join('\n');
 
-    let res;
+    let res: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
     try {
         res = await executeInteractionFromActivity(client, interactionName, params, {
             objectId: objectId,
-            content: instrumented
+            content: instrumented,
         });
-    } catch (error: any) {
-        log.error(`Failed to chunk document ${objectId}`, { error, retryable: error.retryable });
-        
+    } catch (error: unknown) {
+        const chunkError = toRetryableError(error);
+        log.error(`Failed to chunk document ${objectId}`, { error: chunkError, retryable: chunkError.retryable });
+
         // Check retryability and convert to ApplicationFailure for Temporal
-        const isRetryable = error.retryable !== undefined 
-            ? error.retryable !== false
-            : undefined;
-        
+        const isRetryable = chunkError.retryable !== undefined ? chunkError.retryable !== false : undefined;
+
         if (isRetryable !== undefined) {
             if (isRetryable) {
                 throw ApplicationFailure.create({
-                    message: `Document chunking failed for ${objectId}: ${error.message}`,
+                    message: `Document chunking failed for ${objectId}: ${chunkError.message}`,
                     nonRetryable: false,
                 });
             } else {
                 throw ApplicationFailure.create({
-                    message: `Non-retryable document chunking failed for ${objectId}: ${error.message}`,
+                    message: `Non-retryable document chunking failed for ${objectId}: ${chunkError.message}`,
                     nonRetryable: true,
                 });
             }
         }
-        
+
         // Unknown retryability - rethrow
         throw error;
     }
 
-    const jsonResult = res.result.object();
+    const jsonResult = res.result.object<ChunkDocumentInteractionResult>();
 
-    const parts = jsonResult.parts as DocPart[];
+    const parts = jsonResult.parts;
     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" }
+        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;
-        }));
+        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,
+                        ...(document.text_etag !== undefined ? { 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 });
+            log.info(`Deleting previous parts for object ID: ${objectId}`, { parts: document.parts });
             await client.objects.delete(document.parts);
         }
 
         await client.objects.update(objectId, {
-            parts: partDocs.map(p => p.id),
-            parts_etag: document.text_etag
+            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 }
-
-}
+    return { id: objectId, status: 'completed', parts: document.parts };
+}

package/src/activities/createDocumentFromOther.ts

@@ -1,33 +1,31 @@
-import { log } from "@temporalio/activity";
-import { NodeStreamSource } from "@vertesia/client/node";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
-import fs from 'fs';
-import { pdfExtractPages } from "../conversion/mutool.js";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { DocumentNotFoundError } from "../errors.js";
-import { saveBlobToTempFile } from "../utils/blobs.js";
+import fs from 'node:fs';
+import { log } from '@temporalio/activity';
+import { NodeStreamSource } from '@vertesia/client/node';
+import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
+import { pdfExtractPages } from '../conversion/mutool.js';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError } from '../errors.js';
+import { saveBlobToTempFile } from '../utils/blobs.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 extracting pages from a source PDF
  * @returns
  */
-export async function createPdfDocumentFromSource(payload: DSLActivityExecutionPayload<CreatePdfDocumentFromSourceParams>) {
+export async function createPdfDocumentFromSource(
+    payload: DSLActivityExecutionPayload<CreatePdfDocumentFromSourceParams>,
+) {
     const { client, objectId, params } = await setupActivity<CreatePdfDocumentFromSourceParams>(payload);
     const inputObject = await client.objects.retrieve(objectId);
 
@@ -49,9 +47,11 @@ export async function createPdfDocumentFromSource(payload: DSLActivityExecutionP
         throw new DocumentNotFoundError(`Document ${objectId} has no source`, [objectId]);
     }
 
-    if (!inputObject.content.type || (!inputObject.content.type?.startsWith('application/pdf'))) {
+    if (!inputObject.content.type?.startsWith('application/pdf')) {
         log.error(`Document ${objectId} is not an image`);
-        throw new DocumentNotFoundError(`Document ${objectId} is not an image or pdf: ${inputObject.content.type}`, [objectId]);
+        throw new DocumentNotFoundError(`Document ${objectId} is not an image or pdf: ${inputObject.content.type}`, [
+            objectId,
+        ]);
     }
 
     const targetType = await client.types.getTypeByName(params.target_object_type);
@@ -60,16 +60,12 @@ export async function createPdfDocumentFromSource(payload: DSLActivityExecutionP
         throw new DocumentNotFoundError(`Type ${params.target_object_type} not found`);
     }
 
-    const tmpFile = await saveBlobToTempFile(client, inputObject.content.source, ".pdf");
+    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"
-    )
+    const sourceToUpload = new NodeStreamSource(fs.createReadStream(newPdf), name, 'application/pdf');
 
     log.info(`Uploading file ${newPdf} `);
     const upload = await client.objects.upload(sourceToUpload);
@@ -82,11 +78,9 @@ export async function createPdfDocumentFromSource(payload: DSLActivityExecutionP
         content: {
             source: upload.source,
             name: upload.name,
-            type: 'application/pdf'
-        }
+            type: 'application/pdf',
+        },
     });
 
     return { newObjectId: newObject.id, uploadedFile: upload.name };
-
-
 }

package/src/activities/executeInteraction.test.ts

@@ -1,10 +1,10 @@
-import { ApplicationFailure } from '@temporalio/activity';
+import type { ApplicationFailure } from '@temporalio/activity';
 import { MockActivityEnvironment } from '@temporalio/testing';
 import type { VertesiaClient } from '@vertesia/client';
-import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
-import type { ActivityContext } from '../dsl/setup/ActivityContext.js';
+import { ContentEventName, type DSLActivityExecutionPayload, ExecutionRunStatus } from '@vertesia/common';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { executeInteraction, type ExecuteInteractionParams } from './executeInteraction.js';
+import type { ActivityContext } from '../dsl/setup/ActivityContext.js';
+import { type ExecuteInteractionParams, executeInteraction } from './executeInteraction.js';
 
 vi.mock('../dsl/setup/ActivityContext.js', async (importOriginal) => {
     const actual = await importOriginal<typeof import('../dsl/setup/ActivityContext.js')>();
@@ -38,7 +38,9 @@ const createPayload = (): DSLActivityExecutionPayload<ExecuteInteractionParams>
     activity: { name: 'executeInteraction', params: {} },
 });
 
-async function mockInteractionError(error: Error & { statusCode?: number; status?: number; code?: number }): Promise<void> {
+async function mockInteractionError(
+    error: Error & { statusCode?: number; status?: number; code?: number; retryable?: boolean },
+): Promise<void> {
     const { setupActivity } = await import('../dsl/setup/ActivityContext.js');
     const mockClient = {
         interactions: {
@@ -54,7 +56,57 @@ async function mockInteractionError(error: Error & { statusCode?: number; status
 }
 
 describe('executeInteraction retryability', () => {
-    it('leaves 412 rendition-in-progress failures retryable', async () => {
+    it('should forward the execution config object to interaction execution', async () => {
+        const { setupActivity } = await import('../dsl/setup/ActivityContext.js');
+        const httpTimeout = {
+            headersTimeout: 1_000,
+            bodyTimeout: 2_000,
+            connectTimeout: 300,
+        };
+        const executeByName = vi.fn().mockResolvedValue({
+            id: 'run-id',
+            status: ExecutionRunStatus.completed,
+            result: [],
+        });
+        const mockClient = {
+            interactions: {
+                executeByName,
+            },
+        } as unknown as VertesiaClient;
+        const payload = createPayload();
+        const params: ExecuteInteractionParams = {
+            ...payload.params,
+            config: {
+                environment: 'env-id',
+                model: 'model-id',
+                http_timeout: httpTimeout,
+            },
+        };
+
+        vi.mocked(setupActivity).mockResolvedValue({
+            client: mockClient,
+            inputType: 'objectIds',
+            params,
+        } as unknown as ActivityContext<ExecuteInteractionParams>);
+
+        await expect(testEnv.run(executeInteraction, { ...payload, params })).resolves.toMatchObject({
+            runId: 'run-id',
+            status: ExecutionRunStatus.completed,
+        });
+
+        expect(executeByName).toHaveBeenCalledWith(
+            'testInteraction',
+            expect.objectContaining({
+                config: expect.objectContaining({
+                    environment: 'env-id',
+                    model: 'model-id',
+                    http_timeout: httpTimeout,
+                }),
+            }),
+        );
+    });
+
+    it('should leave 412 rendition-in-progress failures retryable', async () => {
         await mockInteractionError(Object.assign(new Error('rendition in progress'), { statusCode: 412 }));
 
         await expect(testEnv.run(executeInteraction, createPayload())).rejects.toMatchObject({
@@ -65,7 +117,7 @@ describe('executeInteraction retryability', () => {
     it.each([
         ['status', { status: 412 }],
         ['code', { code: 412 }],
-    ])('leaves 412 failures retryable when reported as %s', async (_field, statusProps) => {
+    ])('should leave 412 failures retryable when reported as %s', async (_field, statusProps) => {
         await mockInteractionError(Object.assign(new Error('precondition failed'), statusProps));
 
         await expect(testEnv.run(executeInteraction, createPayload())).rejects.toMatchObject({
@@ -73,11 +125,32 @@ describe('executeInteraction retryability', () => {
         });
     });
 
-    it('marks other 4xx failures as non-retryable', async () => {
+    it('should mark other 4xx failures as non-retryable', async () => {
         await mockInteractionError(Object.assign(new Error('bad request'), { statusCode: 400 }));
 
         await expect(testEnv.run(executeInteraction, createPayload())).rejects.toMatchObject({
             nonRetryable: true,
         } satisfies Partial<ApplicationFailure>);
     });
+
+    it('should honor explicitly retryable 4xx execution errors', async () => {
+        await mockInteractionError(
+            Object.assign(new Error('Status: URL_REJECTED-REJECTED_CLIENT_THROTTLED'), {
+                statusCode: 400,
+                retryable: true,
+            }),
+        );
+
+        await expect(testEnv.run(executeInteraction, createPayload())).rejects.toMatchObject({
+            nonRetryable: false,
+        } satisfies Partial<ApplicationFailure>);
+    });
+
+    it('should honor explicitly non-retryable execution errors', async () => {
+        await mockInteractionError(Object.assign(new Error('provider rejected request'), { retryable: false }));
+
+        await expect(testEnv.run(executeInteraction, createPayload())).rejects.toMatchObject({
+            nonRetryable: true,
+        } satisfies Partial<ApplicationFailure>);
+    });
 });