@output.ai/core 0.1.18-dev.pr32-foo → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.1.18-dev.pr32-foo",
+  "version": "0.2.0",
   "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,11 +1,46 @@
 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.
  */
 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.
+ *
+ * @example
+ * ```ts
+ * import { sleep } from '@output.ai/core';
+ *
+ * for ( const url of urls ) {
+ *   await fetchUrl( url );
+ *   await sleep( 100 ); // 100ms delay between calls
+ * }
+ * ```
+ *
+ * @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
+ *
+ */
+export function sleep( ms: number | string ): Promise<void>;
+
+/**
+ * Continue the workflow as a new execution with fresh history.
+ *
+ * Re-exported from Temporal for advanced use cases. Prefer using
+ * `context.control.continueAsNew()` within workflows for type-safe usage.
+ *
+ * @see {@link https://docs.temporal.io/develop/typescript/continue-as-new}
+ */
+export { continueAsNew } from '@temporalio/workflow';
+
 /*
 ╭─────────────────────────╮
 │ C O M M O N  T Y P E S  │╮
@@ -18,6 +53,11 @@ export { z } from 'zod';
  */
 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.
  *
@@ -132,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)
@@ -371,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).
@@ -522,6 +570,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
@@ -549,17 +603,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>;
 
 /*
 ╭─────────────╮
@@ -573,7 +692,7 @@ export declare function createWebhook( params: { url: string; payload?: object }
  *
  * Throw this error to end the workflow execution altogether without retries.
  */
-export class FatalError extends Error {}
+export class FatalError extends Error { }
 
 /**
  * Error indicating invalid input or schema validation issues.
@@ -582,4 +701,4 @@ export class FatalError extends Error {}
  *
  * It will end the workflow execution without retries.
  */
-export class ValidationError extends Error {}
+export class ValidationError extends Error { }

package/src/index.js

@@ -1,9 +1,9 @@
 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 } from '@temporalio/workflow';
+export { continueAsNew, sleep } from '@temporalio/workflow';
 import { z } from 'zod';
 
 export {
@@ -15,8 +15,9 @@ export {
   EvaluationNumberResult,
   EvaluationStringResult,
   EvaluationBooleanResult,
-  // webhook tool
-  createWebhook,
+  // webhook tools
+  sendHttpRequest,
+  sendPostRequestAndAwaitWebhook,
   // errors
   FatalError,
   ValidationError,

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;
 };

package/src/interface/webhook.spec.js

@@ -0,0 +1,122 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mocks for module aliases used by webhook.js
+vi.mock( '#consts', () => ( {
+  ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest'
+} ) );
+
+const validateRequestPayloadMock = vi.fn();
+vi.mock( './validations/static.js', () => ( {
+  validateRequestPayload: validateRequestPayloadMock
+} ) );
+
+// Minimal, legible mock of @temporalio/workflow APIs used by webhook.js
+const activityFnMock = vi.fn();
+const proxyActivitiesMock = vi.fn( () => ( { ['__internal#sendHttpRequest']: activityFnMock } ) );
+
+const storedHandlers = new Map();
+const defineSignalMock = name => name;
+const setHandlerMock = ( signal, fn ) => {
+  storedHandlers.set( signal, fn );
+};
+
+const workflowInfoMock = vi.fn( () => ( { workflowId: 'wf-123' } ) );
+const sinks = { trace: { addEventStart: vi.fn(), addEventEnd: vi.fn() } };
+const proxySinksMock = vi.fn( async () => sinks );
+
+class TestTrigger {
+  constructor() {
+    this.resolved = false;
+    this._resolve = () => {};
+    this.promise = new Promise( res => {
+      this._resolve = res;
+    } );
+  }
+  resolve( value ) {
+    if ( !this.resolved ) {
+      this.resolved = true;
+      this._resolve( value );
+    }
+  }
+  then( onFulfilled, onRejected ) {
+    return this.promise.then( onFulfilled, onRejected );
+  }
+}
+
+vi.mock( '@temporalio/workflow', () => ( {
+  defineSignal: defineSignalMock,
+  setHandler: setHandlerMock,
+  proxyActivities: proxyActivitiesMock,
+  workflowInfo: workflowInfoMock,
+  proxySinks: proxySinksMock,
+  uuid4: () => 'uuid-mock',
+  Trigger: TestTrigger
+} ) );
+
+describe( 'interface/webhook', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    storedHandlers.clear();
+  } );
+
+  it( 'sendHttpRequest validates input and calls activity with correct options and args', async () => {
+    const { sendHttpRequest } = await import( './webhook.js' );
+
+    const fakeSerializedResponse = {
+      url: 'https://example.com',
+      status: 200,
+      statusText: 'OK',
+      ok: true,
+      headers: { 'content-type': 'application/json' },
+      body: { ok: true }
+    };
+    activityFnMock.mockResolvedValueOnce( fakeSerializedResponse );
+
+    const args = { url: 'https://example.com/api', method: 'GET' };
+    const res = await sendHttpRequest( args );
+
+    // validated
+    expect( validateRequestPayloadMock ).toHaveBeenCalledWith( { ...args, payload: undefined, headers: undefined } );
+
+    // activity proxied with specified options
+    expect( proxyActivitiesMock ).toHaveBeenCalledTimes( 1 );
+    const optionsArg = proxyActivitiesMock.mock.calls[0][0];
+    expect( optionsArg.startToCloseTimeout ).toBe( '3m' );
+    expect( optionsArg.retry ).toEqual( expect.objectContaining( {
+      initialInterval: '15s',
+      maximumAttempts: 3,
+      nonRetryableErrorTypes: expect.arrayContaining( [ 'FatalError' ] )
+    } ) );
+
+    // activity invoked with the same args
+    expect( activityFnMock ).toHaveBeenCalledWith( { ...args, payload: undefined, headers: undefined } );
+    expect( res ).toEqual( fakeSerializedResponse );
+  } );
+
+  it( 'sendPostRequestAndAwaitWebhook posts wrapped payload and resolves on resume signal', async () => {
+    const { sendPostRequestAndAwaitWebhook } = await import( './webhook.js' );
+
+    // Make the inner activity resolve (through sendHttpRequest)
+    activityFnMock.mockResolvedValueOnce( {
+      url: 'https://webhook.site',
+      status: 200,
+      statusText: 'OK',
+      ok: true,
+      headers: {},
+      body: null
+    } );
+
+    const url = 'https://webhook.site/ingest';
+    const promise = sendPostRequestAndAwaitWebhook( { url, payload: { x: 1 }, headers: { a: 'b' } } );
+
+    // The activity was called via sendHttpRequest with POST and wrapped payload
+    const callArgs = activityFnMock.mock.calls[0][0];
+    expect( callArgs.method ).toBe( 'POST' );
+    expect( callArgs.url ).toBe( url );
+    expect( callArgs.payload ).toEqual( { workflowId: 'wf-123', payload: { x: 1 } } );
+    expect( callArgs.headers ).toEqual( { a: 'b' } );
+
+    // Returns a promise (async function) for the eventual webhook result
+    expect( typeof promise.then ).toBe( 'function' );
+  } );
+} );

