@output.ai/core 0.1.18 → 0.2.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.1.18",
+  "version": "0.2.1",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -38,6 +38,7 @@
     "@temporalio/workflow": "1.13.1",
     "redis": "5.8.3",
     "stacktrace-parser": "0.1.11",
+    "undici": "7.18.2",
     "zod": "4.1.12"
   },
   "license": "Apache-2.0",

package/src/consts.js

@@ -1,4 +1,4 @@
-export const ACTIVITY_SEND_WEBHOOK = '__internal#sendWebhook';
+export const ACTIVITY_SEND_HTTP_REQUEST = '__internal#sendHttpRequest';
 export const ACTIVITY_GET_TRACE_DESTINATIONS = '__internal#getTraceDestinations';
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
 export const SHARED_STEP_PREFIX = '__shared#';

package/src/index.d.ts

@@ -1,5 +1,6 @@
 import type { z } from 'zod';
 import type { ActivityOptions } from '@temporalio/workflow';
+import type { SerializedFetchResponse } from './utils/index.d.ts';
 
 /**
  * Expose z from Zod as a convenience.
@@ -7,6 +8,7 @@ import type { ActivityOptions } from '@temporalio/workflow';
 export { z } from 'zod';
 
 /**
+ * Exports Temporal's sleep() function for advanced use cases.
  * Pause workflow execution for a specified duration.
  *
  * Use this for delay-based throttling when calling external APIs.
@@ -21,6 +23,8 @@ export { z } from 'zod';
  * }
  * ```
  *
+ * @see {@link https://docs.temporal.io/develop/typescript/timers}
+ *
  * @param ms - Duration to sleep in milliseconds (or a string like '1s', '100ms')
  * @returns A promise that resolves after the specified duration
  *
@@ -49,6 +53,11 @@ export { continueAsNew } from '@temporalio/workflow';
  */
 export type AnyZodSchema = z.ZodType<any, any, any>; // eslint-disable-line @typescript-eslint/no-explicit-any
 
+/**
+ * Allowed HTTP methods for request helpers.
+ */
+export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+
 /**
  * Native Temporal configurations for activities.
  *
@@ -163,8 +172,11 @@ export type StepFunctionWrapper<StepFunction> =
  * - Never call another step from within a step.
  * - Never call a workflow from within a step.
  *
- * @typeParam InputSchema - Zod schema for the step input
- * @typeParam OutputSchema - Zod schema for the step output
+ * @typeParam InputSchema - Zod schema of the fn's input.
+ * @typeParam OutputSchema - Zod schema of the fn's return.
+ *
+ * @throws {@link ValidationError}
+ * @throws {@link FatalError}
  *
  * @param params - Step parameters
  * @param params.name - Human-readable step name (must start with a letter or underscore, followed by letters, numbers, or underscores)
@@ -402,6 +414,11 @@ export type WorkflowFunctionWrapper<WorkflowFunction> =
  *   }
  * } )
  * ```
+ * @typeParam InputSchema - Zod schema of the fn's input.
+ * @typeParam OutputSchema - Zod schema of the fn's return.
+ *
+ * @throws {@link ValidationError}
+ * @throws {@link FatalError}
  *
  * @param params - Workflow parameters
  * @param params.name - Human-readable workflow name (must start with a letter or underscore, followed by letters, numbers, or underscores).
@@ -460,6 +477,11 @@ export class EvaluationResult {
    * @returns The evaluation result reasoning
    */
   get reasoning(): string;
