@vertesia/workflow 0.78.0 → 0.79.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "0.78.0",
+  "version": "0.79.0",
   "type": "module",
   "description": "Vertesia workflow DSL",
   "main": "./lib/esm/index.js",
@@ -49,11 +49,11 @@
     "tmp": "^0.2.3",
     "tmp-promise": "^3.0.3",
     "yaml": "^2.6.0",
-    "@vertesia/client": "0.78.0",
     "@llumiverse/common": "0.22.0",
-    "@vertesia/api-fetch-client": "0.78.0",
-    "@vertesia/common": "0.78.0",
-    "@vertesia/memory": "0.49.0"
+    "@vertesia/client": "0.79.0",
+    "@vertesia/api-fetch-client": "0.79.0",
+    "@vertesia/common": "0.79.0",
+    "@vertesia/memory": "0.50.0"
   },
   "ts_dual_module": {
     "outDir": "lib",
@@ -98,6 +98,11 @@
     },
     "./workflows-bundle": {
       "import": "./lib/workflows-bundle.js"
+    },
+    "./errors": {
+      "types": "./lib/types/errors.d.ts",
+      "import": "./lib/esm/errors.js",
+      "require": "./lib/cjs/errors.js"
     }
   },
   "types": "./lib/types/index.d.ts",
@@ -117,6 +122,9 @@
       ],
       "vars": [
         "./lib/types/dsl/vars.d.ts"
+      ],
+      "errors": [
+        "./lib/types/errors.d.ts"
       ]
     }
   },

package/src/activities/advanced/createDocumentTypeFromInteractionRun.ts

@@ -3,6 +3,7 @@ import { log } from "@temporalio/activity";
 import { projectResult } from "../../dsl/projections.js";
 import { setupActivity } from "../../dsl/setup/ActivityContext.js";
 import { ActivityParamNotFoundError } from "../../errors.js";
