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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "1.5.0-dev.20260714.072725Z",
+  "version": "1.5.0-dev.20260717.131047Z",
   "type": "module",
   "description": "Vertesia workflow DSL",
   "main": "./lib/index.js",
@@ -14,10 +14,10 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@smithy/types": "^4.15.0",
-    "@temporalio/proto": "^1.19.0",
-    "@temporalio/testing": "^1.19.0",
-    "@temporalio/worker": "^1.19.0",
+    "@smithy/types": "^4.15.1",
+    "@temporalio/proto": "^1.20.2",
+    "@temporalio/testing": "^1.20.2",
+    "@temporalio/worker": "^1.20.2",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.13.2",
     "@types/papaparse": "^5.5.2",
@@ -27,11 +27,11 @@
     "@vertesia/tsconfig": "0.1.0"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.1078.0",
-    "@aws-sdk/client-textract": "^3.1078.0",
-    "@aws-sdk/credential-providers": "^3.1078.0",
-    "@temporalio/activity": "^1.19.0",
-    "@temporalio/workflow": "^1.19.0",
+    "@aws-sdk/client-s3": "^3.1083.0",
+    "@aws-sdk/client-textract": "^3.1083.0",
+    "@aws-sdk/credential-providers": "^3.1081.0",
+    "@temporalio/activity": "^1.20.2",
+    "@temporalio/workflow": "^1.20.2",
     "fast-deep-equal": "^3.1.3",
     "jsonwebtoken": "^9.0.3",
     "mime": "^4.1.0",
@@ -47,9 +47,9 @@
     "undici": "^7.28.0",
     "yaml": "^2.9.0",
     "@llumiverse/common": "1.5.0-dev.20260713.114357Z",
-    "@vertesia/api-fetch-client": "1.5.0-dev.20260714.072725Z",
-    "@vertesia/common": "1.5.0-dev.20260714.072725Z",
-    "@vertesia/client": "1.5.0-dev.20260714.072725Z"
+    "@vertesia/client": "1.5.0-dev.20260717.131047Z",
+    "@vertesia/api-fetch-client": "1.5.0-dev.20260717.131047Z",
+    "@vertesia/common": "1.5.0-dev.20260717.131047Z"
   },
   "exports": {
     ".": {
@@ -103,6 +103,7 @@
     "agents",
     "typescript"
   ],
+  "gitHead": "8aaad228827b2927db8e6aa75b27bfac90fec36f",
   "scripts": {
     "lint": "biome lint src",
     "test": "vitest run",

package/src/activities/generateEmbeddings.test.ts

@@ -0,0 +1,114 @@
+import { MockActivityEnvironment } from '@temporalio/testing';
+import type { VertesiaClient } from '@vertesia/client';
+import {
+    ContentEventName,
+    type ContentObject,
+    type DSLActivityExecutionPayload,
+    SupportedEmbeddingTypes,
+} from '@vertesia/common';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ActivityContext } from '../dsl/setup/ActivityContext.js';
+import { type GenerateEmbeddingsParams, generateEmbeddings } from './generateEmbeddings.js';
+
+vi.mock('../dsl/setup/ActivityContext.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('../dsl/setup/ActivityContext.js')>();
+    return { ...actual, setupActivity: vi.fn() };
+});
+
+let testEnv: MockActivityEnvironment;
+
+beforeAll(() => {
+    testEnv = new MockActivityEnvironment();
+});
+
+beforeEach(() => {
+    vi.clearAllMocks();
+});
+
+const createPayload = (params: GenerateEmbeddingsParams): DSLActivityExecutionPayload<GenerateEmbeddingsParams> => {
+    const activityParams: GenerateEmbeddingsParams & Record<string, unknown> = { ...params };
+    return {
+        auth_token: 'mock-token',
+        account_id: 'test-account',
+        project_id: 'test-project',
+        params,
+        config: { studio_url: 'http://mock-studio', store_url: 'http://mock-store' },
+        workflow_name: 'StandardDocumentIntake',
+        event: ContentEventName.create,
+        objectIds: ['properties-only-object'],
+        input: { inputType: 'objectIds', objectIds: ['properties-only-object'] },
+        vars: {},
+        activity: { name: 'generateEmbeddings', params: activityParams },
+    };
+};
+
+describe('generateEmbeddings', () => {
+    it('should generate property embeddings for an object without content', async () => {
+        const { setupActivity } = await import('../dsl/setup/ActivityContext.js');
+        const document = {
+            id: 'properties-only-object',
+            properties: {
+                title: 'Properties-only object',
+                category: 'metadata',
+            },
+        } satisfies Partial<ContentObject>;
+        const embeddingResponse = {
+            model: 'embedding-model',
+            results: [{ outputs: [{ values: [0.1, 0.2, 0.3] }] }],
+        };
+        const client = {
+            objects: {
+                retrieve: vi.fn().mockResolvedValue(document),
+                setEmbedding: vi.fn().mockResolvedValue(undefined),
+            },
+            environments: {
+                embeddings: vi.fn().mockResolvedValue(embeddingResponse),
+            },
+        } as unknown as VertesiaClient;
+        const params = {
+            type: SupportedEmbeddingTypes.properties,
+            force: false,
+        } satisfies GenerateEmbeddingsParams;
+
+        vi.mocked(setupActivity).mockResolvedValue({
+            client,
+            objectId: document.id,
+            params,
+            fetchProject: vi.fn().mockResolvedValue({
+                name: 'Test Project',
+                namespace: 'test-project',
+                configuration: {
+                    embeddings: {
+                        [SupportedEmbeddingTypes.properties]: {
+                            enabled: true,
+                            environment: 'test-environment',
+                            max_tokens: 8000,
+                        },
+                    },
+                },
+            }),
+        } as unknown as ActivityContext<GenerateEmbeddingsParams>);
+
+        const result = await testEnv.run(generateEmbeddings, createPayload(params));
+
+        expect(result).toEqual({
+            id: document.id,
+            type: SupportedEmbeddingTypes.properties,
+            status: 'completed',
+            len: 3,
+        });
+        expect(client.objects.retrieve).toHaveBeenCalledWith(
+            document.id,
+            '+text +parts +embeddings +tokens +properties',
+        );
+        expect(client.environments.embeddings).toHaveBeenCalledWith('test-environment', {
+            inputs: [{ type: 'text', text: JSON.stringify(document.properties) }],
+            model: undefined,
+        });
+        expect(client.objects.setEmbedding).toHaveBeenCalledWith(document.id, SupportedEmbeddingTypes.properties, {
+            values: embeddingResponse.results[0].outputs[0].values,
+            model: embeddingResponse.model,
+            etag: expect.any(String),
+        });
+    });
+});