+
+  /**
+   * @returns A zod schema representing this class
+   */
+  get schema(): string;
 }
 
 /**
@@ -553,6 +575,12 @@ export type EvaluatorFunctionWrapper<EvaluatorFunction> =
  *
  * It is translated to a Temporal Activity.
  *
+ * @typeParam InputSchema - Zod schema of the fn's input.
+ * @typeParam Result - Return type of the fn, extends EvaluationResult.
+ *
+ * @throws {@link ValidationError}
+ * @throws {@link FatalError}
+ *
  * @param params - Evaluator parameters
  * @param params.name - Human-readable evaluator name (must start with a letter or underscore, followed by letters, numbers, or underscores)
  * @param params.description - Description of the evaluator
@@ -580,17 +608,82 @@ export declare function evaluator<
 */
 
 /**
- * Create a webhook call that pauses the workflow until resumed via signal.
+ * Send an POST HTTP request to a URL, optionally with a payload, then wait for a webhook response.
+ *
+ * The "Content-Type" is inferred from the payload type and can be overridden via the `headers` argument.
  *
- * Sends a request via an activity; the workflow will await a corresponding
- * resume signal to continue and return the response payload.
+ * If the body is not a type natively accepted by the Fetch API, it is serialized to a string: `JSON.stringify()` for objects, or `String()` for primitives.
+ *
+ * When a body is sent, the payload is wrapped together with the `workflowId` and sent as:
+ * @example
+ * ```js
+ * const finalPayload = {
+ *   workflowId,
+ *   payload
+ * }
+ * ```
  *
- * @param params - Webhook request parameters
- * @param params.url - Webhook request URL (POST)
- * @param params.payload - Webhook request payload
- * @returns Resolves with the response payload when resumed
+ * After dispatching the request, the workflow pauses and waits for a POST to `/workflow/:id/feedback` (where `:id` is the `workflowId`). When the API receives that request, its body is delivered back to the workflow and execution resumes.
+ *
+ * @example
+ * ```js
+ * const response = await sendPostRequestAndAwaitWebhook( {
+ *   url: 'https://example.com/integration',
+ *   payload: {
+ *   }
+ * } );
+ *
+ * assert( response, 'the value sent back via the api' );
+ * ```
+ *
+ * @remarks
+ * - Only callable from within a workflow function; do not use in steps or evaluators.
+ * - Steps and evaluators are activity-based and are not designed to be paused.
+ * - If used within steps or evaluators, a compilation error will be raised.
+ * - Uses a Temporal Activity to dispatch the HTTP request, working around the runtime limitation for workflows.
+ * - Uses a Temporal Trigger to pause the workflow.
+ * - Uses a Temporal Signal to resume the workflow when the API responds.
+ *
+ * @param params - Parameters object
+ * @param params.url - Request URL
+ * @param params.payload - Request payload
+ * @param params.headers - Headers for the request
+ * @returns Resolves with the payload received by the webhook
+ */
+export declare function sendPostRequestAndAwaitWebhook( params: {
+  url: string;
+  payload?: object;
+  headers?: Record<string, string>;
+} ): Promise<unknown>;
+
+/**
+ * Send an HTTP request to a URL.
+ *
+ * For POST or PUT requests, an optional payload can be sent as the body.
+ *
+ * The "Content-Type" is inferred from the payload type and can be overridden via the `headers` argument.
+ *
+ * If the body is not a type natively accepted by the Fetch API, it is serialized to a string: `JSON.stringify()` for objects, or `String()` for primitives.
+ *
+ * @remarks
+ * - Intended for use within workflow functions; do not use in steps or evaluators.
+ * - Steps and evaluators are activity-based and can perform HTTP requests directly.
+ * - If used within steps or evaluators, a compilation error will be raised.
+ * - Uses a Temporal Activity to dispatch the HTTP request, working around the runtime limitation for workflows.
+ *
+ * @param params - Parameters object
+ * @param params.url - Request URL
+ * @param params.method - The HTTP method (default: 'GET')
+ * @param params.payload - Request payload (only for POST/PUT)
+ * @param params.headers - Headers for the request
+ * @returns Resolves with an HTTP response serialized to a plain object
  */
