@output.ai/core 0.1.18 → 0.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.1.18",
+  "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,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).
@@ -553,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
@@ -580,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.
+ *
+ * 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
+ * }
+ * ```
+ *
+ * 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.
  *
- * Sends a request via an activity; the workflow will await a corresponding
- * resume signal to continue and return the response payload.
+ * For POST or PUT requests, an optional payload can be sent as the body.
  *
- * @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
+ * 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/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

package/src/internal_activities/index.spec.js

@@ -0,0 +1,99 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { MockAgent, setGlobalDispatcher } from 'undici';
+import { FatalError } from '#errors';
+import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
+import { sendHttpRequest } from './index.js';
+
+vi.mock( '#utils', () => {
+  return {
+    setMetadata: vi.fn(),
+    isStringboolTrue: vi.fn( () => false ),
+    serializeBodyAndInferContentType: vi.fn(),
+    serializeFetchResponse: vi.fn()
+  };
+} );
+
+const mockAgent = new MockAgent();
+mockAgent.disableNetConnect();
+
+setGlobalDispatcher( mockAgent );
+
+const url = 'https://growthx.ai';
+const method = 'GET';
+
+describe( 'internal_activities/sendHttpRequest', () => {
+  beforeEach( async () => {
+    vi.restoreAllMocks();
+    vi.clearAllMocks();
+  } );
+
+  it( 'succeeds and returns serialized JSON response', async () => {
+    const payload = { a: 1 };
+    const method = 'POST';
+
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .reply( 200, JSON.stringify( { ok: true, value: 42 } ), {
+        headers: { 'content-type': 'application/json' }
+      } );
+
+    // mock utils
+    serializeBodyAndInferContentType.mockReturnValueOnce( {
+      body: JSON.stringify( payload ),
+      contentType: 'application/json; charset=UTF-8'
+    } );
+    const fakeSerialized = { sentinel: true };
+    serializeFetchResponse.mockResolvedValueOnce( fakeSerialized );
+
+    const result = await sendHttpRequest( { url, method, payload } );
+
+    // utils mocked: verify calls and returned value
+    expect( serializeBodyAndInferContentType ).toHaveBeenCalledTimes( 1 );
+    expect( serializeBodyAndInferContentType ).toHaveBeenCalledWith( payload );
+    expect( serializeFetchResponse ).toHaveBeenCalledTimes( 1 );
+    const respArg = serializeFetchResponse.mock.calls[0][0];
+    expect( respArg && typeof respArg.text ).toBe( 'function' );
+    expect( respArg.status ).toBe( 200 );
+    expect( respArg.headers.get( 'content-type' ) ).toContain( 'application/json' );
+    expect( result ).toBe( fakeSerialized );
+  } );
+
+  it( 'throws FatalError when response.ok is false', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } ).reply( 500, 'Internal error' );
+
+    await expect( sendHttpRequest( { url, method } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai 500' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+
+  it( 'throws FatalError on timeout failure', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .reply( 200, 'ok', { headers: { 'content-type': 'text/plain' } } )
+      .delay( 10_000 );
+
+    await expect( sendHttpRequest( { url, method, timeout: 250 } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai The operation was aborted due to timeout' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+
+  it( 'wraps DNS resolution errors (ENOTFOUND) preserving cause message', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .replyWithError( new Error( 'getaddrinfo ENOTFOUND nonexistent.example.test' ) );
+
+    await expect( sendHttpRequest( { url, method } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai Error: getaddrinfo ENOTFOUND nonexistent.example.test' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+
+  it( 'wraps TCP connection errors (ECONNREFUSED) preserving cause message', async () => {
+    mockAgent.get( url ).intercept( { path: '/', method } )
+      .replyWithError( new Error( 'connect ECONNREFUSED 127.0.0.1:65500' ) );
+
+    await expect( sendHttpRequest( { url, method } ) ).rejects
+      .toThrow( new FatalError( 'GET https://growthx.ai Error: connect ECONNREFUSED 127.0.0.1:65500' ) );
+    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
+  } );
+} );

package/src/tracing/index.d.ts

@@ -6,42 +6,42 @@
 */
 
 /**
- * The public namespace for tracing
+ * Public tracing API for recording event phases on the default trace of the current workflow.
  *
  * @namespace
  */
 export declare const Tracing: {
 
   /**
-   * Adds the start phase of a new event at the default trace for the current workflow.
+   * Record the start of an event on the default trace for the current workflow.
    *
-   * @param {string} id - A unique id for the Event, must be the same across all phases: start, end, error.
-   * @param {string} kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
-   * @param {string} name - The human friendly name of the Event: query, request, create.
-   * @param {any} details - All details attached to this Event Phase. DB queried records, HTTP response body.
-   * @returns {void}
+   * @param args - Event information
+   * @param args.id - A unique id for the Event, must be the same across all phases: start, end, error.
+   * @param args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
+   * @param args.name - The human friendly name of the Event: query, request, create.
+   * @param args.details - Arbitrary metadata associated with this phase (e.g., payloads, summaries).
    */
-  addEventStart( args: { id: string; kind: string; name: string; details: any } ): void; // eslint-disable-line @typescript-eslint/no-explicit-any
+  addEventStart( args: { id: string; kind: string; name: string; details: unknown } ): void;
 
   /**
-   * Adds the end phase at an event at the default trace for the current workflow.
+   * Record the end of an event on the default trace for the current workflow.
    *
-   * It needs to use the same id of the start phase.
+   * Use the same id as the start phase to correlate phases.
    *
-   * @param {string} id - A unique id for the Event, must be the same across all phases: start, end, error.
-   * @param {any} details - All details attached to this Event Phase. DB queried records, HTTP response body.
-   * @returns {void}
+   * @param args - Event information
+   * @param args.id - Identifier matching the event's start phase.
+   * @param args.details - Arbitrary metadata associated with this phase (e.g., results, response body).
    */
-  addEventEnd( args: { id: string; details: any } ): void; // eslint-disable-line @typescript-eslint/no-explicit-any
+  addEventEnd( args: { id: string; details: unknown } ): void;
 
   /**
-   * Adds the error phase at an event as error at the default trace for the current workflow.
+   * Record an error for an event on the default trace for the current workflow.
    *
-   * It needs to use the same id of the start phase.
+   * Use the same id as the start phase to correlate phases.
    *
-   * @param {string} id - A unique id for the Event, must be the same across all phases: start, end, error.
-   * @param {any} details - All details attached to this Event Phase. DB queried records, HTTP response body.
-   * @returns {void}
+   * @param args - Event metadata for the error phase.
+   * @param args.id - Identifier matching the event's start phase.
+   * @param args.details - Arbitrary metadata associated with this phase, possible error info.
    */
-  addEventError( args: { id: string; details: any } ): void; // eslint-disable-line @typescript-eslint/no-explicit-any
+  addEventError( args: { id: string; details: unknown } ): void;
 };

package/src/utils/index.d.ts

@@ -1,30 +1,37 @@
 /**
- * Return the directory of the file invoking the code that called this function
- * Excludes `@output.ai/core`, node, and other internal paths
+ * Return the first immediate directory of the file invoking the code that called this function.
+ *
+ * Excludes `@output.ai/core`, node, and other internal paths.
  */
 export function resolveInvocationDir(): string;
 
 /**
- * Node safe clone implementation that doesn't use global structuredClone()
- * @param {object} v
- * @returns {object}
+ * Node safe clone implementation that doesn't use global structuredClone().
+ *
+ * Returns a cloned version of the object.
+ *
+ * Only clones static properties. Getters become static properties.
+ *
+ * @param object
  */
-export function clone( v: object ): object;
+export function clone( object: object ): object;
 
 /**
- * Throw given error
- * @param {Error} e
- * @throws {e}
+ * Receives an error as argument and throws it.
+ *
+ * @param error
+ * @throws {Error}
  */
-export function throws( e: Error ): void;
+export function throws( error: Error ): void;
 
 /**
- * Add metadata "values" property to a given object
- * @param {object} target
- * @param {object} values
+ * Attach given value to an object with the METADATA_ACCESS_SYMBOL symbol as key.
+ *
+ * @param target
+ * @param value
  * @returns
  */
-export function setMetadata( target: object, values: object ): void;
+export function setMetadata( target: object, value: object ): void;
 
 /**
  * Merge two temporal activity options
@@ -33,3 +40,41 @@ export function mergeActivityOptions(
   base?: import( '@temporalio/workflow' ).ActivityOptions,
   ext?: import( '@temporalio/workflow' ).ActivityOptions
 ): import( '@temporalio/workflow' ).ActivityOptions;
+
+/** Represents a {Response} serialized to plain object  */
+export type SerializedFetchResponse = {
+  /** The response url */
+  url: string,
+
+  /** The response status code */
+  status: number,
+
+  /** The response status text */
+  statusText: string,
+
+  /** Flag indicating if the request succeeded */
+  ok: boolean,
+
+  /** Object with response headers */
+  headers: Record<string, string>,
+
+  /** Response body, either JSON, text or arrayBuffer converter to base64 */
+  body: object | string
+};
+
+/**
+ * Consumes and HTTP Response and serialize it to a plain object
+ */
+export function serializeFetchResponse( response: Response ): SerializedFetchResponse;
+
+export type SerializedBodyAndContentType = {
+  /** The body parsed to string if possible or kept as the types allowed in fetch's POST body */
+  body: string | unknown,
+  /** The inferred content-type */
+  contentType: string | undefined
+};
+
+/**
+ * Based on the type of a payload, serialized it to be send as the body of a fetch POST request and also infer its Content Type.
+ */
+export function serializeBodyAndInferContentType( body: unknown ): SerializedBodyAndContentType;

package/src/utils/utils.js

@@ -42,3 +42,110 @@ export const mergeActivityOptions = ( base = {}, ext = {} ) =>
  * @returns
  */
 export const isStringboolTrue = v => [ '1', 'true', 'on' ].includes( v );
+
+/**
+ * Consume Fetch's HTTP Response and return a serialized version of it;
+ *
+ * @param {Response} response
+ * @returns {object} Serialized response
+ */
+export const serializeFetchResponse = async response => {
+  const headers = Object.fromEntries( response.headers );
+  const contentType = headers['content-type'] || '';
+
+  const body = await ( async () => {
+    if ( contentType.includes( 'application/json' ) ) {
+      return response.json();
+    }
+    if ( contentType.startsWith( 'text/' ) ) {
+      return response.text();
+    }
+    return response.arrayBuffer().then( buf => Buffer.from( buf ).toString( 'base64' ) );
+  } )();
+
+  return {
+    url: response.url,
+    status: response.status,
+    statusText: response.statusText,
+    ok: response.ok,
+    headers,
+    body
+  };
+};
+
+/**
+ * Duck-typing to detect a Node Readable (Stream) without importing anything
+ *
+ * @param {unknown} v
+ * @returns {boolean}
+ */
+const isReadable = v =>
+  typeof v === 'object' &&
+  typeof v?.read === 'function' &&
+  typeof v?.on === 'function' &&
+  typeof v?.pipe === 'function' &&
+  v?.readable !== false;
+
+/**
+ * Based on the type of a payload, serialized it to be send as the body of a fetch POST request and also infer its Content Type.
+ *
+ * Non serializable types versus Content-Type reference (for Node)
+ *
+ * |Type|Is self-describing)|Inferred type by fetch|Defined mime type|
+ * |-|-|-|-}
+ * |Blob|yes|`blob.type`||
+ * |File|yes|`file.type`||
+ * |FormData|yes|"multipart/form-data; boundary=..."||
+ * |URLSearchParams|yes|"application/x-www-form-urlencoded;charset=UTF-8"||
+ * |ArrayBuffer|no||"application/octet-stream"|
+ * |TypedArray (Uint8Array,Uint16Array)||"application/octet-stream"||
+ * |DataView|no||"application/octet-stream"|
+ * |ReadableStream, Readable, AsyncIterator|no||Can't, because stream must be read|
+ *
+ * If payload is none of the above types, test it:
+ * If the it is an object, serialize using JSON.stringify and set content-type to `application/json`;
+ * Else, it is a JS primitive, serialize using JSON.stringify and set content-type to `text/plain`;
+ *
+ * This implementation is overkill for temporal workflows since the only types available there will be:
+ * - URLSearchParams
+ * - ArrayBuffer
+ * - TypedArrays
+ * - DataView
+ * - asyncGenerator
+ * The others are non deterministic and are not available at runtime, but this function was build to be flexible
+ *
+ * @see {@link https://fetch.spec.whatwg.org/#bodyinit}
+ * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch}
+ *
+ * @param {unknown} payload
+ * @returns {object} An object with the serialized body and inferred content-type
+ */
+export const serializeBodyAndInferContentType = payload => {
+  const dataTypes = [ Blob, File, URLSearchParams, FormData ];
+
+  // empty body
+  if ( [ null, undefined ].includes( payload ) ) {
+    return { body: undefined, contentType: undefined };
+  }
+
+  // Buffer types, covers ArrayBuffer, TypedArrays and DataView
+  if ( payload instanceof ArrayBuffer || ArrayBuffer.isView( payload ) ) {
+    return { body: payload, contentType: 'application/octet-stream' };
+  }
+
+  // These data types auto assigned mime types
+  if ( dataTypes.some( t => payload instanceof t ) ) {
+    return { body: payload, contentType: undefined };
+  }
+
+  // ReadableStream, Readable and Async Iterator mimes cant be determined without reading it
+  if ( payload instanceof ReadableStream || typeof payload[Symbol.asyncIterator] === 'function' || isReadable( payload ) ) {
+    return { body: payload, contentType: undefined };
+  }
+
+  if ( typeof payload === 'object' ) {
+    return { body: JSON.stringify( payload ), contentType: 'application/json; charset=UTF-8' };
+  }
+
+  return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
+};

package/src/utils/utils.spec.js

@@ -1,5 +1,7 @@
 import { describe, it, expect } from 'vitest';
-import { clone, mergeActivityOptions } from './utils.js';
+import { Readable } from 'node:stream';
+import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse } from './utils.js';
+// Response is available globally in Node 18+ (undici)
 
 describe( 'clone', () => {
   it( 'produces a deep copy without shared references', () => {
@@ -14,6 +16,206 @@ describe( 'clone', () => {
   } );
 } );
 
+describe( 'serializeFetchResponse', () => {
+  it( 'serializes JSON response body and flattens headers', async () => {
+    const payload = { a: 1, b: 'two' };
+    const response = new Response( JSON.stringify( payload ), {
+      status: 200,
+      statusText: 'OK',
+      headers: { 'content-type': 'application/json' }
+    } );
+
+    const result = await serializeFetchResponse( response );
+    expect( result.status ).toBe( 200 );
+    expect( result.ok ).toBe( true );
+    expect( result.statusText ).toBe( 'OK' );
+    expect( result.headers['content-type'] ).toContain( 'application/json' );
+    expect( result.body ).toEqual( payload );
+  } );
+
+  it( 'serializes text/* response via text()', async () => {
+    const bodyText = 'hello world';
+    const response = new Response( bodyText, {
+      status: 201,
+      statusText: 'Created',
+      headers: { 'content-type': 'text/plain; charset=utf-8' }
+    } );
+
+    const result = await serializeFetchResponse( response );
+    expect( result.status ).toBe( 201 );
+    expect( result.ok ).toBe( true );
+    expect( result.statusText ).toBe( 'Created' );
+    expect( result.headers['content-type'] ).toContain( 'text/plain' );
+    expect( result.body ).toBe( bodyText );
+  } );
+
+  if ( typeof ReadableStream !== 'undefined' ) {
+    it( 'serializes ReadableStream body for text/* via text()', async () => {
+      const encoder = new TextEncoder();
+      const chunk = encoder.encode( 'streamed text' );
+      const stream = new ReadableStream( {
+        start( controller ) {
+          controller.enqueue( chunk );
+          controller.close();
+        }
+      } );
+      const response = new Response( stream, {
+        status: 200,
+        statusText: 'OK',
+        headers: { 'content-type': 'text/plain; charset=utf-8' }
+      } );
+
+      const result = await serializeFetchResponse( response );
+      expect( result.status ).toBe( 200 );
+      expect( result.ok ).toBe( true );
+      expect( result.statusText ).toBe( 'OK' );
+      expect( result.headers['content-type'] ).toContain( 'text/plain' );
+      expect( result.body ).toBe( 'streamed text' );
+    } );
+  }
+
+  it( 'serializes non-text/non-json response as base64 from arrayBuffer()', async () => {
+    const bytes = Uint8Array.from( [ 0, 1, 2, 3 ] );
+    const response = new Response( bytes, {
+      status: 200,
+      statusText: 'OK',
+      headers: { 'content-type': 'application/octet-stream' }
+    } );
+
+    const result = await serializeFetchResponse( response );
+    expect( result.status ).toBe( 200 );
+    expect( result.ok ).toBe( true );
+    expect( result.statusText ).toBe( 'OK' );
+    expect( result.headers['content-type'] ).toBe( 'application/octet-stream' );
+    expect( result.body ).toBe( Buffer.from( bytes ).toString( 'base64' ) );
+  } );
+
+  it( 'defaults to base64 when content-type header is missing', async () => {
+    const bytes = Uint8Array.from( [ 0, 1, 2, 3 ] );
+    const response = new Response( bytes, { status: 200 } );
+    // No headers set; content-type resolves to ''
+
+    const result = await serializeFetchResponse( response );
+    expect( result.headers['content-type'] ?? '' ).toBe( '' );
+    expect( result.body ).toBe( Buffer.from( bytes ).toString( 'base64' ) );
+  } );
+} );
+
+describe( 'serializeBodyAndInferContentType', () => {
+  it( 'returns undefineds for null payload', () => {
+    const { body, contentType } = serializeBodyAndInferContentType( null );
+    expect( body ).toBeUndefined();
+    expect( contentType ).toBeUndefined();
+  } );
+
+  it( 'returns undefineds for undefined payload', () => {
+    const { body, contentType } = serializeBodyAndInferContentType( undefined );
+    expect( body ).toBeUndefined();
+    expect( contentType ).toBeUndefined();
+  } );
+
+  it( 'handles ArrayBuffer with octet-stream', () => {
+    const buf = new ArrayBuffer( 4 );
+    const { body, contentType } = serializeBodyAndInferContentType( buf );
+    expect( body ).toBe( buf );
+    expect( contentType ).toBe( 'application/octet-stream' );
+  } );
+
+  it( 'handles TypedArray with octet-stream', () => {
+    const view = new Uint8Array( [ 1, 2, 3 ] );
+    const { body, contentType } = serializeBodyAndInferContentType( view );
+    expect( body ).toBe( view );
+    expect( contentType ).toBe( 'application/octet-stream' );
+  } );
+
+  it( 'handles DataView with octet-stream', () => {
+    const ab = new ArrayBuffer( 2 );
+    const dv = new DataView( ab );
+    const { body, contentType } = serializeBodyAndInferContentType( dv );
+    expect( body ).toBe( dv );
+    expect( contentType ).toBe( 'application/octet-stream' );
+  } );
+
+  // Environment-provided web types
+  if ( typeof URLSearchParams !== 'undefined' ) {
+    it( 'passes through URLSearchParams without content type', () => {
+      const usp = new URLSearchParams( { a: '1', b: 'two' } );
+      const { body, contentType } = serializeBodyAndInferContentType( usp );
+      expect( body ).toBe( usp );
+      expect( contentType ).toBeUndefined();
+    } );
+  }
+
+  if ( typeof FormData !== 'undefined' ) {
+    it( 'passes through FormData without content type', () => {
+      const fd = new FormData();
+      fd.append( 'a', '1' );
+      const { body, contentType } = serializeBodyAndInferContentType( fd );
+      expect( body ).toBe( fd );
+      expect( contentType ).toBeUndefined();
+    } );
+  }
+
+  if ( typeof Blob !== 'undefined' ) {
+    it( 'passes through Blob without content type', () => {
+      const blob = new Blob( [ 'abc' ], { type: 'text/plain' } );
+      const { body, contentType } = serializeBodyAndInferContentType( blob );
+      expect( body ).toBe( blob );
+      expect( contentType ).toBeUndefined();
+    } );
+  }
+
+  if ( typeof File !== 'undefined' ) {
+    it( 'passes through File without content type', () => {
+      const file = new File( [ 'abc' ], 'a.txt', { type: 'text/plain' } );
+      const { body, contentType } = serializeBodyAndInferContentType( file );
+      expect( body ).toBe( file );
+      expect( contentType ).toBeUndefined();
+    } );
+  }
+
+  it( 'passes through async iterator without content type', () => {
+    const asyncIter = ( async function *() {
+      yield 'chunk';
+    } )();
+    const { body, contentType } = serializeBodyAndInferContentType( asyncIter );
+    expect( typeof body[Symbol.asyncIterator] ).toBe( 'function' );
+    expect( contentType ).toBeUndefined();
+  } );
+
+  it( 'passes through Node Readable without content type', () => {
+    const readable = Readable.from( [ 'a', 'b' ] );
+    const { body, contentType } = serializeBodyAndInferContentType( readable );
+    expect( body ).toBe( readable );
+    expect( contentType ).toBeUndefined();
+  } );
+
+  it( 'serializes plain object as JSON with JSON content type', () => {
+    const input = { a: 1, b: 'two' };
+    const { body, contentType } = serializeBodyAndInferContentType( input );
+    expect( body ).toBe( JSON.stringify( input ) );
+    expect( contentType ).toBe( 'application/json; charset=UTF-8' );
+  } );
+
+  it( 'serializes string primitive with text/plain content type', () => {
+    const { body, contentType } = serializeBodyAndInferContentType( 'hello' );
+    expect( body ).toBe( 'hello' );
+    expect( contentType ).toBe( 'text/plain; charset=UTF-8' );
+  } );
+
+  it( 'serializes number primitive with text/plain content type', () => {
+    const { body, contentType } = serializeBodyAndInferContentType( 42 );
+    expect( body ).toBe( '42' );
+    expect( contentType ).toBe( 'text/plain; charset=UTF-8' );
+  } );
+
+  it( 'serializes boolean primitive with text/plain content type', () => {
+    const { body, contentType } = serializeBodyAndInferContentType( true );
+    expect( body ).toBe( 'true' );
+    expect( contentType ).toBe( 'text/plain; charset=UTF-8' );
+  } );
+} );
+
 describe( 'mergeActivityOptions', () => {
   it( 'recursively merges nested objects', () => {
     const base = {

package/src/worker/loader.js

@@ -2,10 +2,10 @@ import { basename, dirname, join } from 'node:path';
 import { mkdirSync, writeFileSync } from 'node:fs';
 import { EOL } from 'node:os';
 import { fileURLToPath } from 'url';
-import { getTraceDestinations, sendWebhook } from '#internal_activities';
+import { getTraceDestinations, sendHttpRequest } from '#internal_activities';
 import { importComponents } from './loader_tools.js';
 import {
-  ACTIVITY_SEND_WEBHOOK,
+  ACTIVITY_SEND_HTTP_REQUEST,
   ACTIVITY_OPTIONS_FILENAME,
   SHARED_STEP_PREFIX,
   WORKFLOWS_INDEX_FILENAME,
@@ -50,7 +50,7 @@ export async function loadActivities( target ) {
   writeActivityOptionsFile( activityOptionsMap );
 
   // system activities
-  activities[ACTIVITY_SEND_WEBHOOK] = sendWebhook;
+  activities[ACTIVITY_SEND_HTTP_REQUEST] = sendHttpRequest;
   activities[ACTIVITY_GET_TRACE_DESTINATIONS] = getTraceDestinations;
   return activities;
 };

package/src/worker/loader.spec.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
 vi.mock( '#consts', () => ( {
-  ACTIVITY_SEND_WEBHOOK: '__internal#sendWebhook',
+  ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest',
   ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   WORKFLOW_CATALOG: 'catalog',
@@ -9,10 +9,10 @@ vi.mock( '#consts', () => ( {
   SHARED_STEP_PREFIX: '/shared'
 } ) );
 
-const sendWebhookMock = vi.fn();
+const sendHttpRequestMock = vi.fn();
 const getTraceDestinationsMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhook: sendWebhookMock,
+  sendHttpRequest: sendHttpRequestMock,
   getTraceDestinations: getTraceDestinationsMock
 } ) );
 
@@ -40,7 +40,7 @@ describe( 'worker/loader', () => {
 
     const activities = await loadActivities( '/root' );
     expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
-    expect( activities['__internal#sendWebhook'] ).toBe( sendWebhookMock );
+    expect( activities['__internal#sendHttpRequest'] ).toBe( sendHttpRequestMock );
 
     // options file written with the collected map
     expect( writeFileSyncMock ).toHaveBeenCalledTimes( 1 );