package/src/activities/generateEmbeddings.ts

@@ -113,10 +113,6 @@ export async function generateEmbeddings(payload: DSLActivityExecutionPayload<Ge
         throw new DocumentNotFoundError('Document not found', [objectId]);
     }
 
-    if (!document.content) {
-        throw new DocumentNotFoundError('Document content not found', [objectId]);
-    }
-
     let res:
         | Awaited<ReturnType<typeof generateTextEmbeddings>>
         | Awaited<ReturnType<typeof generateImageEmbeddings>>
@@ -174,14 +170,19 @@ async function generateTextEmbeddings({ document, client, type, config, force }:
         };
     }
 
-    if (type === SupportedEmbeddingTypes.text && !document.text) {
-        return { id: document.id, status: 'failed', message: 'no text found' };
-    }
-    if (type === SupportedEmbeddingTypes.properties && !document?.properties) {
+    const sourceText =
+        type === SupportedEmbeddingTypes.text
+            ? document.text
+            : document.properties
+              ? JSON.stringify(document.properties)
+              : undefined;
+
+    if (!sourceText) {
         return {
             id: document.id,
-            status: 'failed',
-            message: 'no properties found',
+            type,
+            status: 'skipped',
+            message: type === SupportedEmbeddingTypes.text ? 'no text found' : 'no properties found',
         };
     }
 
@@ -192,12 +193,12 @@ async function generateTextEmbeddings({ document, client, type, config, force }:
         );
     }
 
-    // Compute text etag for comparison
-    const textEtag = document.text_etag ?? (document.text ? md5(document.text) : undefined);
+    const sourceEtag =
+        type === SupportedEmbeddingTypes.text ? (document.text_etag ?? md5(sourceText)) : md5(sourceText);
 
     // Skip if embeddings already exist with matching etag (unless force=true)
     const existingEmbedding = document.embeddings?.[type];