-export declare function createWebhook( params: { url: string; payload?: object } ): Promise<object>;
+export declare function sendHttpRequest( params: {
+  url: string;
+  method?: HttpMethod;
+  payload?: object;
+  headers?: Record<string, string>;
+} ): Promise<SerializedFetchResponse>;
 
 /*
 ╭─────────────╮

package/src/index.js

@@ -1,7 +1,7 @@
 import { evaluator, EvaluationStringResult, EvaluationNumberResult, EvaluationBooleanResult } from './interface/evaluator.js';
 import { step } from './interface/step.js';
 import { workflow } from './interface/workflow.js';
-import { createWebhook } from './interface/webhook.js';
+import { sendHttpRequest, sendPostRequestAndAwaitWebhook } from './interface/webhook.js';
 import { FatalError, ValidationError } from './errors.js';
 export { continueAsNew, sleep } from '@temporalio/workflow';
 import { z } from 'zod';
@@ -15,8 +15,9 @@ export {
   EvaluationNumberResult,
   EvaluationStringResult,
   EvaluationBooleanResult,
-  // webhook tool
-  createWebhook,
+  // webhook tools
+  sendHttpRequest,
+  sendPostRequestAndAwaitWebhook,
   // errors
   FatalError,
   ValidationError,

package/src/interface/evaluator.js

@@ -34,11 +34,17 @@ export class EvaluationResult {
    */
   reasoning = undefined;
 
