@vertesia/workflow 1.5.0-dev.20260717.131047Z → 1.5.0-dev.20260722.120446Z

package/src/activities/generateOrAssignContentType.ts

@@ -1,10 +1,14 @@
+import type { JSONSchema } from '@llumiverse/common';
 import { ApplicationFailure, log } from '@temporalio/activity';
 import {
     type ContentObjectTypeItem,
+    type ContentSource,
     type CreateContentObjectTypePayload,
     type DSLActivityExecutionPayload,
     type DSLActivitySpec,
     ImageRenditionFormat,
+    PDF_RENDITION_NAME,
+    type Rendition,
 } from '@vertesia/common';
 import { type ActivityContext, setupActivity } from '../dsl/setup/ActivityContext.js';
 import { type TruncateSpec, truncByMaxTokens } from '../utils/tokens.js';
@@ -75,9 +79,39 @@ export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrA
     name: 'generateOrAssignContentType';
 }
 
+export type GenerateOrAssignContentTypeResult =
+    | {
+          status: 'skipped';
+          message: string;
+      }
+    | {
+          status: 'failed';
+          error: 'no-text';
+      }
+    | {
+          id: string;
+          name: string;
+          isNew: boolean;
+      };
+
+function getPdfRenditionContent(doc: { metadata?: { renditions?: unknown } }): ContentSource | undefined {
+    const renditions = doc.metadata?.renditions;
+    if (!Array.isArray(renditions)) {
+        return undefined;
+    }
+    const pdfRendition = renditions.find(
+        (rendition): rendition is Rendition =>
+            typeof rendition === 'object' &&
+            rendition !== null &&
+            (rendition as { name?: unknown }).name === PDF_RENDITION_NAME &&
+            typeof (rendition as { content?: { source?: unknown } }).content?.source === 'string',
+    );
+    return pdfRendition?.content;
+}
+
 export async function generateOrAssignContentType(
     payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>,
-) {
+): Promise<GenerateOrAssignContentTypeResult> {
     const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
     const { params, client, objectId } = context;
 
@@ -85,7 +119,7 @@ export async function generateOrAssignContentType(
 
     log.debug(`SelectDocumentType for object: ${objectId}`, { payload });
 
-    const object = await client.objects.retrieve(objectId, '+text');
+    const object = await client.objects.retrieve(objectId, '+text +metadata +content');
 
     //Expects object.type to be null on first ingestion of content
     //User initiated Content Type change via the Composable UI,
@@ -99,12 +133,13 @@ export async function generateOrAssignContentType(
         };
     }
 
-    if (
-        !object ||
-        (!object.text &&
-            !object.content?.type?.startsWith('image/') &&
-            !object.content?.type?.startsWith('application/pdf'))
-    ) {
+    const pdfRendition = getPdfRenditionContent(object);
+    const hasVisionSource =
+        object.content?.type?.startsWith('image/') ||
+        object.content?.type?.startsWith('application/pdf') ||
+        !!pdfRendition?.type?.startsWith('application/pdf');
+
+    if (!object || (!object.text && !hasVisionSource)) {
         log.info(`Object ${objectId} not found or text is empty and not an image`, {
             object,
         });
@@ -116,10 +151,13 @@ export async function generateOrAssignContentType(
     });
 
     //make a list of all existing types, and add hints if any
-    const existing_types = types.filter((t) => !['DocumentPart', 'Rendition'].includes(t.name));
+    const existing_types = types.filter((t) => !['DocumentPart', 'Rendition'].includes(t.name) && t.status !== 'draft');
     const content = object.text ? truncByMaxTokens(object.text, params.truncate || 30000) : undefined;
 
-    const getImage = async () => {
+    const getImage = async (): Promise<string | ContentSource | undefined> => {
+        if (pdfRendition?.type?.startsWith('application/pdf')) {
+            return pdfRendition;
+        }
         if (object.content?.type?.includes('pdf') && object.text?.length && object.text?.length < 100) {
             return `store:${objectId}`;
         }
@@ -140,18 +178,48 @@ export async function generateOrAssignContentType(
 
     const fileRef = await getImage();
 
+    // Slim catalog for the selection prompt: names + identification guidance only, NO schemas
+    // (design intake-v2 §3). The full list (with schemas) is still used for matching and for
+    // new-type generation below.
+    const selectionCatalog = existing_types.map((t) => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        guidance: t.intake?.identification?.guidance,
+        distinguish_from: t.intake?.identification?.distinguish_from,
+    }));
+
+    // Closed-world output: constrain the result to the eligible type names + 'other', which
+    // removes the exact-string-match fragility on the model's answer.
+    const selectionResultSchema: JSONSchema = {
+        type: 'object',
+        properties: {
+            document_type: {
+                type: 'string',
+                enum: [...existing_types.map((t) => t.name), 'other'],
+                description: "Name of the matching document type, or 'other' when none matches.",
+            },
+        },
+        required: ['document_type'],
+    };
+
     log.info(
-        'Execute SelectDocumentType interaction on content with \nexisting types - passing full types: ' +
-            existing_types.filter((t) => !t.tags?.includes('system')),
+        'Execute SelectDocumentType interaction on content with \nexisting types - passing slim catalog: ' +
+            existing_types.filter((t) => !t.tags?.includes('system')).map((t) => t.name),
     );
 
     let res: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
     try {
-        res = await executeInteractionFromActivity(client, interactionName, params, {
-            existing_types,
-            content,
-            image: fileRef,
-        });
+        res = await executeInteractionFromActivity(
+            client,
+            interactionName,
+            { ...params, result_schema: selectionResultSchema },
+            {
+                existing_types: selectionCatalog,
+                content,
+                image: fileRef,
+            },
+        );
     } catch (error: unknown) {
         const selectionError = toRetryableError(error);
         log.error(`Failed to select document type`, { error: selectionError, retryable: selectionError.retryable });
@@ -180,20 +248,31 @@ export async function generateOrAssignContentType(
     log.debug(`Selected Content Type Result: ${JSON.stringify(jsonResult)}`);
 
     //if type is not identified or not present in the database, generate a new type
-    let selectedType: { id: string; name: string } | undefined;
+    let selectedType: { id: string; name: string; isNew: boolean } | undefined;
 
-    selectedType = types.find((t) => t.name === jsonResult.document_type);
+    const existingMatch = existing_types.find((t) => t.name === jsonResult.document_type);
+    if (existingMatch) {
+        selectedType = { id: existingMatch.id, name: existingMatch.name, isNew: false };
+    }
 
     if (!selectedType) {
         if (params.allowNewContentTypes === false) {
             // Type generation is disabled (handled separately, e.g. via the Studio Assistant), so
             // fall back to the project's default type (or sys:GenericDocument) rather than leaving
-            // the document untyped.
+            // the document untyped. 'other' is the constrained schema's first-class no-match
+            // answer, not a selection defect — only warn on anything else.
+            if (jsonResult.document_type && jsonResult.document_type !== 'other') {
+                log.warn('Document type selection returned an ineligible or unknown type; assigning fallback', {
+                    objectId,
+                    selectedDocumentType: jsonResult.document_type,
+                    eligibleTypes: existing_types.map((type) => type.name),
+                });
+            }
             selectedType = await resolveFallbackType(context, params.fallbackTypeId, jsonResult.document_type);
         } else {
             log.warn('Document type not identified: starting type generation');
             const newType = await generateNewType(context, existing_types, content, fileRef);
-            selectedType = { id: newType.id, name: newType.name };
+            selectedType = { id: newType.id, name: newType.name, isNew: true };
         }
     }
 
@@ -202,15 +281,21 @@ export async function generateOrAssignContentType(
         throw new Error(`Type not found: ${jsonResult.document_type}`);
     }
 
-    //update object with selected type
-    await client.objects.update(objectId, {
-        type: selectedType.id,
-    });
+    // Update object with selected type. Suppress workflow triggers: this is an intake-internal
+    // self-write — type updates now emit dirty.type and match the StandardIntake trigger, so an
+    // unsuppressed write here would recursively re-run intake on every type assignment.
+    await client.objects.update(
+        objectId,
+        {
+            type: selectedType.id,
+        },
+        { suppressWorkflows: true },
+    );
 
     return {
         id: selectedType.id,
         name: selectedType.name,
-        isNew: !types.find((t) => t.name === selectedType.name),
+        isNew: selectedType.isNew,
     };
 }
 
@@ -222,7 +307,7 @@ async function resolveFallbackType(
     context: ActivityContext<GenerateOrAssignContentTypeParams>,
     fallbackTypeId: string | undefined,
     selectedDocumentType: unknown,
-): Promise<{ id: string; name: string }> {
+): Promise<{ id: string; name: string; isNew: false }> {
     if (fallbackTypeId && fallbackTypeId !== GENERIC_DOCUMENT_TYPE_ID) {
         try {
             const resolved = await context.client.types.catalog.resolve(fallbackTypeId);
@@ -230,7 +315,7 @@ async function resolveFallbackType(
                 fallbackTypeId,
                 selectedDocumentType,
             });
-            return { id: resolved.id ?? fallbackTypeId, name: resolved.name ?? fallbackTypeId };
+            return { id: resolved.id ?? fallbackTypeId, name: resolved.name ?? fallbackTypeId, isNew: false };
         } catch (error) {
             log.warn('Configured default content type not resolvable; using GenericDocument', {
                 fallbackTypeId,
@@ -239,14 +324,14 @@ async function resolveFallbackType(
         }
     }
     log.info('Document type not identified; assigning GenericDocument fallback', { selectedDocumentType });
-    return { id: GENERIC_DOCUMENT_TYPE_ID, name: GENERIC_DOCUMENT_TYPE_NAME };
+    return { id: GENERIC_DOCUMENT_TYPE_ID, name: GENERIC_DOCUMENT_TYPE_NAME, isNew: false };
 }
 
 async function generateNewType(
     context: ActivityContext<GenerateOrAssignContentTypeParams>,
     existing_types: ContentObjectTypeItem[],
     content?: string,
-    fileRef?: string,
+    fileRef?: string | ContentSource,
 ) {
     const { client, params } = context;
 

package/src/activities/media/exec.test.ts

@@ -0,0 +1,194 @@
+import { MockActivityEnvironment } from '@temporalio/testing';
+import { describe, expect, it } from 'vitest';
+import { createFfmpegProgressTracker, execActivityFile, execActivityFileWithProgress } from './exec.js';
+
+describe('execActivityFile', () => {
+    it('should execute a child process inside an Activity context', async () => {
+        const testEnv = new MockActivityEnvironment();
+
+        const result = await testEnv.run(() =>
+            execActivityFile(process.execPath, ['-e', "process.stdout.write('completed')"]),
+        );
+
+        expect(result).toEqual({ stdout: 'completed', stderr: '' });
+    });
+
+    it('should terminate the child process when the Activity is cancelled', async () => {
+        const testEnv = new MockActivityEnvironment();
+        const execution = testEnv.run(() =>
+            execActivityFile(process.execPath, ['-e', 'setInterval(() => undefined, 1_000)']),
+        );
+        const rejection = expect(execution).rejects.toMatchObject({ name: 'AbortError' });
+
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        testEnv.cancel();
+
+        await rejection;
+    });
+
+    it('should terminate the child process before the Activity StartToClose timeout', async () => {
+        const testEnv = new MockActivityEnvironment({
+            currentAttemptScheduledTimestampMs: Date.now(),
+            startToCloseTimeoutMs: 500,
+        });
+
+        const execution = testEnv.run(() =>
+            execActivityFile(process.execPath, ['-e', 'setInterval(() => undefined, 1_000)']),
+        );
+
+        await expect(execution).rejects.toMatchObject({ killed: true });
+    });
+});
+
+describe('createFfmpegProgressTracker', () => {
+    it('reports advancement only when a monotonic field increases', () => {
+        const tracker = createFfmpegProgressTracker();
+        expect(tracker.observe('frame=1 time=00:00:00.10\n')).toBe(true);
+        expect(tracker.observe('frame=2 time=00:00:00.20\n')).toBe(true);
+        // A wedged encoder re-emitting an identical status line must not be mistaken for progress (P1).
+        expect(tracker.observe('frame=2 time=00:00:00.20\n')).toBe(false);
+        expect(tracker.observe('frame=2 time=00:00:00.20\n')).toBe(false);
+    });
+
+    it('advances on time= for audio-only output with no frame= field', () => {
+        const tracker = createFfmpegProgressTracker();
+        expect(tracker.observe('size=1024kB time=00:00:01.00 bitrate=209.7kbits/s\n')).toBe(true);
+        expect(tracker.observe('size=1024kB time=00:00:01.00 bitrate=209.7kbits/s\n')).toBe(false);
+        expect(tracker.observe('size=2048kB time=00:00:02.00 bitrate=209.7kbits/s\n')).toBe(true);
+    });
+
+    it('recognizes a marker split across stream chunks (P2)', () => {
+        const tracker = createFfmpegProgressTracker();
+        // No delimiter yet: the partial record is buffered rather than parsed.
+        expect(tracker.observe('fra')).toBe(false);
+        // Reassembled to `frame=7` once the record completes.
+        expect(tracker.observe('me=7\n')).toBe(true);
+    });
+
+    it('treats carriage-return-delimited snapshots as complete records', () => {
+        const tracker = createFfmpegProgressTracker();
+        expect(tracker.observe('frame=1\rframe=2\r')).toBe(true);
+        expect(tracker.observe('frame=2\r')).toBe(false);
+    });
+});
+
+describe('execActivityFileWithProgress', () => {
+    const activityEnv = () =>
+        new MockActivityEnvironment({
+            currentAttemptScheduledTimestampMs: Date.now(),
+            startToCloseTimeoutMs: 60_000,
+        });
+
+    // Timing-based cases run with generous timeouts so shared-CI CPU contention cannot flake them. The stall window is
+    // kept far larger than the progress cadence so a delayed-but-alive child is never mistaken for a wedged one.
+    const TIMING_TEST_TIMEOUT_MS = 20_000;
+
+    it(
+        'captures output and resolves when the command completes',
+        async () => {
+            const result = (await activityEnv().run(() =>
+                execActivityFileWithProgress(process.execPath, [
+                    '-e',
+                    "process.stderr.write('frame=1\\n'); process.stdout.write('ok')",
+                ]),
+            )) as { stdout: string; stderr: string };
+
+            expect(result.stdout).toBe('ok');
+            expect(result.stderr).toContain('frame=1');
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'terminates a child that reports progress and then stops',
+        async () => {
+            const execution = activityEnv().run(() =>
+                execActivityFileWithProgress(
+                    process.execPath,
+                    ['-e', "process.stderr.write('frame=1\\n'); setInterval(() => undefined, 1_000)"],
+                    { stallTimeoutMs: 300 },
+                ),
+            );
+
+            await expect(execution).rejects.toMatchObject({ stalled: true, killed: true });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'terminates a child that keeps repeating the same progress line',
+        async () => {
+            // A wedged encoder that keeps flushing an identical status line must still be detected as stalled (P1).
+            const execution = activityEnv().run(() =>
+                execActivityFileWithProgress(
+                    process.execPath,
+                    ['-e', "setInterval(() => process.stderr.write('frame=1 time=00:00:01.00\\n'), 40)"],
+                    { stallTimeoutMs: 300 },
+                ),
+            );
+
+            await expect(execution).rejects.toMatchObject({ stalled: true, killed: true });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'keeps running while the child continues to report progress',
+        async () => {
+            // Emit progress every 100ms for ~500ms against a 2s stall window: a healthy child must never trip it, even
+            // if CI scheduling delays some ticks.
+            const script = [
+                'let n = 0;',
+                'const timer = setInterval(() => {',
+                '    process.stderr.write(`frame=${++n}\\n`);',
+                '    if (n >= 5) {',
+                '        clearInterval(timer);',
+                '        process.exit(0);',
+                '    }',
+                '}, 100);',
+            ].join('\n');
+
+            const result = (await activityEnv().run(() =>
+                execActivityFileWithProgress(process.execPath, ['-e', script], { stallTimeoutMs: 2_000 }),
+            )) as { stdout: string; stderr: string };
+
+            expect(result.stderr).toContain('frame=5');
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'rejects with the exit code when the command fails',
+        async () => {
+            const execution = activityEnv().run(() =>
+                execActivityFileWithProgress(process.execPath, ['-e', 'process.exit(3)']),
+            );
+
+            await expect(execution).rejects.toMatchObject({ code: 3, killed: false });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+
+    it(
+        'terminates a still-progressing child at the Activity start-to-close deadline',
+        async () => {
+            // The child keeps reporting advancing progress, so the stall watchdog never fires; the Activity deadline
+            // must still terminate it. This exercises a different path than execActivityFile — the spawn timeout, not
+            // execFile's timeout.
+            const deadlineEnv = new MockActivityEnvironment({
+                currentAttemptScheduledTimestampMs: Date.now(),
+                startToCloseTimeoutMs: 600,
+            });
+            const execution = deadlineEnv.run(() =>
+                execActivityFileWithProgress(
+                    process.execPath,
+                    ['-e', 'setInterval(() => process.stderr.write(`frame=${Date.now()}\\n`), 50)'],
+                    { stallTimeoutMs: 60_000 },
+                ),
+            );
+
+            await expect(execution).rejects.toMatchObject({ killed: true });
+        },
+        TIMING_TEST_TIMEOUT_MS,
+    );
+});