@vertesia/workflow 1.4.0-dev.20260629.130134Z → 1.5.0-dev.20260713.113008Z

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/workflow",
-  "version": "1.4.0-dev.20260629.130134Z",
+  "version": "1.5.0-dev.20260713.113008Z",
   "type": "module",
   "description": "Vertesia workflow DSL",
   "main": "./lib/index.js",
@@ -14,10 +14,10 @@
   },
   "license": "Apache-2.0",
   "devDependencies": {
-    "@smithy/types": "^4.14.3",
-    "@temporalio/proto": "^1.18.1",
-    "@temporalio/testing": "^1.18.1",
-    "@temporalio/worker": "^1.18.1",
+    "@smithy/types": "^4.15.0",
+    "@temporalio/proto": "^1.19.0",
+    "@temporalio/testing": "^1.19.0",
+    "@temporalio/worker": "^1.19.0",
     "@types/jsonwebtoken": "^9.0.10",
     "@types/node": "^24.13.2",
     "@types/papaparse": "^5.5.2",
@@ -27,29 +27,29 @@
     "@vertesia/tsconfig": "0.1.0"
   },
   "dependencies": {
-    "@aws-sdk/client-s3": "^3.1068.0",
-    "@aws-sdk/client-textract": "^3.1068.0",
-    "@aws-sdk/credential-providers": "^3.1068.0",
-    "@temporalio/activity": "^1.18.1",
-    "@temporalio/workflow": "^1.18.1",
+    "@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",
     "fast-deep-equal": "^3.1.3",
     "jsonwebtoken": "^9.0.3",
     "mime": "^4.1.0",
     "ms": "3.0.0-canary.202508261828",
     "node-web-stream-adapters": "^0.2.1",
     "p-limit": "^7.3.0",
-    "papaparse": "^5.5.3",
+    "papaparse": "^5.5.4",
     "seedrandom": "^3.0.5",
-    "sharp": "^0.34.5",
+    "sharp": "^0.35.3",
     "tiktoken": "^1.0.22",
     "tmp": "^0.2.7",
     "tmp-promise": "^3.0.3",
-    "undici": "^7.27.2",
+    "undici": "^7.28.0",
     "yaml": "^2.9.0",
-    "@vertesia/client": "1.4.0-dev.20260629.130134Z",
-    "@llumiverse/common": "1.4.0-dev.20260629.090753Z",
-    "@vertesia/common": "1.4.0-dev.20260629.130134Z",
-    "@vertesia/api-fetch-client": "1.4.0-dev.20260629.130134Z"
+    "@llumiverse/common": "1.5.0-dev",
+    "@vertesia/api-fetch-client": "1.5.0-dev.20260713.113008Z",
+    "@vertesia/client": "1.5.0-dev.20260713.113008Z",
+    "@vertesia/common": "1.5.0-dev.20260713.113008Z"
   },
   "exports": {
     ".": {

package/src/activities/detectDocumentLanguage.ts

@@ -0,0 +1,92 @@
+import { log } from '@temporalio/activity';
+import type { DSLActivityExecutionPayload, DSLActivitySpec } from '@vertesia/common';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { executeInteractionFromActivity, type InteractionExecutionParams } from './executeInteraction.js';
+
+const INT_DETECT_LANGUAGE = 'sys:DetectLanguage';
+
+// A short head of the text is enough to identify the language; keep the call tiny.
+const DEFAULT_MAX_CHARS = 500;
+
+const LANGUAGE_RESULT_SCHEMA: InteractionExecutionParams['result_schema'] = {
+    type: 'object',
+    properties: {
+        languages: { type: 'array', items: { type: 'string' } },
+    },
+    required: ['languages'],
+};
+
+export interface DetectDocumentLanguageParams extends InteractionExecutionParams {
+    interactionName?: string;
+    /** Number of leading characters of the document text to inspect (default 500). */
+    maxChars?: number;
+}
+
+export interface DetectDocumentLanguage extends DSLActivitySpec<DetectDocumentLanguageParams> {
+    name: 'detectDocumentLanguage';
+}
+
+interface DetectLanguageResult {
+    languages?: unknown;
+}
+
+/**
+ * Detect the document language(s) from its first pages and store them in metadata.languages.
+ *
+ * A small, focused pass: it runs the sys:DetectLanguage interaction on a short text excerpt rather
+ * than folding language into full property extraction (more reliable, and cheap). No-op when the
+ * document has no text yet (e.g. media handled by the transcription path, which sets languages
+ * itself).
+ */
+export async function detectDocumentLanguage(payload: DSLActivityExecutionPayload<DetectDocumentLanguageParams>) {
+    const context = await setupActivity<DetectDocumentLanguageParams>(payload);
+    const { params, client, objectId } = context;
+    const interactionName = params.interactionName ?? INT_DETECT_LANGUAGE;
+
+    const doc = await client.objects.retrieve(objectId, '+text');
+    if (!doc?.text) {
+        log.info(`detectDocumentLanguage: object ${objectId} has no text, skipping`);
+        return { status: 'skipped', message: 'no-text' };
+    }
+
+    const content = doc.text.slice(0, params.maxChars ?? DEFAULT_MAX_CHARS);
+
+    let res: Awaited<ReturnType<typeof executeInteractionFromActivity>>;
+    try {
+        res = await executeInteractionFromActivity(
+            client,
+            interactionName,
+            { ...params, result_schema: LANGUAGE_RESULT_SCHEMA },
+            { content },
+            payload.debug_mode ?? false,
+        );
+    } catch (error) {
+        // Language detection is best-effort — never fail the whole intake over it.
+        log.warn(`detectDocumentLanguage: detection failed for ${objectId}, skipping`, { error: String(error) });
+        return { status: 'skipped', message: 'detection-failed' };
+    }
+
+    const result = res.result.object<DetectLanguageResult>();
+    const languages = Array.isArray(result.languages)
+        ? Array.from(
+              new Set(
+                  result.languages
+                      .filter((lang): lang is string => typeof lang === 'string')
+                      .map((lang) => lang.trim().toLowerCase())
+                      .filter(Boolean),
+              ),
+          )
+        : [];
+
+    if (languages.length === 0) {
+        log.warn(`detectDocumentLanguage: no language detected for ${objectId}`, { runId: res.id });
+        return { status: 'completed', languages: [] };
+    }
+
+    // metadata-only update (not source/properties), so it won't re-trigger intake; suppress
+    // workflows anyway for consistency with the other intake writes.
+    await client.objects.update(objectId, { metadata: { ...doc.metadata, languages } }, { suppressWorkflows: true });
+
+    log.info(`detectDocumentLanguage: set languages for ${objectId}`, { languages, runId: res.id });
+    return { status: 'completed', languages };
+}

package/src/activities/extractDocumentText.ts

@@ -235,13 +235,25 @@ function createResponse(
     return {
         status,
         message,
-        tokens: doc.tokens,
+        tokens: getCompleteTokens(doc),
         len: text.length,
         objectId: doc.id,
         hasText: !!text,
     };
 }
 
+function getCompleteTokens(doc: ContentObject): TextExtractionResult['tokens'] {
+    const tokens = doc.tokens;
+    if (tokens?.count === undefined || tokens.encoding === undefined || tokens.etag === undefined) {
+        return undefined;
+    }
+    return {
+        count: tokens.count,
+        encoding: tokens.encoding,
+        etag: tokens.etag,
+    };
+}
+
 function sniffIfText(buf: Buffer) {
     // If file is too large, don't even try
     if (buf.length > 500 * 1024) {

package/src/activities/generateEmbeddings.ts

@@ -48,21 +48,33 @@ export interface GenerateEmbeddings extends DSLActivitySpec<GenerateEmbeddingsPa
     name: 'generateEmbeddings';
 }
 
+/**
+ * True when an error indicates the embedding environment is missing/unavailable (e.g. the
+ * configured environment id no longer exists). Treated as "not configured" so intake skips
+ * embeddings gracefully instead of failing.
+ */
+function isEnvironmentNotFound(error: unknown): boolean {
+    const message = error instanceof Error ? error.message : String(error);
+    return /environment not found/i.test(message);
+}
+
 export async function generateEmbeddings(payload: DSLActivityExecutionPayload<GenerateEmbeddingsParams>) {
     const { params, client, objectId, fetchProject } = await setupActivity<GenerateEmbeddingsParams>(payload);
     const { force, type } = params;
 
+    const skipped = (message: string) => {
+        log.info(`Skipping ${type} embeddings for ${objectId}: ${message}`);
+        return { id: objectId, status: 'skipped' as const, message };
+    };
+
     const projectData = await fetchProject();
     const config = projectData?.configuration.embeddings[type];
     if (!projectData) {
         throw new DocumentNotFoundError('Project not found', [payload.project_id]);
     }
+    // Embeddings not configured for this type -> skip rather than fail intake.
     if (!config) {
-        throw new DocumentNotFoundError('Embeddings configuration not found', [objectId]);
-    }
-
-    if (!projectData) {
-        throw new DocumentNotFoundError('Project not found', [payload.project_id]);
+        return skipped(`embeddings not configured for type ${type}`);
     }
 
     if (!projectData?.configuration.embeddings[type]?.enabled) {
@@ -82,10 +94,9 @@ export async function generateEmbeddings(payload: DSLActivityExecutionPayload<Ge
         config,
     });
 
+    // No embedding environment configured for this type -> skip rather than fail intake.
     if (!config.environment) {
-        throw new Error(
-            'No environment found in project configuration. Set environment in project configuration to generate embeddings.',
-        );
+        return skipped(`no embedding environment configured for type ${type}`);
     }
 
     let document: Awaited<ReturnType<typeof client.objects.retrieve>>;
@@ -111,40 +122,31 @@ export async function generateEmbeddings(payload: DSLActivityExecutionPayload<Ge
         | Awaited<ReturnType<typeof generateImageEmbeddings>>
         | { id: string; status: string; message: string };
 
-    switch (type) {
-        case SupportedEmbeddingTypes.text:
-            res = await generateTextEmbeddings({
-                client,
-                config,
-                document,
-                type,
-                force,
-            });
-            break;
-        case SupportedEmbeddingTypes.properties:
-            res = await generateTextEmbeddings({
-                client,
-                config,
-                document,
-                type,
-                force,
-            });
-            break;
-        case SupportedEmbeddingTypes.image:
-            res = await generateImageEmbeddings({
-                client,
-                config,
-                document,
-                type,
-                force,
-            });
-            break;
-        default:
-            res = {
-                id: objectId,
-                status: 'failed',
-                message: `unsupported embedding type: ${type}`,
-            };
+    try {
+        switch (type) {
+            case SupportedEmbeddingTypes.text:
+                res = await generateTextEmbeddings({ client, config, document, type, force });
+                break;
+            case SupportedEmbeddingTypes.properties:
+                res = await generateTextEmbeddings({ client, config, document, type, force });
+                break;
+            case SupportedEmbeddingTypes.image:
+                res = await generateImageEmbeddings({ client, config, document, type, force });
+                break;
+            default:
+                res = {
+                    id: objectId,
+                    status: 'failed',
+                    message: `unsupported embedding type: ${type}`,
+                };
+        }
+    } catch (error) {
+        // Configured environment is missing/unavailable -> skip rather than fail the whole intake
+        // (and avoid the long LLM-activity retry storm a throw would trigger).
+        if (isEnvironmentNotFound(error)) {
+            return skipped(`embedding environment unavailable for type ${type}`);
+        }
+        throw error;
     }
 
     return res;

package/src/activities/generateOrAssignContentType.ts

@@ -13,6 +13,12 @@ import { executeInteractionFromActivity, type InteractionExecutionParams } from
 const INT_SELECT_DOCUMENT_TYPE = 'sys:SelectDocumentType';
 const INT_GENERATE_METADATA_MODEL = 'sys:GenerateMetadataModel';
 
+// Always-present system fallback type (registered in zeno's SystemContentTypeRegistry). When type
+// selection finds no existing match and new-type generation is disabled, documents are assigned
+// this generic type so they still get a minimal property set + a processing hint for later typing.
+const GENERIC_DOCUMENT_TYPE_ID = 'sys:GenericDocument';
+const GENERIC_DOCUMENT_TYPE_NAME = 'GenericDocument';
+
 interface RetryableError extends Error {
     retryable?: boolean;
 }
@@ -51,6 +57,18 @@ export interface GenerateOrAssignContentTypeParams extends InteractionExecutionP
         selectDocumentType?: string;
         generateMetadataModel?: string;
     };
+
+    /**
+     * Whether the activity may create a brand-new content type when no existing type matches.
+     * Defaults to true for backward compatibility.
+     */
+    allowNewContentTypes?: boolean;
+
+    /**
+     * Type id to assign when no existing type matches and generation is disabled. Resolved in this
+     * project; falls back to sys:GenericDocument if unset or unresolvable.
+     */
+    fallbackTypeId?: string;
 }
 
 export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrAssignContentTypeParams> {
@@ -167,9 +185,16 @@ export async function generateOrAssignContentType(
     selectedType = types.find((t) => t.name === jsonResult.document_type);
 
     if (!selectedType) {
-        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 };
+        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.
+            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 };
+        }
     }
 
     if (!selectedType) {
@@ -189,6 +214,34 @@ export async function generateOrAssignContentType(
     };
 }
 
+/**
+ * Resolve the fallback type to assign when selection finds no match: the project's configured
+ * default content type if set and resolvable, otherwise the platform sys:GenericDocument.
+ */
+async function resolveFallbackType(
+    context: ActivityContext<GenerateOrAssignContentTypeParams>,
+    fallbackTypeId: string | undefined,
+    selectedDocumentType: unknown,
+): Promise<{ id: string; name: string }> {
+    if (fallbackTypeId && fallbackTypeId !== GENERIC_DOCUMENT_TYPE_ID) {
+        try {
+            const resolved = await context.client.types.catalog.resolve(fallbackTypeId);
+            log.info('Document type not identified; assigning project default content type', {
+                fallbackTypeId,
+                selectedDocumentType,
+            });
+            return { id: resolved.id ?? fallbackTypeId, name: resolved.name ?? fallbackTypeId };
+        } catch (error) {
+            log.warn('Configured default content type not resolvable; using GenericDocument', {
+                fallbackTypeId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    log.info('Document type not identified; assigning GenericDocument fallback', { selectedDocumentType });
+    return { id: GENERIC_DOCUMENT_TYPE_ID, name: GENERIC_DOCUMENT_TYPE_NAME };
+}
+
 async function generateNewType(
     context: ActivityContext<GenerateOrAssignContentTypeParams>,
     existing_types: ContentObjectTypeItem[],

package/src/activities/handleError.ts

@@ -10,6 +10,7 @@ export async function handleDslError(payload: DSLActivityExecutionPayload<Handle
     const { client, params, objectId } = await setupActivity<HandleDslErrorParams>(payload);
 
     const isIntake = [
+        'StandardIntake',
         'StandardDocumentIntake',
         'StandardImageIntake',
         'StandardMediaContainerIntake',

package/src/activities/index-dsl.ts

@@ -5,6 +5,7 @@ export { createOrUpdateDocumentFromInteractionRun } from './advanced/createOrUpd
 export { updateDocumentFromInteractionRun } from './advanced/updateDocumentFromInteractionRun.js';
 export { chunkDocument } from './chunkDocument.js';
 export { createPdfDocumentFromSource } from './createDocumentFromOther.js';
+export { detectDocumentLanguage } from './detectDocumentLanguage.js';
 export { executeInteraction } from './executeInteraction.js';
 export { executeRemoteActivity } from './executeRemoteActivity.js';
 export { extractDocumentText } from './extractDocumentText.js';

package/src/activities/media/prepareAudio.ts

@@ -258,11 +258,14 @@ export async function prepareAudio(
         }
 
         // Step 4: Update content object with metadata and renditions
+        const generationRuns = Array.isArray(inputObject.metadata?.generation_runs)
+            ? inputObject.metadata.generation_runs
+            : [];
         const audioMetadata: AudioMetadata = {
             type: ContentNature.Audio,
             duration: metadata.duration,
             renditions,
-            generation_runs: inputObject.metadata?.generation_runs || [],
+            generation_runs: generationRuns,
         };
 
         await client.objects.update(objectId, {

package/src/activities/media/prepareVideo.ts

@@ -534,6 +534,9 @@ export async function prepareVideo(
         }
 
         // Step 7: Update content object with metadata and renditions
+        const generationRuns = Array.isArray(inputObject.metadata?.generation_runs)
+            ? inputObject.metadata.generation_runs
+            : [];
         const videoMetadata: VideoMetadata = {
             type: ContentNature.Video,
             duration: metadata.duration,
@@ -543,7 +546,7 @@ export async function prepareVideo(
             },
             renditions,
             hasAudio: metadata.hasAudio,
-            generation_runs: inputObject.metadata?.generation_runs || [],
+            generation_runs: generationRuns,
         };
 
         await client.objects.update(objectId, {

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

@@ -1,8 +1,8 @@
 import { MockActivityEnvironment } from '@temporalio/testing';
 import type { VertesiaClient } from '@vertesia/client';
 import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
-import type { ActivityContext } from '@vertesia/workflow';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ActivityContext } from '../../dsl/setup/ActivityContext.js';
 import { type ProbeMediaStreamsParams, type ProbeMediaStreamsResult, probeMediaStreams } from './probeMediaStreams.js';
 
 vi.mock('../../dsl/setup/ActivityContext.js', async (importOriginal) => {

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

@@ -1,8 +1,9 @@
 import { MockActivityEnvironment } from '@temporalio/testing';
 import type { VertesiaClient } from '@vertesia/client';
 import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
-import type { ActivityContext, TextExtractionResult } from '@vertesia/workflow';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ActivityContext } from '../../dsl/setup/ActivityContext.js';
+import type { TextExtractionResult } from '../../result-types.js';
 import { TextExtractionStatus } from '../../result-types.js';
 import { type SaveGladiaTranscriptionParams, saveGladiaTranscription } from './saveGladiaTranscription.js';
 

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

@@ -7,8 +7,8 @@ import {
     ContentNature,
     type DSLActivityExecutionPayload,
 } from '@vertesia/common';
-import type { ActivityContext } from '@vertesia/workflow';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import type { ActivityContext } from '../../dsl/setup/ActivityContext.js';
 import { TextExtractionStatus } from '../../result-types.js';
 import {
     type TranscriptMediaParams,

package/src/activities/notifyWebhook.test.ts

@@ -1,4 +1,5 @@
 import { MockActivityEnvironment } from '@temporalio/testing';
+import type { VertesiaClient } from '@vertesia/client';
 import { ApiVersions, ContentEventName, type DSLActivityExecutionPayload, type WebHookSpec } from '@vertesia/common';
 import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
 import {
@@ -8,6 +9,23 @@ import {
     type WebhookNotificationPayload,
 } from './notifyWebhook.js';
 
+const mockValidateUrl = vi.hoisted(() => vi.fn());
+
+vi.mock('../utils/client.js', async (importOriginal) => {
+    const actual = await importOriginal<typeof import('../utils/client.js')>();
+    return {
+        ...actual,
+        getVertesiaClient: vi.fn(
+            () =>
+                ({
+                    apps: {
+                        validateUrl: mockValidateUrl,
+                    },
+                }) as unknown as VertesiaClient,
+        ),
+    };
+});
+
 // Mock fetch globally
 vi.stubGlobal('fetch', vi.fn());
 
@@ -20,6 +38,7 @@ beforeAll(async () => {
 
 beforeEach(() => {
     vi.clearAllMocks();
+    mockValidateUrl.mockResolvedValue({ valid: true });
 });
 
 const defaultParams = {
@@ -64,6 +83,7 @@ describe('Webhook should be notified', () => {
             status: 200,
             statusText: 'OK',
             url: defaultParams.webhook,
+            headers: new Headers(),
         };
         mockFetch.mockResolvedValueOnce(mockResponse as Response);
 
@@ -82,6 +102,7 @@ describe('Webhook should be notified', () => {
             headers: {
                 'Content-Type': 'application/json',
             },
+            redirect: 'manual',
         });
 
         // Verify response
@@ -99,6 +120,7 @@ describe('Webhook should be notified', () => {
             status: 500,
             statusText: 'Internal Server Error',
             url: defaultParams.webhook,
+            headers: new Headers(),
             text: vi.fn().mockResolvedValue('{"error": "Database connection failed", "code": "DB_ERROR"}'),
         } as unknown as Response;
         mockFetch.mockResolvedValueOnce(mockResponse);
@@ -122,6 +144,7 @@ describe('Webhook should be notified', () => {
             headers: {
                 'Content-Type': 'application/json',
             },
+            redirect: 'manual',
         });
 
         // Verify that text() was called to read the response
@@ -150,6 +173,100 @@ describe('Webhook should be notified', () => {
             headers: {
                 'Content-Type': 'application/json',
             },
+            redirect: 'manual',
+        });
+    });
+
+    it('should block URLs rejected by central URL validation', async () => {
+        mockValidateUrl.mockRejectedValueOnce(new Error('Access to internal hosts is not allowed'));
+
+        const payload = createTestPayload({
+            webhook: 'https://metadata.google.internal/computeMetadata/v1/',
+        });
+
+        await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow(
+            'Webhook endpoint blocked: Access to internal hosts is not allowed',
+        );
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should retry transient central URL validation failures', async () => {
+        const transientError = Object.assign(new Error('studio-server unavailable'), { statusCode: 503 });
+        mockValidateUrl.mockRejectedValueOnce(transientError);
+
+        const payload = createTestPayload();
+
+        await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow('studio-server unavailable');
+        expect(mockFetch).not.toHaveBeenCalled();
+    });
+
+    it('should block webhook redirects', async () => {
+        mockFetch.mockResolvedValueOnce(
+            new Response(null, {
+                status: 302,
+                statusText: 'Found',
+                headers: {
+                    Location: 'https://example.com/redirected',
+                },
+            }),
+        );
+
+        const payload = createTestPayload();
+
+        await expect(testEnv.run(notifyWebhook, payload)).rejects.toThrow('Webhook endpoint blocked: Request to');
+        expect(mockFetch).toHaveBeenCalledWith(defaultParams.webhook, {
+            method: 'POST',
+            body: JSON.stringify({
+                workflowId: 'wf_id',
+                runId: 'wf_run_id',
+                status: 'completed',
+                result: { message: 'Hello World' },
+            }),
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            redirect: 'manual',
+        });
+    });
+
+    it('should send a raw body when provided', async () => {
+        const mockResponse = {
+            ok: true,
+            status: 202,
+            statusText: 'Accepted',
+            url: defaultParams.webhook,
+            headers: new Headers(),
+        };
+        mockFetch.mockResolvedValueOnce(mockResponse as Response);
+
+        const body = JSON.stringify({ event: { event_id: 'evt-1' } });
+        const payload = createTestPayload({
+            body,
+            headers: {
+                'content-type': 'application/json',
+                'X-Vertesia-Event-Id': 'evt-1',
+            },
+            timeout_ms: 5000,
+        });
+
+        const res: NotifyWebhookResult = await testEnv.run(notifyWebhook, payload);
+
+        expect(mockFetch).toHaveBeenCalledTimes(1);
+        const [url, options] = mockFetch.mock.calls[0];
+        expect(url).toBe(defaultParams.webhook);
+        expect(options).toMatchObject({
+            method: 'POST',
+            body,
+            headers: {
+                'content-type': 'application/json',
+                'X-Vertesia-Event-Id': 'evt-1',
+            },
+        });
+        expect(options?.signal).toBeInstanceOf(AbortSignal);
+        expect(res).toEqual({
+            status: 202,
+            message: 'Accepted',
+            url: defaultParams.webhook,
         });
     });
 
@@ -160,6 +277,7 @@ describe('Webhook should be notified', () => {
             status: 200,
             statusText: 'OK',
             url: 'https://vertesia.test',
+            headers: new Headers(),
         };
         mockFetch.mockResolvedValueOnce(mockResponse as Response);
 
@@ -213,6 +331,7 @@ describe('Webhook should be notified', () => {
             status: 200,
             statusText: 'OK',
             url: 'https://vertesia.test',
+            headers: new Headers(),
         };
         mockFetch.mockResolvedValueOnce(mockResponse as Response);