-  static #schema = z.object( {
-    value: z.any(),
-    confidence: z.number(),
-    reasoning: z.string().optional()
-  } );
+  static get valueSchema() {
+    return z.any();
+  };
+
+  static get schema() {
+    return z.object( {
+      value: this.valueSchema,
+      confidence: z.number(),
+      reasoning: z.string().optional()
+    } );
+  };
 
   /**
    * @constructor
@@ -48,7 +54,7 @@ export class EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationResult.#schema.safeParse( args );
+    const result = this.constructor.schema.safeParse( args );
     if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
@@ -64,7 +70,9 @@ export class EvaluationResult {
  * @property {string} value - The evaluation result value
  */
 export class EvaluationStringResult extends EvaluationResult {
-  static #valueSchema = z.string();
+  static get valueSchema() {
+    return z.string();
+  };
 
   /**
    * @constructor
@@ -74,10 +82,6 @@ export class EvaluationStringResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationStringResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -88,7 +92,9 @@ export class EvaluationStringResult extends EvaluationResult {
  * @property {boolean} value - The evaluation result value
  */
 export class EvaluationBooleanResult extends EvaluationResult {
-  static #valueSchema = z.boolean();
+  static get valueSchema() {
+    return z.boolean();
+  };
 
   /**
    * @constructor
@@ -98,10 +104,6 @@ export class EvaluationBooleanResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationBooleanResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -112,7 +114,9 @@ export class EvaluationBooleanResult extends EvaluationResult {
  * @property {number} value - The evaluation result value
  */
 export class EvaluationNumberResult extends EvaluationResult {
-  static #valueSchema = z.number();
+  static get valueSchema() {
+    return z.number();
+  };
 
   /**
    * @constructor
@@ -122,10 +126,6 @@ export class EvaluationNumberResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    const result = EvaluationNumberResult.#valueSchema.safeParse( args.value );
-    if ( result.error ) {
-      throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
-    }
     super( args );
   }
 };
@@ -138,7 +138,7 @@ export function evaluator( { name, description, inputSchema, fn, options } ) {
 
     const output = await fn( input );
 
-    if ( !output instanceof EvaluationResult ) {
+    if ( !( output instanceof EvaluationResult ) ) {
       throw new ValidationError( 'Evaluators must return an EvaluationResult' );
     }
 

package/src/interface/evaluator.spec.js

@@ -0,0 +1,103 @@
+import { describe, it, expect } from 'vitest';
+import {
+  EvaluationResult,
+  EvaluationStringResult,
+  EvaluationNumberResult,
+  EvaluationBooleanResult
+} from './evaluator.js';
+import { ValidationError } from '#errors';
+
+describe( 'interface/evaluator - EvaluationResult classes', () => {
+  describe( 'class inheritance', () => {
+    it( 'subclasses extend EvaluationResult', () => {
+      const s = new EvaluationStringResult( { value: 'ok', confidence: 0.8 } );
+      const n = new EvaluationNumberResult( { value: 42, confidence: 1 } );
+      const b = new EvaluationBooleanResult( { value: true, confidence: 0.5 } );
+
+      expect( s ).toBeInstanceOf( EvaluationResult );
+      expect( n ).toBeInstanceOf( EvaluationResult );
+      expect( b ).toBeInstanceOf( EvaluationResult );
+    } );
+  } );
+
+  describe( 'constructor payload validation', () => {
+    it( 'base class validates presence and types of common fields', () => {
+      // valid
+      const base = new EvaluationResult( { value: { any: 'thing' }, confidence: 0.1 } );
+      expect( base.value ).toEqual( { any: 'thing' } );
+      expect( base.confidence ).toBe( 0.1 );
+      expect( base.reasoning ).toBeUndefined();
+
+      // invalid: missing confidence
+      expect( () => new EvaluationResult( { value: 1 } ) ).toThrow( ValidationError );
+
+      // invalid: confidence wrong type
+      expect( () => new EvaluationResult( { value: 'x', confidence: 'nope' } ) ).toThrow( ValidationError );
+
+      // invalid: reasoning wrong type
+      expect( () => new EvaluationResult( { value: 'x', confidence: 1, reasoning: 123 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'string subclass enforces string value', () => {
+      // valid
+      const r = new EvaluationStringResult( { value: 'hello', confidence: 0.9 } );
+      expect( r.value ).toBe( 'hello' );
+
+      // invalid
+      expect( () => new EvaluationStringResult( { value: 123, confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'number subclass enforces number value', () => {
+      // valid
+      const r = new EvaluationNumberResult( { value: 123, confidence: 0.2 } );
+      expect( r.value ).toBe( 123 );
+
+      // invalid
+      expect( () => new EvaluationNumberResult( { value: 'nope', confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+
+    it( 'boolean subclass enforces boolean value', () => {
+      // valid
+      const r = new EvaluationBooleanResult( { value: true, confidence: 1 } );
+      expect( r.value ).toBe( true );
+
+      // invalid
+      expect( () => new EvaluationBooleanResult( { value: 'nope', confidence: 0.2 } ) ).toThrow( ValidationError );
+    } );
+  } );
+
+  describe( 'static schema getter', () => {
+    it( 'base schema accepts any value and optional reasoning', () => {
+      const ok = EvaluationResult.schema.safeParse( { value: 'x', confidence: 0.5, reasoning: 'why' } );
+      expect( ok.success ).toBe( true );
+
+      const ok2 = EvaluationResult.schema.safeParse( { value: 123, confidence: 0.5 } );
+      expect( ok2.success ).toBe( true );
+    } );
+
+    it( 'string schema requires value to be string', () => {
+      const ok = EvaluationStringResult.schema.safeParse( { value: 'x', confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationStringResult.schema.safeParse( { value: 123, confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+
+    it( 'number schema requires value to be number', () => {
+      const ok = EvaluationNumberResult.schema.safeParse( { value: 10, confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationNumberResult.schema.safeParse( { value: '10', confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+
+    it( 'boolean schema requires value to be boolean', () => {
+      const ok = EvaluationBooleanResult.schema.safeParse( { value: false, confidence: 1 } );
+      expect( ok.success ).toBe( true );
+
+      const bad = EvaluationBooleanResult.schema.safeParse( { value: 'false', confidence: 1 } );
+      expect( bad.success ).toBe( false );
+    } );
+  } );
+} );
+

package/src/interface/validations/static.js

@@ -55,9 +55,11 @@ const stepAndWorkflowSchema = z.strictObject( {
 
 const evaluatorSchema = stepAndWorkflowSchema.omit( { outputSchema: true } );
 
-const webhookSchema = z.object( {
+const httpRequestSchema = z.object( {
   url: z.url( { protocol: /^https?$/ } ),
-  payload: z.any().optional()
+  method: z.enum( [ 'GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE' ] ),
+  payload: z.any().optional(),
+  headers: z.record( z.string(), z.string() ).optional()
 } );
 
 const validateAgainstSchema = ( schema, args ) => {
@@ -98,11 +100,11 @@ export function validateWorkflow( args ) {
 };
 
 /**
- * Validate createWebhook payload
+ * Validate request payload
  *
- * @param {object} args - The createWebhook arguments
+ * @param {object} args - The request arguments
  * @throws {StaticValidationError} Throws if args are invalid
  */
-export function validateCreateWebhook( args ) {
-  validateAgainstSchema( webhookSchema, args );
+export function validateRequestPayload( args ) {
+  validateAgainstSchema( httpRequestSchema, args );
 };

package/src/interface/validations/static.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'vitest';
 import { z } from 'zod';
-import { validateStep, validateWorkflow, validateCreateWebhook, validateEvaluator, StaticValidationError } from './static.js';
+import { validateStep, validateWorkflow, validateRequestPayload, validateEvaluator, StaticValidationError } from './static.js';
 
 const validArgs = Object.freeze( {
   name: 'valid_name',
@@ -186,28 +186,77 @@ describe( 'interface/validator', () => {
     } );
   } );
 
-  describe( 'validate webhook', () => {
+  describe( 'validate request', () => {
     it( 'passes with valid http url', () => {
-      expect( () => validateCreateWebhook( { url: 'http://example.com' } ) ).not.toThrow();
+      expect( () => validateRequestPayload( { url: 'http://example.com', method: 'GET' } ) ).not.toThrow();
     } );
 
     it( 'passes with valid https url', () => {
-      expect( () => validateCreateWebhook( { url: 'https://example.com/path?q=1' } ) ).not.toThrow();
+      expect( () => validateRequestPayload( { url: 'https://example.com/path?q=1', method: 'GET' } ) ).not.toThrow();
     } );
 
     it( 'rejects missing url', () => {
       const error = new StaticValidationError( '✖ Invalid input: expected string, received undefined\n  → at url' );
-      expect( () => validateCreateWebhook( { } ) ).toThrow( error );
+      expect( () => validateRequestPayload( { method: 'GET' } ) ).toThrow( error );
     } );
 
     it( 'rejects invalid scheme', () => {
       const error = new StaticValidationError( '✖ Invalid URL\n  → at url' );
-      expect( () => validateCreateWebhook( { url: 'ftp://example.com' } ) ).toThrow( error );
+      expect( () => validateRequestPayload( { url: 'ftp://example.com', method: 'GET' } ) ).toThrow( error );
     } );
 
     it( 'rejects malformed url', () => {
       const error = new StaticValidationError( '✖ Invalid URL\n  → at url' );
-      expect( () => validateCreateWebhook( { url: 'http:////' } ) ).toThrow( error );
+      expect( () => validateRequestPayload( { url: 'http:////', method: 'GET' } ) ).toThrow( error );
+    } );
+
+    it( 'rejects missing method', () => {
+      expect( () => validateRequestPayload( { url: 'https://example.com' } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'passes with headers as string map', () => {
+      const request = {
+        url: 'https://example.com',
+        method: 'GET',
+        headers: { 'x-api-key': 'abc', accept: 'application/json' }
+      };
+      expect( () => validateRequestPayload( request ) ).not.toThrow();
+    } );
+
+    it( 'rejects non-object headers', () => {
+      const request = {
+        url: 'https://example.com',
+        method: 'GET',
+        headers: 5
+      };
+      expect( () => validateRequestPayload( request ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'rejects headers with non-string values', () => {
+      const request = {
+        url: 'https://example.com',
+        method: 'GET',
+        headers: { 'x-num': 123 }
+      };
+      expect( () => validateRequestPayload( request ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'passes with payload object', () => {
+      const request = {
+        url: 'https://example.com/api',
+        method: 'POST',
+        payload: { a: 1, b: 'two' }
+      };
+      expect( () => validateRequestPayload( request ) ).not.toThrow();
+    } );
+
+    it( 'passes with payload string', () => {
+      const request = {
+        url: 'https://example.com/upload',
+        method: 'POST',
+        payload: 'raw-body'
+      };
+      expect( () => validateRequestPayload( request ) ).not.toThrow();
     } );
   } );
 } );

package/src/interface/webhook.js

@@ -1,31 +1,64 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { defineSignal, setHandler, proxyActivities, workflowInfo, proxySinks, uuid4 } from '@temporalio/workflow';
-import { ACTIVITY_SEND_WEBHOOK } from '#consts';
+import { defineSignal, setHandler, proxyActivities, workflowInfo, proxySinks, uuid4, Trigger } from '@temporalio/workflow';
+import { ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 import { FatalError } from '#errors';
-import { validateCreateWebhook } from './validations/static.js';
+import { validateRequestPayload } from './validations/static.js';
 
-export async function createWebhook( { url, payload } ) {
-  validateCreateWebhook( { url, payload } );
-  const { workflowId } = workflowInfo();
-
-  await proxyActivities( {
+/**
+ * Call the internal activity to make a HTTP request and returns its response.
+ *
+ * @param {Object} parameters
+ * @param {string} url
+ * @param {string} method
+ * @param {unknown} [payload]
+ * @param {object} [headers]
+ * @returns {Promise<object>} The serialized HTTP response
+ */
+export async function sendHttpRequest( { url, method = 'GET', payload = undefined, headers = undefined } ) {
+  validateRequestPayload( { method, url, payload, headers } );
+  const res = await proxyActivities( {
     startToCloseTimeout: '3m',
     retry: {
       initialInterval: '15s',
-      maximumAttempts: 5,
+      maximumAttempts: 3,
       nonRetryableErrorTypes: [ FatalError.name ]
     }
-  } )[ACTIVITY_SEND_WEBHOOK]( { url, workflowId, payload } );
+  } )[ACTIVITY_SEND_HTTP_REQUEST]( { method, url, payload, headers } );
+  return res;
+};
+
+/**
+ * Call the internal activity to make a POST request sending a payload to a given url.
+ *
+ * After the request succeeds, pause the code using Trigger and wait for a Signal to un-pause it.
+ *
+ * The signal will be sent by the API when a response is sent to its webhook url.
+ *
+ * @param {Object} parameters
+ * @param {string} url
+ * @param {unknown} [payload]
+ * @param {object} [headers]
+ * @returns {Promise<unknown>} The response received by the webhook
+ */
+export async function sendPostRequestAndAwaitWebhook( { url, payload = undefined, headers = undefined } ) {
+  const { workflowId } = workflowInfo();
+  const wrappedPayload = { workflowId, payload };
+
+  await sendHttpRequest( { method: 'POST', url, payload: wrappedPayload, headers } );
 
   const sinks = await proxySinks();
+  const resumeTrigger = new Trigger();
   const resumeSignal = defineSignal( 'resume' );
 
-  const traceId = `${workflowId}-${url}-${uuid4}`;
+  const traceId = `${workflowId}-${url}-${uuid4()}`;
   sinks.trace.addEventStart( { id: traceId, name: 'resume', kind: 'webhook' } );
-  return new Promise( resolve =>
-    setHandler( resumeSignal, responsePayload => {
-      sinks.trace.addEventEnd( { id: traceId, details: responsePayload } );
-      resolve( responsePayload );
-    } )
-  );
+
+  setHandler( resumeSignal, webhookPayload => {
+    if ( !resumeTrigger.resolved ) {
+      sinks.trace.addEventEnd( { id: traceId, details: webhookPayload } );
+      resumeTrigger.resolve( webhookPayload );
+    }
+  } );
+
+  return resumeTrigger;
 };