+import { parseCompletionResultsToJson } from "@llumiverse/common";
 
 
 export interface CreateDocumentTypeFromInteractionRunParams {
@@ -30,16 +31,18 @@ export async function createDocumentTypeFromInteractionRun(payload: DSLActivityE
 
     const genTypeRes = params.run.result;
 
-    if (!genTypeRes.document_type) {
+    const jsonResult = parseCompletionResultsToJson(params.run.result);
+
+    if (!jsonResult.document_type) {
         log.error("No name generated for type: " + JSON.stringify(genTypeRes), genTypeRes);
         throw new Error("No name generated for type");
     }
 
-    log.info("Generated schema for type", genTypeRes.metadata_schema);
+    log.info("Generated schema for type", jsonResult.metadata_schema);
     const typeData: CreateContentObjectTypePayload = {
-        name: genTypeRes.document_type,
-        object_schema: genTypeRes.metadata_schema,
-        is_chunkable: !!genTypeRes.is_chunkable,
+        name: jsonResult.document_type,
+        object_schema: jsonResult.metadata_schema,
+        is_chunkable: !!jsonResult.is_chunkable,
     }
 
     const type = await client.types.create(typeData);

package/src/activities/advanced/createOrUpdateDocumentFromInteractionRun.ts

@@ -2,6 +2,7 @@ import { log } from "@temporalio/activity";
 import { ContentObjectStatus, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
 import { setupActivity } from "../../dsl/setup/ActivityContext.js";
 import { ActivityParamNotFoundError, DocumentNotFoundError } from "../../errors.js";
+import { parseCompletionResultsToJson, completionResultToString } from "@llumiverse/common";
 
 interface CreateOrUpdateObjectFromInteractionRunParams {
     /**
@@ -68,28 +69,23 @@ export async function createOrUpdateDocumentFromInteractionRun(payload: DSLActiv
 
 
     const result = run.result;
-    const resultIsObject = typeof result === 'object';
+    const jsonResult = parseCompletionResultsToJson(run.result);
     const inputData = run.parameters;
 
-    let name: string;
-    if (resultIsObject) {
-        name = result['name'] || result["title"] || inputData['name'] || params.fallback_name || 'Untitled';
-    } else {
-        name = inputData['name'] || params.fallback_name || 'Untitled';
-    }
+    const name = jsonResult['name'] || jsonResult["title"] || inputData['name'] || params.fallback_name || 'Untitled';
 
     const docPayload = {
         name,
         parent: params.parent ?? undefined,
-        properties: resultIsObject ? result : {},
-        text: !resultIsObject ? result : undefined,
+        properties: jsonResult ? jsonResult : {},
+        text: !jsonResult ? result.map(completionResultToString).join('\n') : undefined,
         type: type?.id,
         status: ContentObjectStatus.completed,
         generation_run_info: {
             id: run.id,
             date: new Date().toISOString(),
             model: run.modelId,
-            target: resultIsObject ? 'properties' : 'text'
+            target: jsonResult ? 'properties' : 'text'
         }
     };
 

package/src/activities/advanced/updateDocumentFromInteractionRun.ts

@@ -1,6 +1,7 @@
 import { DSLActivityExecutionPayload, DSLActivitySpec, ExecutionRun } from "@vertesia/common";
 import { setupActivity } from "../../dsl/setup/ActivityContext.js";
 import { ActivityParamNotFoundError } from "../../errors.js";
+import { parseCompletionResultsToJson } from "@llumiverse/common";
 
 
 export interface UpdateDocumentFromInteractionRunParams {
@@ -28,7 +29,9 @@ export async function updateDocumentFromInteractionRun(payload: DSLActivityExecu
         return { status: "failed", error: "no-props" };
     }
 
-    await client.objects.update(objectId, docProps);
+    const jsonResult = parseCompletionResultsToJson(params.run.result);
+
+    await client.objects.update(objectId, jsonResult);
 
     return { status: "success" };
 }

package/src/activities/chunkDocument.ts

@@ -3,6 +3,7 @@ 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 { parseCompletionResultsToJson } from "@llumiverse/common";
 
 const INT_CHUNK_DOCUMENT = "sys:ChunkDocument"
 
@@ -82,7 +83,9 @@ export async function chunkDocument(payload: DSLActivityExecutionPayload<ChunkDo
         content: instrumented
     });
 
-    const parts = res.result.parts as DocPart[];
+    const jsonResult = parseCompletionResultsToJson(res.result);
+
+    const parts = jsonResult.parts as DocPart[];
     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" }

package/src/activities/executeInteraction.ts

@@ -13,7 +13,7 @@ import {
 } from "@vertesia/common";
 import { projectResult } from "../dsl/projections.js";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { ActivityParamInvalidError, ActivityParamNotFoundError } from "../errors.js";
+import { ActivityParamInvalidError, ActivityParamNotFoundError, ResourceExhaustedError } from "../errors.js";
 import { TruncateSpec, truncByMaxTokens } from "../utils/tokens.js";
 import { Readable } from "stream";
 
@@ -98,6 +98,11 @@ export interface InteractionExecutionParams {
      * Options to control generation
      */
     model_options?: ModelOptions;
+
+    /**
+     * activity won't be retried if it fails due to resource exhaustion (429)
+     */
+    exit_on_resource_exhaustion?: boolean;
 }
 
 /**
@@ -153,11 +158,11 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload<Ex
         
         // Handle image uploads if the result contains base64 images
         if (res.output_modality === Modalities.image) {
-            const images = res.result.images;
+            const images = res.result.filter((r: { type: string; }) => r.type === 'image');
             const uploadedImages = await Promise.all(
-                images.map((image: string, index: number) => {
+                images.map((image: { value: string; }, index: number) => {
                     // Extract base64 data and create buffer
-                    const base64Data = image.replace(/^data:image\/[a-z]+;base64,/, "");
+                    const base64Data = image.value.replace(/^data:image\/[a-z]+;base64,/, "");
                     const buffer = Buffer.from(base64Data, 'base64');
                     
                     // Generate filename
@@ -177,7 +182,7 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload<Ex
                     return client.files.uploadFile(source);
                 })
             );
-            res.result.images = uploadedImages;
+            res.result = uploadedImages.map(file => ({ type: "image", value: file }));
         }
 
         return projectResult(payload, params, res, {
@@ -187,15 +192,17 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload<Ex
         });
 
     } catch (error: any) {
-        log.error("Failed to execute interaction", { error });
-        if (error.message.includes("Failed to validate merged prompt schema")) {
+        log.error(`Failed to execute interaction ${interactionName}`, { error });
+        if (error.statusCode === 429 && params.exit_on_resource_exhaustion) {
+            throw new ResourceExhaustedError(error.statusCode, "Resource exhausted - rate limit exceeded");
+        } else if (error.message.includes("Failed to validate merged prompt schema")) {
             //issue with the input data, don't retry
             throw new ActivityParamInvalidError("prompt_data", payload.activity, error.message);
         } else if (error.message.includes("modelId: Path `modelId` is required")) {
             //issue with the input data, don't retry
             throw new ActivityParamInvalidError("model", payload.activity, error.message);
         } else {
-            throw error;
+            throw new Error(`Interaction Execution failed ${interactionName}: ${error.message}`);
         }
     }
 }
@@ -270,7 +277,7 @@ export async function executeInteractionFromActivity(
         })
         .catch((err) => {
             log.error(`Error executing interaction ${interactionName}`, { err });
-            throw new Error(`Interaction Execution failed ${interactionName}: ${err.message}`);
+            throw err;
         });
 
     if (debug) {

package/src/activities/generateDocumentProperties.ts

@@ -1,8 +1,9 @@
 import { log } from "@temporalio/activity";
 import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { TruncateSpec } from "../utils/tokens.js";
+import { TruncateSpec, truncByMaxTokens } from "../utils/tokens.js";
 import { InteractionExecutionParams, executeInteractionFromActivity } from "./executeInteraction.js";
+import { parseCompletionResultsToJson } from "@llumiverse/common";
 
 const INT_EXTRACT_INFORMATION = "sys:ExtractInformation";
 export interface GenerateDocumentPropertiesParams extends InteractionExecutionParams {
@@ -55,8 +56,12 @@ export async function generateDocumentProperties(
         return undefined;
     };
 
+    const content = doc.text
+        ? truncByMaxTokens(doc.text, params.truncate || 30000)
+        : undefined;
+
     const promptData = {
-        content: doc.text ?? undefined,
+        content: content,
         image: getImageRef() ?? undefined,
         human_context: project?.configuration?.human_context ?? undefined,
     };
@@ -84,11 +89,12 @@ export async function generateDocumentProperties(
             return undefined;
         }
         let text = "";
-        if (infoRes.result.title) {
-            text += infoRes.result.title + "\n";
+        const jsonResult = parseCompletionResultsToJson(infoRes.result);
+        if (jsonResult.title) {
+            text += jsonResult.title + "\n";
         }
-        if (infoRes.result.description) {
-            text += infoRes.result.description;
+        if (jsonResult.description) {
+            text += jsonResult.description;
         }
         if (text) {
             return text;
@@ -100,7 +106,7 @@ 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,
+            ...parseCompletionResultsToJson(infoRes.result),
             etag: doc.text_etag,
         },
         text: getText(),

package/src/activities/generateOrAssignContentType.ts

@@ -15,6 +15,7 @@ import {
   InteractionExecutionParams,
   executeInteractionFromActivity,
 } from "./executeInteraction.js";
+import { parseCompletionResultsToJson } from "@llumiverse/common";
 
 const INT_SELECT_DOCUMENT_TYPE = "sys:SelectDocumentType";
 const INT_GENERATE_METADATA_MODEL = "sys:GenerateMetadataModel";
@@ -119,7 +120,7 @@ export async function generateOrAssignContentType(
 
   log.info(
     "Execute SelectDocumentType interaction on content with \nexisting types - passing full types: " +
-      existing_types.filter((t) => !t.tags?.includes("system")),
+    existing_types.filter((t) => !t.tags?.includes("system")),
   );
 
   const res = await executeInteractionFromActivity(
@@ -133,12 +134,15 @@ export async function generateOrAssignContentType(
     },
   );
 
-  log.info("Selected Content Type Result: " + JSON.stringify(res.result));
+  const jsonResult = parseCompletionResultsToJson(res.result);
+
+  log.info("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 = undefined;
 
-  selectedType = types.find((t) => t.name === res.result.document_type);
+  selectedType = types.find((t) => t.name === jsonResult.document_type);
 
   if (!selectedType) {
     log.warn("Document type not identified: starting type generation");
@@ -153,7 +157,7 @@ export async function generateOrAssignContentType(
 
   if (!selectedType) {
     log.error("Type not found: ", res.result);
-    throw new Error("Type not found: " + res.result.document_type);
+    throw new Error("Type not found: " + jsonResult.document_type);
   }
 
   //update object with selected type
@@ -193,18 +197,20 @@ async function generateNewType(
     },
   );
 
-  if (!genTypeRes.result.document_type) {
+  const jsonResult = parseCompletionResultsToJson(genTypeRes.result);
+
+  if (!jsonResult.document_type) {
     log.error("No name generated for type", genTypeRes);
     throw new Error("No name generated for type");
   }
 
-  log.info("Generated schema for type", genTypeRes.result.metadata_schema);
+  log.info("Generated schema for type", jsonResult.metadata_schema);
   const typeData: CreateContentObjectTypePayload = {
-    name: genTypeRes.result.document_type,
-    description: genTypeRes.result.document_type_description,
-    object_schema: genTypeRes.result.metadata_schema,
-    is_chunkable: genTypeRes.result.is_chunkable,
-    table_layout: genTypeRes.result.table_layout,
+    name: jsonResult.document_type,
+    description: jsonResult.document_type_description,
+    object_schema: jsonResult.metadata_schema,
+    is_chunkable: jsonResult.is_chunkable,
+    table_layout: jsonResult.table_layout,
   };
 
   const type = await client.types.create(typeData);

package/src/activities/index-dsl.ts

@@ -17,4 +17,4 @@ export { convertPdfToStructuredText } from "./media/processPdfWithTextract.js";
 export { transcribeMedia } from "./media/transcribeMediaWithGladia.js";
 export { notifyWebhook } from "./notifyWebhook.js";
 export { setDocumentStatus } from "./setDocumentStatus.js";
-export { identifyTextSections } from "./identifyTextSections.js";
+export { checkRateLimit } from "./rateLimiter.js";

package/src/activities/notifyWebhook.test.ts

@@ -1,32 +1,134 @@
 import {
   MockActivityEnvironment,
-  TestWorkflowEnvironment,
 } from "@temporalio/testing";
-import { beforeAll, describe, expect, test } from "vitest";
-import { notifyWebhook, NotifyWebhook } from "./notifyWebhook.js";
+import { ContentEventName, DSLActivityExecutionPayload } from "@vertesia/common";
+import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import { notifyWebhook, NotifyWebhookParams } from "./notifyWebhook.js";
 
-let testEnv: TestWorkflowEnvironment;
-let activityContext: MockActivityEnvironment;
+// Mock fetch globally
+vi.stubGlobal('fetch', vi.fn());
+
+let testEnv: MockActivityEnvironment;
+const mockFetch = vi.mocked(fetch);
 
 beforeAll(async () => {
-  testEnv = await TestWorkflowEnvironment.createLocal();
-  activityContext = new MockActivityEnvironment();
+  testEnv = new MockActivityEnvironment();
+});
+
+beforeEach(() => {
+  vi.clearAllMocks();
 });
 
-// https://github.com/becomposable/studio/issues/432 Skip tests
-// Cannot read properties of undefined (reading 'params')
+const defaultParams = {
+  webhook: "https://vertesia.test",
+  method: "POST" as const,
+  detail: { message: "Hello World" },
+  workflow_id: "wf_id",
+  workflow_type: "wfFuncName",
+  workflow_run_id: "wf_run_id",
+  event_name: "completed",
+} satisfies NotifyWebhookParams;
+
+// Helper function to create test payload
+const createTestPayload = (params: Partial<NotifyWebhookParams> = {}): DSLActivityExecutionPayload<NotifyWebhookParams> => {
+  const mergedParams = { ...defaultParams, ...params };
+  return {
+    auth_token: "unset",
+    account_id: "unset",
+    project_id: "unset",
+    params: mergedParams,
+    config: {
+      studio_url: "http://mock-studio",
+      store_url: "http://mock-store",
+    },
+    workflow_name: "",
+    event: ContentEventName.create,
+    objectIds: [],
+    vars: {},
+    activity: { name: "notifyWebhook", params: mergedParams }
+  };
+};
+
 describe("Webhook should be notified", () => {
-  test.skip("test POST", async () => {
-    const activityConfig = {
-      name: "notifyWebhook",
-      params: {
-        target_url: "https://en5zdcyvn4dc3.x.pipedream.net",
-        method: "POST",
-        payload: { message: "Hello World" },
+  it("test POST success", async () => {
+    // Mock successful response
+    const mockResponse = {
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      url: defaultParams.webhook
+    };
+    mockFetch.mockResolvedValueOnce(mockResponse as Response);
+
+    const payload = createTestPayload();
+    const res = await testEnv.run(notifyWebhook, payload);
+
+    // Verify fetch was called with correct parameters
+    expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello World' }),
+      headers: {
+        'Content-Type': 'application/json',
       },
-    } satisfies NotifyWebhook;
+    });
 
-    const res = await activityContext.run(notifyWebhook, activityConfig);
-    expect(res).toBeDefined();
+    // Verify response
+    expect(res).toEqual({
+      status: 200,
+      message: 'OK',
+      url: defaultParams.webhook
+    });
   });
+
+  it("test POST server error", async () => {
+    // Mock error response with response body
+    const mockResponse = {
+      ok: false,
+      status: 500,
+      statusText: 'Internal Server Error',
+      url: defaultParams.webhook,
+      text: vi.fn().mockResolvedValue('{"error": "Database connection failed", "code": "DB_ERROR"}')
+    } as unknown as Response;
+    mockFetch.mockResolvedValueOnce(mockResponse);
+
+    const payload = createTestPayload();
+
+    // Expect the function to throw an error with response payload
+    await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow(
+      `Webhook Notification to ${defaultParams.webhook} failed with status: 500 Internal Server Error - Response: {"error": "Database connection failed", "code": "DB_ERROR"}`
+    );
+
+    // Verify fetch was called with correct parameters
+    expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello World' }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+
+    // Verify that text() was called to read the response
+    expect(mockResponse.text).toHaveBeenCalled();
+  });
+
+  it("test POST network error", async () => {
+    // Mock fetch to throw a network error
+    const networkError = new Error('Network request failed');
+    mockFetch.mockRejectedValueOnce(networkError);
+
+    const payload = createTestPayload();
+
+    // Expect the function to throw the network error
+    await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow('Network request failed');
+
+    // Verify fetch was called with correct parameters
+    expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+      method: 'POST',
+      body: JSON.stringify({ message: 'Hello World' }),
+      headers: {
+        'Content-Type': 'application/json',
+      },
+    });
+  });
+
 });