package/src/internal_activities/index.js

@@ -1,45 +1,67 @@
 import { FatalError } from '#errors';
-import { setMetadata, isStringboolTrue } from '#utils';
+import { fetch } from 'undici';
+import { setMetadata, isStringboolTrue, serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
 import { ComponentType } from '#consts';
 import * as localProcessor from '../tracing/processors/local/index.js';
 import * as s3Processor from '../tracing/processors/s3/index.js';
 
 /**
- * Send a post to a given URL
+ * Send a HTTP request.
  *
  * @param {object} options
  * @param {string} options.url - The target url
- * @param {string} options.workflowId - The current workflow id
- * @param {any} options.payload - The payload to send url
+ * @param {string} options.method - The HTTP method
+ * @param {unknown} [options.payload] - The payload to send url
+ * @param {object} [options.headers] - The headers for the request
+ * @param {number} [options.timeout] - The timeout for the request (default 30s)
+ * @returns {object} The serialized HTTP response
  * @throws {FatalError}
  */
-export const sendWebhook = async ( { url, workflowId, payload } ) => {
-  const request = fetch( url, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json'
-    },
-    body: JSON.stringify( { workflowId, payload } ),
-    signal: AbortSignal.timeout( 5000 )
-  } );
-
-  const res = await ( async () => {
+export const sendHttpRequest = async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
+  const args = {
+    method,
+    headers: new Headers( headers ?? {} ),
+    signal: AbortSignal.timeout( timeout )
+  };
+
+  const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
+  const hasBodyPayload = ![ undefined, null ].includes( payload );
+  if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
+    const { body, contentType } = serializeBodyAndInferContentType( payload );
+    if ( contentType && !args.headers.has( 'content-type' ) ) {
+      args.headers.set( 'Content-Type', contentType );
+    }
+    Object.assign( args, { body } );
+  };
+
+  const response = await ( async () => {
     try {
-      return await request;
-    } catch {
-      throw new FatalError( 'Webhook fail: timeout' );
+      return await fetch( url, args );
+    } catch ( e ) {
+      throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
     }
   } )();
 
-  console.log( '[Core.SendWebhook]', res.status, res.statusText );
+  console.log( '[Core.sendHttpRequest]', response.status, response.statusText );
 
-  if ( !res.ok ) {
-    throw new FatalError( `Webhook fail: ${res.status}` );
+  if ( !response.ok ) {
+    throw new FatalError( `${method} ${url} ${response.status}` );
   }
+
+  return serializeFetchResponse( response );
 };
 
-setMetadata( sendWebhook, { type: ComponentType.INTERNAL_STEP } );
+setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
 
+/**
+ * Resolve and return all possible trace destinations based on env var flags
+ *
+ * @param {Object} options
+ * @param {Date} startTime - Workflow startTime
+ * @param {string} workflowId
+ * @param {string} workflowName
+ * @returns {object} Information about enabled workflows
+ */
 export const getTraceDestinations = ( { startTime, workflowId, workflowName } ) => ( {
   local: isStringboolTrue( process.env.TRACE_LOCAL_ON ) ? localProcessor.getDestination( { startTime, workflowId, workflowName } ) : null,
   remote: isStringboolTrue( process.env.TRACE_REMOTE_ON ) ? s3Processor.getDestination( { startTime, workflowId, workflowName } ) : null