-    if (!force && existingEmbedding?.etag && textEtag && existingEmbedding.etag === textEtag) {
+    if (!force && existingEmbedding?.etag && existingEmbedding.etag === sourceEtag) {
         log.debug(`Skipping ${type} embeddings for document ${document.id} - etag unchanged`);
         return {
             id: document.id,
@@ -208,15 +209,7 @@ async function generateTextEmbeddings({ document, client, type, config, force }:
     }
 
     // Count tokens if needed, do not rely on existing token count
-    let tokenCount: number | undefined;
-    if (type === SupportedEmbeddingTypes.text && document.text) {
-        tokenCount = countTokens(document.text).count;
-    }
-
-    if (type === SupportedEmbeddingTypes.properties && document.properties) {
-        const propertiesText = JSON.stringify(document.properties);
-        tokenCount = countTokens(propertiesText).count;
-    }
+    const tokenCount = countTokens(sourceText).count;
 
     const maxTokens = config.max_tokens ?? 8000;
 
@@ -233,7 +226,7 @@ async function generateTextEmbeddings({ document, client, type, config, force }:
     } else {
         log.debug(`Generating ${type} embeddings for document`);
 
-        const res = await generateEmbeddingsFromStudio(JSON.stringify(document[type]), environment, client);
+        const res = await generateEmbeddingsFromStudio(sourceText, environment, client);
         const values = res?.results?.[0]?.outputs?.[0]?.values;
         if (!values) {
             return {
@@ -249,7 +242,7 @@ async function generateTextEmbeddings({ document, client, type, config, force }:
         await client.objects.setEmbedding(document.id, type, {
             values,
             model: res.model,
-            etag: textEtag,
+            etag: sourceEtag,
         });
 
         return {

package/src/dsl/dslProxyActivities.test.ts

@@ -0,0 +1,23 @@
+import { describe, expect, it } from 'vitest';
+import { stripWorkflowContinuationFromVars } from './dslProxyActivities.js';
+
+describe('stripWorkflowContinuationFromVars', () => {
+    it('removes continue-as-new state from activity vars', () => {
+        const vars = {
+            interaction: 'sys:AppDeveloper',
+            _continuation: {
+                conversationState: { large: true },
+            },
+        };
+
+        expect(stripWorkflowContinuationFromVars(vars)).toEqual({
+            interaction: 'sys:AppDeveloper',
+        });
+        expect(vars).toHaveProperty('_continuation');
+    });
+
+    it('returns primitive and array vars unchanged', () => {
+        expect(stripWorkflowContinuationFromVars(undefined)).toBeUndefined();
+        expect(stripWorkflowContinuationFromVars(['a'])).toEqual(['a']);
+    });
+});

package/src/dsl/dslProxyActivities.ts

@@ -14,6 +14,16 @@ export type DslSimplifiedActivityFunction<ParamsT extends object = Record<string
     params: ParamsT,
 ) => Promise<ReturnT>;
 
+export function stripWorkflowContinuationFromVars<T>(vars: T): T {
+    if (!vars || typeof vars !== 'object' || Array.isArray(vars) || !('_continuation' in vars)) {
+        return vars;
+    }
+
+    const rest = { ...(vars as Record<string, unknown>) };
+    delete rest._continuation;
+    return rest as T;
+}
+
 export function dslProxyActivities<ActivitiesT extends object>(workflowName: string, options: ActivityOptions = {}) {
     type DslActivities = {
         [K in keyof ActivitiesT]: ActivitiesT[K] extends DslActivityFunction<infer ParamsT, infer ReturnT>
@@ -34,6 +44,7 @@ export function dslProxyActivities<ActivitiesT extends object>(workflowName: str
                 return (payload: WorkflowExecutionPayload, params: Record<string, unknown>) => {
                     return activityFn({
                         ...payload,
+                        vars: stripWorkflowContinuationFromVars(payload.vars),
                         activity: {
                             name: prop as string,
                         },

package/src/errors.ts

@@ -116,4 +116,9 @@ export const WF_NON_RETRYABLE_ERRORS = [
     'TokenExpiredError',
     'ZenoClientNotFoundError',
     'WorkflowExecutionError',
+    // Temporal raises NotFoundError when an activity isn't registered on the worker
+    // (e.g. a new tool whose activity barrel export was missed). Retrying can never
+    // make it appear within a worker version, and the retried failure carries the
+    // full activity list which blows the payload size limit — so fail fast.
+    'NotFoundError',
 ];