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

package/src/activities/executeInteraction.ts

@@ -1,69 +1,82 @@
-import { CompletionResult, ModelOptions, LlumiverseError } from "@llumiverse/common";
-import { activityInfo, ApplicationFailure, log } from "@temporalio/activity";
-import { VertesiaClient } from "@vertesia/client";
-import { NodeStreamSource } from "@vertesia/client/node";
+import { Readable } from 'node:stream';
 import {
-    DSLActivityExecutionPayload,
-    DSLActivitySpec,
-    ExecutionRun,
+    type CompletionResult,
+    type HttpTimeoutOptions,
+    type JSONSchema,
+    LlumiverseError,
+    type ModelOptions,
+} from '@llumiverse/common';
+import { ApplicationFailure, activityInfo, log } from '@temporalio/activity';
+import type { VertesiaClient } from '@vertesia/client';
+import { NodeStreamSource } from '@vertesia/client/node';
+import {
+    type DSLActivityExecutionPayload,
+    type DSLActivitySpec,
+    type ExecutionRun,
     ExecutionRunStatus,
-    ExecutionRunWorkflow,
-    InteractionExecutionConfiguration,
-    RunSearchPayload,
-} from "@vertesia/common";
-import { projectResult } from "../dsl/projections.js";
-import { setupActivity } from "../dsl/setup/ActivityContext.js";
-import { ActivityParamInvalidError, ActivityParamNotFoundError, ResourceExhaustedError } from "../errors.js";
-import { TruncateSpec, truncByMaxTokens } from "../utils/tokens.js";
-import { Readable } from "stream";
+    type ExecutionRunWorkflow,
+    type InteractionExecutionConfiguration,
+    type RunSearchPayload,
+} from '@vertesia/common';
+import { projectResult } from '../dsl/projections.js';
+import { setupActivity } from '../dsl/setup/ActivityContext.js';
+import { ActivityParamInvalidError, ActivityParamNotFoundError, ResourceExhaustedError } from '../errors.js';
+import { activityWorkflowExecution } from '../utils/activity-info.js';
+import { type TruncateSpec, truncByMaxTokens } from '../utils/tokens.js';
 
 //Example:
-//@ts-ignore
-const JSON: DSLActivitySpec = {
-    name: "executeInteraction",
-    import: ["defaultModel", "guidlineId", "docTypeId"],
+//@ts-expect-error
+const _JSON: DSLActivitySpec = {
+    name: 'executeInteraction',
+    import: ['defaultModel', 'guidlineId', 'docTypeId'],
     params: {
-        defaultModel: "${model}",
-        interactionName: "GenerateSummary",
+        defaultModel: '${model}',
+        interactionName: 'GenerateSummary',
         model: "${defaultModel ?? 'gpt4'}",
-        environment: "13456",
+        environment: '13456',
         max_tokens: 100,
         temperature: 0.5,
-        tags: ["test"],
-        result_schema: "${docType.object_schema}",
+        tags: ['test'],
+        result_schema: '${docType.object_schema}',
         prompt_data: {
-            documents: "${documents}",
-            guidline: "${guidline.text}",
+            documents: '${documents}',
+            guidline: '${guidline.text}',
         },
     },
     fetch: {
         documents: {
-            type: "document",
+            type: 'document',
             query: {
-                id: { $in: "${objectIds}" },
+                id: { $in: '${objectIds}' },
             },
-            select: "+text",
+            select: '+text',
         },
         guidline: {
-            type: "document",
+            type: 'document',
             limit: 1,
             query: {
-                id: "${guidlineId}",
+                id: '${guidlineId}',
             },
-            select: "+text",
-            on_not_found: "throw",
+            select: '+text',
+            on_not_found: 'throw',
         },
         docType: {
-            type: "document_type",
+            type: 'document_type',
             limit: 1,
             query: {
-                id: "${docTypeId}",
+                id: '${docTypeId}',
             },
-            select: "+object_schema",
+            select: '+object_schema',
         },
     },
 };
 export interface InteractionExecutionParams {
+    /**
+     * Execution configuration shared across workflow-driven interaction calls.
+     * Activity-level fields below override this object for backward compatibility.
+     */
+    config?: InteractionExecutionConfiguration;
+
     /**
      * The environment to use. If not specified the project default environment will be used.
      * If the latter is not specified an exception will be thrown.
@@ -79,7 +92,7 @@ export interface InteractionExecutionParams {
     /**
      * Request a JSON schema for the result
      */
-    result_schema?: any;
+    result_schema?: JSONSchema | null;
 
     /** Wether to validate the result against the schema */
     validate_result?: boolean;
@@ -99,6 +112,11 @@ export interface InteractionExecutionParams {
      */
     model_options?: ModelOptions;
 
+    /**
+     * Per-run HTTP timeouts for upstream LLM-provider calls.
+     */
+    http_timeout?: HttpTimeoutOptions;
+
     /**
      * activity won't be retried if it fails due to resource exhaustion (429)
      */
@@ -113,18 +131,18 @@ export interface InteractionExecutionParams {
 export interface ExecuteInteractionParams extends InteractionExecutionParams {
     //TODO rename to interaction as in InteractionAsyncExecutionPayload
     interactionName: string;
-    prompt_data: Record<string, any>;
+    prompt_data: Record<string, unknown>;
     /**
      * Additional prompt data passed by the workflow configuration. This will be merged with prompt_data if any.
      * You should use `import: ["static_prompt_data"]` to import the workflow prompt data as static_prompt_data param.
      * Otherwise the workflow prompt data will be ignored.
      */
-    static_prompt_data?: Record<string, any>;
+    static_prompt_data?: Record<string, unknown>;
     truncate?: Record<string, TruncateSpec>;
 }
 
 export interface ExecuteInteraction extends DSLActivitySpec<ExecuteInteractionParams> {
-    name: "executeInteraction";
+    name: 'executeInteraction';
 }
 
 export async function executeInteraction(payload: DSLActivityExecutionPayload<ExecuteInteractionParams>) {
@@ -136,14 +154,17 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload<Ex
     }
 
     if (!interactionName) {
-        log.error("Missing interactionName", { params });
-        throw new ActivityParamNotFoundError("interactionName", payload.activity);
+        log.error('Missing interactionName', { params });
+        throw new ActivityParamNotFoundError('interactionName', payload.activity);
     }
 
     if (params.truncate) {
         const truncate = params.truncate;
         for (const [key, value] of Object.entries(truncate)) {
-            prompt_data[key] = truncByMaxTokens(prompt_data[key], value);
+            const promptValue = prompt_data[key];
+            if (typeof promptValue === 'string') {
+                prompt_data[key] = truncByMaxTokens(promptValue, value);
+            }
         }
     }
 
@@ -159,35 +180,31 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload<Ex
         let completionResult: CompletionResult[] = res.result;
 
         // Handle image uploads if the result contains base64 images
-        const imageResults = completionResult.filter(r => r.type === "image");
+        const imageResults = completionResult.filter((r) => r.type === 'image');
         if (imageResults.length > 0) {
             const uploadedImages = await Promise.all(
                 completionResult.map(async (item, index) => {
-                    if (item.type === "image") {
+                    if (item.type === 'image') {
                         const image = item.value;
                         // Extract base64 data and create buffer
-                        const base64Data = image.replace(/^data:image\/[a-z]+;base64,/, "");
+                        const base64Data = image.replace(/^data:image\/[a-z]+;base64,/, '');
                         const buffer = Buffer.from(base64Data, 'base64');
 
                         // Generate filename
-                        const { runId } = activityInfo().workflowExecution;
+                        const { runId } = activityWorkflowExecution();
                         const { activityId } = activityInfo();
                         const filename = `generated-image-${runId}-${activityId}-${index}.png`;
 
                         // Create a readable stream from the buffer
                         const stream = Readable.from(buffer);
 
-                        const source = new NodeStreamSource(
-                            stream,
-                            filename,
-                            "image/png",
-                        );
+                        const source = new NodeStreamSource(stream, filename, 'image/png');
 
                         const file = await client.files.uploadFile(source);
-                        return { type: "image", value: file } as CompletionResult;
+                        return { type: 'image', value: file } as CompletionResult;
                     }
                     return item;
-                })
+                }),
             );
             completionResult = uploadedImages;
         }
@@ -197,52 +214,60 @@ export async function executeInteraction(payload: DSLActivityExecutionPayload<Ex
             status: res.status,
             result: completionResult,
         });
-
-    } catch (error: any) {
-        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 (is4xxNonRetryable(error.status) || is4xxNonRetryable(error.statusCode) || is4xxNonRetryable(error.code) || error.retryable === false) {
-            // 4xx HTTP errors (except retryable statuses) are permanent client errors
-            // (e.g. model not found, invalid request).
-            // Errors explicitly marked as non-retryable (e.g. LlumiverseError) also fall here.
-            // They will not be resolved by retrying.
-            throw ApplicationFailure.create({
-                message: `Interaction Execution failed ${interactionName}: ${error.message}`,
-                nonRetryable: true,
-            });
-        } else if (error.message.includes("Failed to validate merged prompt schema")) {
+    } catch (error: unknown) {
+        const executionError = toExecutionError(error);
+        log.error(`Failed to execute interaction ${interactionName}`, { error: executionError });
+        if (executionError.statusCode === 429 && params.exit_on_resource_exhaustion) {
+            throw new ResourceExhaustedError(executionError.statusCode, 'Resource exhausted - rate limit exceeded');
+        } else if (executionError.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")) {
+            throw new ActivityParamInvalidError('prompt_data', payload.activity, executionError.message);
+        } else if (executionError.message.includes('modelId: Path `modelId` is required')) {
             //issue with the input data, don't retry
-            throw new ActivityParamInvalidError("model", payload.activity, error.message);
+            throw new ActivityParamInvalidError('model', payload.activity, executionError.message);
         }
-        
+
         // Check retryability from error object (set by executeInteractionFromActivity)
         // or from LlumiverseError instance (direct driver errors in some paths)
-        const isRetryable = error.retryable !== undefined 
-            ? error.retryable !== false  // Treat undefined as retryable
-            : (error instanceof LlumiverseError ? error.retryable !== false : undefined);
-        
+        const isRetryable =
+            executionError.retryable !== undefined
+                ? executionError.retryable
+                : error instanceof LlumiverseError
+                  ? error.retryable !== false
+                  : undefined;
+
         if (isRetryable !== undefined) {
             if (isRetryable) {
-                log.debug('Marking error as retryable', { interactionName, errorCode: error.errorCode });
+                log.debug('Marking error as retryable', { interactionName, errorCode: executionError.errorCode });
                 throw ApplicationFailure.create({
-                    message: `Interaction Execution failed ${interactionName}: ${error.message}`,
+                    message: `Interaction Execution failed ${interactionName}: ${executionError.message}`,
                     nonRetryable: false,
                 });
             } else {
-                log.debug('Marking error as non-retryable', { interactionName, errorCode: error.errorCode });
+                log.debug('Marking error as non-retryable', { interactionName, errorCode: executionError.errorCode });
                 throw ApplicationFailure.create({
-                    message: `Non-retryable Interaction Execution failed ${interactionName}: ${error.message}`,
+                    message: `Non-retryable Interaction Execution failed ${interactionName}: ${executionError.message}`,
                     nonRetryable: true,
                 });
             }
         }
-        
+
+        if (
+            is4xxNonRetryable(executionError.status) ||
+            is4xxNonRetryable(executionError.statusCode) ||
+            is4xxNonRetryable(executionError.code)
+        ) {
+            // 4xx HTTP errors (except retryable statuses) are permanent client errors
+            // (e.g. model not found, invalid request). The explicit retryability
+            // flag above wins when a provider marks a 4xx as transient.
+            throw ApplicationFailure.create({
+                message: `Interaction Execution failed ${interactionName}: ${executionError.message}`,
+                nonRetryable: true,
+            });
+        }
+
         // Unknown retryability - rethrow as generic error (Temporal will use default retry policy)
-        throw new Error(`Interaction Execution failed ${interactionName}: ${error.message}`);
+        throw new Error(`Interaction Execution failed ${interactionName}: ${executionError.message}`);
     }
 }
 
@@ -250,38 +275,39 @@ export async function executeInteractionFromActivity(
     client: VertesiaClient,
     interactionName: string,
     params: InteractionExecutionParams,
-    prompt_data: any,
+    prompt_data: Record<string, unknown>,
     debug?: boolean,
 ) {
     const userTags = params.tags;
     const info = activityInfo();
-    const runId = info.workflowExecution.runId;
-    let tags = ["workflow"];
+    const execution = activityWorkflowExecution(info);
+    const runId = execution.runId;
+    let tags = ['workflow'];
     if (userTags) {
         tags = tags.concat(userTags);
     }
     const workflow: ExecutionRunWorkflow = {
-        run_id: info.workflowExecution.runId,
-        workflow_id: info.workflowExecution.workflowId,
+        run_id: execution.runId,
+        workflow_id: execution.workflowId,
         activity_type: info.activityType,
     };
 
-    let previousStudioExecutionRun: ExecutionRun | undefined = undefined;
+    let previousStudioExecutionRun: ExecutionRun | undefined;
     if (params.include_previous_error) {
         //retrieve last failed run if any
         if (info.attempt > 1) {
-            log.info("Retrying, searching for previous run", { prev_run_id: runId });
+            log.info('Retrying, searching for previous run', { prev_run_id: runId });
             const payload: RunSearchPayload = {
                 query: { workflow_run_ids: [runId] },
                 limit: 1,
             };
             const previousRun = await client.runs.search(payload).then((res) => {
-                log.info("Search results", { results: res });
+                log.info('Search results', { results: res });
                 return res ? (res[0] ?? undefined) : undefined;
             });
 
             if (previousRun) {
-                log.info("Found previous run", { previousRun });
+                log.info('Found previous run', { previousRun });
                 previousStudioExecutionRun = await client.runs.retrieve(previousRun.id);
             }
         }
@@ -290,11 +316,14 @@ export async function executeInteractionFromActivity(
         log.info(`Found  previous run error`, { error: previousStudioExecutionRun?.error });
     }
 
+    const configDefaults = params.config ?? {};
     const config: InteractionExecutionConfiguration = {
-        environment: params.environment,
-        model: params.model,
-        model_options: params.model_options,
-        do_validate: params.validate_result,
+        ...configDefaults,
+        environment: params.environment ?? configDefaults.environment,
+        model: params.model ?? configDefaults.model,
+        model_options: params.model_options ?? configDefaults.model_options,
+        http_timeout: params.http_timeout ?? configDefaults.http_timeout,
+        do_validate: params.validate_result ?? configDefaults.do_validate,
     };
     const data = {
         ...prompt_data,
@@ -325,15 +354,16 @@ export async function executeInteractionFromActivity(
 
     if (res.error || res.status === ExecutionRunStatus.failed) {
         log.error(`Error executing interaction ${interactionName}`, { error: res.error });
-        
+
         // Create error with retryability information
         const errorMessage = `Interaction Execution failed ${interactionName}: ${res.error?.message || 'Unknown error'}`;
         const error = new Error(errorMessage);
-        
+
         // Attach retryable property so the catch block can access it
-        (error as any).retryable = res.error?.retryable;
-        (error as any).errorCode = res.error?.code;
-        
+        const executionError = error as Error & { retryable?: boolean; errorCode?: string };
+        executionError.retryable = res.error?.retryable;
+        executionError.errorCode = res.error?.code;
+
         throw error;
     }
 
@@ -349,3 +379,18 @@ function is4xxNonRetryable(code: number | undefined): boolean {
     if (code === undefined || typeof code !== 'number') return false;
     return code >= 400 && code < 500 && code !== 412 && code !== 429;
 }
+
+interface ExecutionError extends Error {
+    status?: number;
+    statusCode?: number;
+    code?: number;
+    retryable?: boolean;
+    errorCode?: unknown;
+}
+
+function toExecutionError(error: unknown): ExecutionError {
+    if (error instanceof Error) {
+        return error as ExecutionError;
+    }
+    return new Error(String(error)) as ExecutionError;
+}

package/src/activities/executeRemoteActivity.test.ts

@@ -1,11 +1,11 @@
-import { MockActivityEnvironment } from "@temporalio/testing";
-import { ContentEventName, DSLActivityExecutionPayload } from "@vertesia/common";
-import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
-import { executeRemoteActivity, ExecuteRemoteActivityParams } from "./executeRemoteActivity.js";
+import { MockActivityEnvironment } from '@temporalio/testing';
+import { ContentEventName, type DSLActivityExecutionPayload } from '@vertesia/common';
+import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
+import { type ExecuteRemoteActivityParams, executeRemoteActivity } from './executeRemoteActivity.js';
 
-vi.stubGlobal("fetch", vi.fn());
+vi.stubGlobal('fetch', vi.fn());
 
-vi.mock("../utils/client.js", () => ({
+vi.mock('../utils/client.js', () => ({
     getVertesiaClient: vi.fn().mockReturnValue({
         apps: {
             validateUrl: vi.fn().mockResolvedValue({ valid: true }),
@@ -27,122 +27,116 @@ beforeEach(() => {
 const createPayload = (
     overrides: Partial<ExecuteRemoteActivityParams> = {},
 ): DSLActivityExecutionPayload<ExecuteRemoteActivityParams> => {
-    const params: ExecuteRemoteActivityParams = {
-        url: "https://tool-server.test/api/activities/nlp",
-        activity_name: "analyze_sentiment",
-        params: { text: "Hello world" },
-        app_install_id: "install-123",
-        app_name: "nlp-app",
+    const params = {
+        url: 'https://tool-server.test/api/activities/nlp',
+        activity_name: 'analyze_sentiment',
+        params: { text: 'Hello world' },
+        app_install_id: 'install-123',
+        app_name: 'nlp-app',
         ...overrides,
-    };
+    } satisfies ExecuteRemoteActivityParams;
     return {
-        auth_token: "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.sig",
-        account_id: "acc-123",
-        project_id: "proj-456",
+        auth_token:
+            'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJpc3MiOiJodHRwOi8vbW9jay10b2tlbi1zZXJ2ZXIiLCJzdWIiOiJ0ZXN0In0.sig',
+        account_id: 'acc-123',
+        project_id: 'proj-456',
         params,
         config: {
-            studio_url: "http://mock-studio",
-            store_url: "http://mock-store",
+            studio_url: 'http://mock-studio',
+            store_url: 'http://mock-store',
         },
-        workflow_name: "TestWorkflow",
+        workflow_name: 'TestWorkflow',
         event: ContentEventName.create,
         objectIds: [],
         vars: {},
-        activity: { name: "executeRemoteActivity", params },
+        activity: { name: 'executeRemoteActivity', params: params as unknown as Record<string, unknown> },
     };
 };
 
-describe("executeRemoteActivity", () => {
-    it("posts correct payload and returns result on success", async () => {
+describe('executeRemoteActivity', () => {
+    it('should post correct payload and return result on success', async () => {
         mockFetch.mockResolvedValueOnce(
-            new Response(
-                JSON.stringify({ result: { score: 0.95 }, is_error: false }),
-                { status: 200, headers: { "Content-Type": "application/json" } },
-            ),
+            new Response(JSON.stringify({ result: { score: 0.95 }, is_error: false }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }),
         );
 
-        const result = await testEnv.run(executeRemoteActivity, createPayload());
+        const result: unknown = await testEnv.run(executeRemoteActivity, createPayload());
         expect(result).toEqual({ score: 0.95 });
 
         expect(mockFetch).toHaveBeenCalledOnce();
         const [url, opts] = mockFetch.mock.calls[0];
-        expect(url).toBe("https://tool-server.test/api/activities/nlp");
-        expect(opts?.method).toBe("POST");
+        expect(url).toBe('https://tool-server.test/api/activities/nlp');
+        expect(opts?.method).toBe('POST');
         expect(opts?.headers).toMatchObject({
-            "Content-Type": "application/json",
-            Accept: "application/json",
+            'Content-Type': 'application/json',
+            Accept: 'application/json',
         });
         // Verify the auth header is forwarded
-        expect((opts?.headers as Record<string, string>)["Authorization"]).toMatch(/^Bearer /);
+        expect((opts?.headers as Record<string, string>).Authorization).toMatch(/^Bearer /);
 
         // Verify the body structure
         const body = JSON.parse(opts?.body as string);
-        expect(body.activity_name).toBe("analyze_sentiment");
-        expect(body.params).toEqual({ text: "Hello world" });
-        expect(body.metadata.app_install_id).toBe("install-123");
-        expect(body.metadata.endpoints).toEqual({ studio: "http://mock-studio", store: "http://mock-store" });
+        expect(body.activity_name).toBe('analyze_sentiment');
+        expect(body.params).toEqual({ text: 'Hello world' });
+        expect(body.metadata.app_install_id).toBe('install-123');
+        expect(body.metadata.endpoints).toEqual({ studio: 'http://mock-studio', store: 'http://mock-store' });
         // auth_token should NOT be in the payload (it's in the Authorization header)
         expect(body.auth_token).toBeUndefined();
     });
 
-    it("throws on HTTP error (4xx/5xx)", async () => {
+    it('should throw on HTTP error (4xx/5xx)', async () => {
         mockFetch.mockResolvedValueOnce(
-            new Response(
-                JSON.stringify({ error: "Activity not found", is_error: true }),
-                { status: 404, statusText: "Not Found" },
-            ),
+            new Response(JSON.stringify({ error: 'Activity not found', is_error: true }), {
+                status: 404,
+                statusText: 'Not Found',
+            }),
         );
 
         await expect(testEnv.run(executeRemoteActivity, createPayload())).rejects.toThrow(
-            "Remote activity analyze_sentiment failed: Activity not found",
+            'Remote activity analyze_sentiment failed: Activity not found',
         );
     });
 
-    it("throws on network error (for Temporal retry)", async () => {
-        mockFetch.mockRejectedValueOnce(new Error("Connection refused"));
+    it('should throw on network error (for Temporal retry)', async () => {
+        mockFetch.mockRejectedValueOnce(new Error('Connection refused'));
 
         await expect(testEnv.run(executeRemoteActivity, createPayload())).rejects.toThrow(
             /Failed to reach remote activity endpoint/,
         );
     });
 
-    it("throws on invalid JSON response", async () => {
-        mockFetch.mockResolvedValueOnce(
-            new Response("not json", { status: 200 }),
-        );
+    it('should throw on invalid JSON response', async () => {
+        mockFetch.mockResolvedValueOnce(new Response('not json', { status: 200 }));
 
-        await expect(testEnv.run(executeRemoteActivity, createPayload())).rejects.toThrow(
-            /returned invalid JSON/,
-        );
+        await expect(testEnv.run(executeRemoteActivity, createPayload())).rejects.toThrow(/returned invalid JSON/);
     });
 
-    it("throws when response indicates is_error", async () => {
+    it('should throw when response indicates is_error', async () => {
         mockFetch.mockResolvedValueOnce(
-            new Response(
-                JSON.stringify({ result: null, is_error: true, error: "Something went wrong" }),
-                { status: 200, headers: { "Content-Type": "application/json" } },
-            ),
+            new Response(JSON.stringify({ result: null, is_error: true, error: 'Something went wrong' }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }),
         );
 
         await expect(testEnv.run(executeRemoteActivity, createPayload())).rejects.toThrow(
-            "Remote activity analyze_sentiment: Something went wrong",
+            'Remote activity analyze_sentiment: Something went wrong',
         );
     });
 
-    it("forwards app_settings in metadata", async () => {
+    it('should forward app_settings in metadata', async () => {
         mockFetch.mockResolvedValueOnce(
-            new Response(
-                JSON.stringify({ result: "ok", is_error: false }),
-                { status: 200, headers: { "Content-Type": "application/json" } },
-            ),
+            new Response(JSON.stringify({ result: 'ok', is_error: false }), {
+                status: 200,
+                headers: { 'Content-Type': 'application/json' },
+            }),
         );
 
-        await testEnv.run(
-            executeRemoteActivity,
-            createPayload({ app_settings: { api_key: "secret" } }),
-        );
+        await testEnv.run(executeRemoteActivity, createPayload({ app_settings: { api_key: 'secret' } }));
 
         const body = JSON.parse(mockFetch.mock.calls[0][1]?.body as string);
-        expect(body.metadata.app_settings).toEqual({ api_key: "secret" });
+        expect(body.metadata.app_settings).toEqual({ api_key: 'secret' });
     });
 });