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

package/src/activities/executeRemoteActivity.ts

@@ -1,11 +1,11 @@
-import { ApplicationFailure, log } from "@temporalio/activity";
-import {
+import { ApplicationFailure, log } from '@temporalio/activity';
+import type {
     DSLActivityExecutionPayload,
     RemoteActivityExecutionPayload,
     RemoteActivityExecutionResponse,
-} from "@vertesia/common";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { URLValidationError, safeFetch } from "../security/ssrf.js";
+} from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { safeFetch, URLValidationError } from '../security/ssrf.js';
 
 /**
  * Parameters for the executeRemoteActivity bridge activity.
@@ -16,13 +16,13 @@ export interface ExecuteRemoteActivityParams {
     /** The activity name (unprefixed, as known by the tool server) */
     activity_name: string;
     /** The resolved parameters for the activity */
-    params: Record<string, any>;
+    params: Record<string, unknown>;
     /** App installation ID */
     app_install_id: string;
     /** App name */
     app_name: string;
     /** App installation settings */
-    app_settings?: Record<string, any>;
+    app_settings?: Record<string, unknown>;
 }
 
 /**
@@ -38,7 +38,7 @@ export interface ExecuteRemoteActivityParams {
  */
 export async function executeRemoteActivity(
     payload: DSLActivityExecutionPayload<ExecuteRemoteActivityParams>,
-): Promise<any> {
+): Promise<unknown> {
     const ctx = await setupActivity<ExecuteRemoteActivityParams>(payload);
     const { params, runId, client } = ctx;
     const { url, activity_name, params: activityParams, app_install_id, app_settings } = params;
@@ -47,7 +47,11 @@ export async function executeRemoteActivity(
     try {
         await client.apps.validateUrl(url);
     } catch (e) {
-        log.warn("URL validation blocked remote activity endpoint", { activity: activity_name, url, error: (e as Error).message });
+        log.warn('URL validation blocked remote activity endpoint', {
+            activity: activity_name,
+            url,
+            error: (e as Error).message,
+        });
         throw ApplicationFailure.create({
             message: `Remote activity ${activity_name} blocked: ${(e as Error).message}`,
             nonRetryable: true,
@@ -61,38 +65,50 @@ export async function executeRemoteActivity(
             run_id: runId,
             app_install_id,
             app_settings,
-            endpoints: payload.config ? {
-                studio: payload.config.studio_url,
-                store: payload.config.store_url,
-            } : undefined,
+            endpoints: payload.config
+                ? {
+                      studio: payload.config.studio_url,
+                      store: payload.config.store_url,
+                  }
+                : undefined,
         },
     };
 
     let response: Response;
     try {
         response = await safeFetch(url, {
-            method: "POST",
+            method: 'POST',
             headers: {
-                "Content-Type": "application/json",
-                "Accept": "application/json",
-                "Authorization": `Bearer ${payload.auth_token}`,
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                Authorization: `Bearer ${payload.auth_token}`,
             },
             body: JSON.stringify(executionPayload),
         });
     } catch (err: unknown) {
         if (err instanceof URLValidationError) {
-            log.warn("Redirect blocked on remote activity endpoint", { activity: activity_name, url, error: err.message });
+            log.warn('Redirect blocked on remote activity endpoint', {
+                activity: activity_name,
+                url,
+                error: err.message,
+            });
             throw ApplicationFailure.create({
                 message: `Remote activity ${activity_name} blocked: ${err.message}`,
                 nonRetryable: true,
             });
         }
         const message = err instanceof Error ? err.message : String(err);
-        log.warn("Failed to reach remote activity endpoint", {
-            error: message, activity: activity_name, endpoint: url, runId, app_install_id,
+        log.warn('Failed to reach remote activity endpoint', {
+            error: message,
+            activity: activity_name,
+            endpoint: url,
+            runId,
+            app_install_id,
         });
         // Network-level failure — let Temporal retry
-        throw new Error(`Failed to reach remote activity endpoint (activity: ${activity_name}, endpoint: ${url}): ${message}`);
+        throw new Error(
+            `Failed to reach remote activity endpoint (activity: ${activity_name}, endpoint: ${url}): ${message}`,
+        );
     }
 
     const responseText = await response.text();
@@ -107,8 +123,12 @@ export async function executeRemoteActivity(
         } catch {
             // Not JSON — use the status line
         }
-        log.warn("Remote activity returned HTTP error", {
-            activity: activity_name, endpoint: url, status: response.status, runId, app_install_id,
+        log.warn('Remote activity returned HTTP error', {
+            activity: activity_name,
+            endpoint: url,
+            status: response.status,
+            runId,
+            app_install_id,
             responsePreview: responseText.slice(0, 500),
         });
         const msg = `Remote activity ${activity_name} failed: ${errorMessage}`;
@@ -126,10 +146,13 @@ export async function executeRemoteActivity(
     let responseJson: RemoteActivityExecutionResponse;
     try {
         responseJson = JSON.parse(responseText);
-    } catch (err: unknown) {
-        const preview = responseText.length > 200 ? responseText.slice(0, 200) + '...' : responseText;
-        log.warn("Invalid JSON response from remote activity", {
-            activity: activity_name, endpoint: url, runId, app_install_id,
+    } catch {
+        const preview = responseText.length > 200 ? `${responseText.slice(0, 200)}...` : responseText;
+        log.warn('Invalid JSON response from remote activity', {
+            activity: activity_name,
+            endpoint: url,
+            runId,
+            app_install_id,
             responsePreview: preview,
         });
         throw ApplicationFailure.create({
@@ -139,8 +162,12 @@ export async function executeRemoteActivity(
     }
 
     if (responseJson.is_error) {
-        log.warn("Remote activity returned error", {
-            activity: activity_name, endpoint: url, error: responseJson.error, runId, app_install_id,
+        log.warn('Remote activity returned error', {
+            activity: activity_name,
+            endpoint: url,
+            error: responseJson.error,
+            runId,
+            app_install_id,
         });
         throw ApplicationFailure.create({
             message: `Remote activity ${activity_name}: ${responseJson.error}`,

package/src/activities/extractDocumentText.ts

@@ -1,34 +1,32 @@
-import { log } from "@temporalio/activity";
-import {
+import { log } from '@temporalio/activity';
+import type { VertesiaClient } from '@vertesia/client';
+import type {
     ContentObject,
     CreateContentObjectPayload,
     DSLActivityExecutionPayload,
     DSLActivitySpec,
     WorkflowInputFile,
-} from "@vertesia/common";
-import { markdownWithMarkitdown } from "../conversion/markitdown.js";
-import { mutoolPdfToText } from "../conversion/mutool.js";
-import { markdownWithPandoc } from "../conversion/pandoc.js";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { DocumentNotFoundError } from "../errors.js";
-import { TextExtractionResult, TextExtractionStatus } from "../result-types.js";
-import { fetchBlobAsBuffer, md5 } from "../utils/blobs.js";
-import {
-    createFileSourceResult,
-    uploadTextPreviewToStorage
-} from "../utils/text-preview-utils.js";
-import { countTokens } from "../utils/tokens.js";
-
-//@ts-ignore
-const JSON: DSLActivitySpec = {
-    name: "extractDocumentText",
+} from '@vertesia/common';
+import { markdownWithMarkitdown } from '../conversion/markitdown.js';
+import { mutoolPdfToText } from '../conversion/mutool.js';
+import { markdownWithPandoc } from '../conversion/pandoc.js';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { DocumentNotFoundError } from '../errors.js';
+import { type TextExtractionResult, TextExtractionStatus } from '../result-types.js';
+import { fetchBlobAsBuffer, md5 } from '../utils/blobs.js';
+import { createFileSourceResult, uploadTextPreviewToStorage } from '../utils/text-preview-utils.js';
+import { countTokens } from '../utils/tokens.js';
+
+//@ts-expect-error
+const _JSON: DSLActivitySpec = {
+    name: 'extractDocumentText',
 };
 
 export interface ExtractDocumentTextParams {
     output_storage_path?: string;
 }
 export interface ExtractDocumentText extends DSLActivitySpec<ExtractDocumentTextParams> {
-    name: "extractDocumentText";
+    name: 'extractDocumentText';
     projection?: never;
 }
 
@@ -52,16 +50,28 @@ export async function extractDocumentText(
 }
 
 async function extractFromObject(
-    client: any,
+    client: VertesiaClient,
     objectId: string,
     objectIds: string[],
 ): Promise<TextExtractionResult> {
-    const r = await client.objects.find({
-        query: { _id: objectId },
-        limit: 1,
-        select: "+text",
-    });
-    const doc = r[0] as ContentObject;
+    // Fetch the exact revision by id rather than `find({_id, revision.head:true})`.
+    // `find` filters to HEAD revisions, so if a newer revision is created while this
+    // intake is in flight (e.g. an update with `createRevision: true`), the original
+    // revision this workflow was queued for becomes non-head and `find` returns empty —
+    // failing intake with a spurious "not found" even though the revision still exists.
+    // A direct GET by id resolves the specific revision regardless of head.
+    let doc: ContentObject;
+    try {
+        doc = (await client.objects.retrieve(objectId, '+text')) as ContentObject;
+    } catch (err: unknown) {
+        const status =
+            err && typeof err === 'object' && 'status' in err ? (err as { status?: number }).status : undefined;
+        if (status === 404) {
+            log.error(`Document ${objectId} not found`);
+            throw new DocumentNotFoundError(`Document ${objectId} not found`, objectIds);
+        }
+        throw err;
+    }
     if (!doc) {
         log.error(`Document ${objectId} not found`);
         throw new DocumentNotFoundError(`Document ${objectId} not found`, objectIds);
@@ -71,30 +81,31 @@ async function extractFromObject(
 
     if (!doc.content?.type || !doc.content?.source) {
         if (doc.text) {
-            return createResponse(doc, doc.text, TextExtractionStatus.skipped, "Text present and no source or type");
+            return createResponse(doc, doc.text, TextExtractionStatus.skipped, 'Text present and no source or type');
         } else {
-            return createResponse(doc, "", TextExtractionStatus.error, "No source or type found");
+            return createResponse(doc, '', TextExtractionStatus.error, 'No source or type found');
         }
     }
 
     //skip if text already extracted and proper etag
     if (doc.text && doc.text.length > 0 && doc.text_etag === doc.content.etag) {
-        return createResponse(doc, doc.text, TextExtractionStatus.skipped, "Text already extracted");
+        return createResponse(doc, doc.text, TextExtractionStatus.skipped, 'Text already extracted');
     }
 
     let fileBuffer: Buffer;
     try {
         fileBuffer = await fetchBlobAsBuffer(client, doc.content.source);
-    } catch (e: any) {
+    } catch (e: unknown) {
+        const message = e instanceof Error ? e.message : String(e);
         log.error(`Error reading file: ${e}`);
-        return createResponse(doc, "", TextExtractionStatus.error, e.message);
+        return createResponse(doc, '', TextExtractionStatus.error, message);
     }
 
     const txt = await extractTextFromBuffer(fileBuffer, doc.content.type);
     if (!txt) {
         return createResponse(
             doc,
-            doc.text ?? "",
+            doc.text ?? '',
             TextExtractionStatus.skipped,
             `Unsupported mime type: ${doc.content.type}`,
         );
@@ -118,16 +129,16 @@ async function extractFromObject(
 }
 
 async function extractFromFileSource(
-    client: any,
+    client: VertesiaClient,
     input_file: WorkflowInputFile,
-    output_storage_path: string
+    output_storage_path: string,
 ): Promise<TextExtractionResult> {
     log.info(`Extracting text from ${input_file}`);
 
     let fileBuffer: Buffer;
     try {
         fileBuffer = await fetchBlobAsBuffer(client, input_file.url);
-    } catch (e: any) {
+    } catch (e: unknown) {
         log.error(`Error reading file: ${e}`);
         return createFileSourceResult(input_file.url, output_storage_path, null);
     }
@@ -136,7 +147,7 @@ async function extractFromFileSource(
 
     // Upload extracted text to storage
     if (txt && output_storage_path) {
-        await uploadTextPreviewToStorage(client, txt, output_storage_path, "Document");
+        await uploadTextPreviewToStorage(client, txt, output_storage_path, 'Document');
     }
 
     return createFileSourceResult(input_file.url, output_storage_path, txt);
@@ -146,67 +157,67 @@ async function extractTextFromBuffer(fileBuffer: Buffer, mimeType: string): Prom
     let txt: string;
 
     switch (mimeType) {
-        case "application/pdf":
+        case 'application/pdf':
             txt = await mutoolPdfToText(fileBuffer);
             break;
 
-        case "text/plain":
-            txt = fileBuffer.toString("utf8");
+        case 'text/plain':
+            txt = fileBuffer.toString('utf8');
             break;
 
         //docx
-        case "application/vnd.openxmlformats-officedocument.wordprocessingml.document":
-            txt = await markdownWithMarkitdown(fileBuffer, "docx");
+        case 'application/vnd.openxmlformats-officedocument.wordprocessingml.document':
+            txt = await markdownWithMarkitdown(fileBuffer, 'docx');
             break;
 
         //pptx
-        case "application/vnd.openxmlformats-officedocument.presentationml.presentation":
-            txt = await markdownWithMarkitdown(fileBuffer, "pptx");
+        case 'application/vnd.openxmlformats-officedocument.presentationml.presentation':
+            txt = await markdownWithMarkitdown(fileBuffer, 'pptx');
             break;
 
         //html
-        case "text/html":
-            txt = await markdownWithPandoc(fileBuffer, "html");
+        case 'text/html':
+            txt = await markdownWithPandoc(fileBuffer, 'html');
             break;
 
         //opendocument
-        case "application/vnd.oasis.opendocument.text":
-            txt = await markdownWithPandoc(fileBuffer, "odt");
+        case 'application/vnd.oasis.opendocument.text':
+            txt = await markdownWithPandoc(fileBuffer, 'odt');
             break;
 
         //rtf
-        case "application/rtf":
-            txt = await markdownWithPandoc(fileBuffer, "rtf");
+        case 'application/rtf':
+            txt = await markdownWithPandoc(fileBuffer, 'rtf');
             break;
 
         //markdown
-        case "text/markdown":
-            txt = fileBuffer.toString("utf8");
+        case 'text/markdown':
+            txt = fileBuffer.toString('utf8');
             break;
 
         //csv
-        case "text/csv":
-            txt = fileBuffer.toString("utf8");
+        case 'text/csv':
+            txt = fileBuffer.toString('utf8');
             break;
 
         //typescript
-        case "application/typescript":
-            txt = fileBuffer.toString("utf8");
+        case 'application/typescript':
+            txt = fileBuffer.toString('utf8');
             break;
 
         //javascript
-        case "application/javascript":
-            txt = fileBuffer.toString("utf8");
+        case 'application/javascript':
+            txt = fileBuffer.toString('utf8');
             break;
 
         //json
-        case "application/json":
-            txt = fileBuffer.toString("utf8");
+        case 'application/json':
+            txt = fileBuffer.toString('utf8');
             break;
 
         default:
             if (sniffIfText(fileBuffer)) {
-                txt = fileBuffer.toString("utf8"); //TODO: add charset detection
+                txt = fileBuffer.toString('utf8'); //TODO: add charset detection
                 break;
             }
             return null;
@@ -256,9 +267,9 @@ function sniffIfText(buf: Buffer) {
 
     // Additional check for valid UTF-8 encoding
     try {
-        const s = buf.toString("utf8");
-        return s.length > 0 && !s.includes("\uFFFD"); // Replacement character
-    } catch (e) {
+        const s = buf.toString('utf8');
+        return s.length > 0 && !s.includes('\uFFFD'); // Replacement character
+    } catch {
         return false;
     }
 }

package/src/activities/generateDocumentProperties.ts

@@ -1,10 +1,27 @@
-import { ApplicationFailure, log } from "@temporalio/activity";
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { TruncateSpec, truncByMaxTokens } from "../utils/tokens.js";
-import { InteractionExecutionParams, executeInteractionFromActivity } from "./executeInteraction.js";
+import { ApplicationFailure, log } from '@temporalio/activity';
+import type { DSLActivityExecutionPayload, DSLActivitySpec, JSONObject } from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { type TruncateSpec, truncByMaxTokens } from '../utils/tokens.js';
+import { executeInteractionFromActivity, type InteractionExecutionParams } from './executeInteraction.js';
+
+const INT_EXTRACT_INFORMATION = 'sys:ExtractInformation';
+
+interface RetryableError extends Error {
+    retryable?: boolean;
+}
+
+interface GeneratedPropertiesSummary {
+    title?: unknown;
+    description?: unknown;
+}
+
+function toRetryableError(error: unknown): RetryableError {
+    if (error instanceof Error) {
+        return error as RetryableError;
+    }
+    return new Error(String(error)) as RetryableError;
+}
 
-const INT_EXTRACT_INFORMATION = "sys:ExtractInformation";
 export interface GenerateDocumentPropertiesParams extends InteractionExecutionParams {
     typesHint?: string[];
     /**
@@ -17,7 +34,7 @@ export interface GenerateDocumentPropertiesParams extends InteractionExecutionPa
     use_vision?: boolean;
 }
 export interface GenerateDocumentProperties extends DSLActivitySpec<GenerateDocumentPropertiesParams> {
-    name: "generateDocumentProperties";
+    name: 'generateDocumentProperties';
 }
 
 export async function generateDocumentProperties(
@@ -29,37 +46,33 @@ export async function generateDocumentProperties(
 
     const project = await context.fetchProject();
 
-    const doc = await client.objects.retrieve(objectId, "+text");
-    const type = doc.type
-        ? await client.types.catalog.resolve(doc.type)
-        : undefined;
+    const doc = await client.objects.retrieve(objectId, '+text');
+    const type = doc.type ? await client.types.catalog.resolve(doc.type) : undefined;
 
-    if (!doc?.text && !params.use_vision && !doc?.content?.type?.startsWith("image/")) {
+    if (!doc?.text && !params.use_vision && !doc?.content?.type?.startsWith('image/')) {
         log.warn(`Object ${objectId} not found or text is empty`);
-        return { status: "failed", error: "no-text" };
+        return { status: 'failed', error: 'no-text' };
     }
 
-    if (!type || !type.object_schema) {
+    if (!type?.object_schema) {
         log.info(`Object ${objectId} has no schema`);
-        return { document: objectId, status: "skipped", message: "no schema defined on type" };
+        return { document: objectId, status: 'skipped', message: 'no schema defined on type' };
     }
 
     const getImageRef = () => {
-        if (doc.content?.type?.startsWith("image/")) {
-            return "store:" + doc.id;
+        if (doc.content?.type?.startsWith('image/')) {
+            return `store:${doc.id}`;
         }
 
-        if (params.use_vision && doc.content?.type?.startsWith("application/pdf")) {
-            return "store:" + doc.id;
+        if (params.use_vision && doc.content?.type?.startsWith('application/pdf')) {
+            return `store:${doc.id}`;
         }
 
         log.info(`Object ${objectId} is not an image or pdf`);
         return undefined;
     };
 
-    const content = doc.text
-        ? truncByMaxTokens(doc.text, params.truncate || 30000)
-        : undefined;
+    const content = doc.text ? truncByMaxTokens(doc.text, params.truncate || 30000) : undefined;
 
     const promptData = {
         content: content,
@@ -72,7 +85,7 @@ export async function generateDocumentProperties(
         payload.debug_mode ? { params } : undefined,
     );
 
-    let infoRes;
+    let infoRes: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
     try {
         infoRes = await executeInteractionFromActivity(
             client,
@@ -86,27 +99,29 @@ export async function generateDocumentProperties(
             promptData,
             payload.debug_mode ?? false,
         );
-    } catch (error: any) {
-        log.error(`Failed to extract document properties for ${objectId}`, { error, retryable: error.retryable });
-        
-        const isRetryable = error.retryable !== undefined 
-            ? error.retryable !== false
-            : undefined;
-        
+    } catch (error: unknown) {
+        const extractionError = toRetryableError(error);
+        log.error(`Failed to extract document properties for ${objectId}`, {
+            error: extractionError,
+            retryable: extractionError.retryable,
+        });
+
+        const isRetryable = extractionError.retryable !== undefined ? extractionError.retryable !== false : undefined;
+
         if (isRetryable !== undefined) {
             if (isRetryable) {
                 throw ApplicationFailure.create({
-                    message: `Document property extraction failed for ${objectId}: ${error.message}`,
+                    message: `Document property extraction failed for ${objectId}: ${extractionError.message}`,
                     nonRetryable: false,
                 });
             } else {
                 throw ApplicationFailure.create({
-                    message: `Non-retryable document property extraction failed for ${objectId}: ${error.message}`,
+                    message: `Non-retryable document property extraction failed for ${objectId}: ${extractionError.message}`,
                     nonRetryable: true,
                 });
             }
         }
-        
+
         throw error;
     }
 
@@ -114,12 +129,12 @@ export async function generateDocumentProperties(
         if (doc.text) {
             return undefined;
         }
-        let text = "";
-        const jsonResult = infoRes.result.object();
-        if (jsonResult.title) {
-            text += jsonResult.title + "\n";
+        let text = '';
+        const jsonResult = infoRes.result.object<GeneratedPropertiesSummary>();
+        if (typeof jsonResult.title === 'string') {
+            text += `${jsonResult.title}\n`;
         }
-        if (jsonResult.description) {
+        if (typeof jsonResult.description === 'string') {
             text += jsonResult.description;
         }
         if (text) {
@@ -130,18 +145,22 @@ export async function generateDocumentProperties(
     };
 
     log.info(`Extracted information from object ${objectId} with type ${type.name}`, { runId: infoRes.id });
-    await client.objects.update(doc.id, {
-        properties: {
-            ...infoRes.result.object(),
-            etag: doc.text_etag,
-        },
-        text: getText(),
-        generation_run_info: {
-            id: infoRes.id,
-            date: new Date().toISOString(),
-            model: infoRes.modelId ?? "",
+    await client.objects.update(
+        doc.id,
+        {
+            properties: {
+                ...infoRes.result.object<JSONObject>(),
+                ...(doc.text_etag !== undefined ? { etag: doc.text_etag } : {}),
+            },
+            text: getText(),
+            generation_run_info: {
+                id: infoRes.id,
+                date: new Date().toISOString(),
+                model: infoRes.modelId ?? '',
+            },
         },
-    }, { suppressWorkflows: true });
+        { suppressWorkflows: true },
+    );
 
-    return { status: "completed" };
+    return { status: 'completed' };
 }