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

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,41 +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 id - A unique id for the Event, must be the same across all phases: start, end, error.
-   * @param kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
-   * @param name - The human friendly name of the Event: query, request, create.
-   * @param details - All details attached to this Event Phase. DB queried records, HTTP response body.
+   * @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 id - A unique id for the Event, must be the same across all phases: start, end, error.
-   * @param details - All details attached to this Event Phase. DB queried records, HTTP response body.
-   * @returns
+   * @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 id - A unique id for the Event, must be the same across all phases: start, end, error.
-   * @param details - All details attached to this Event Phase. DB queried records, HTTP response body.
-   * @returns
+   * @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 );

package/src/tracing/processors/local/temp/traces/1767713888257_continue_as_new-19b2e908-d403-438f-af77-080d43823bea.trace

@@ -1,4 +0,0 @@
-{"kind":"workflow","phase":"start","name":"continue_as_new","id":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713888277,"details":{"value":1}}
-{"kind":"step","phase":"start","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713888285,"details":1}
-{"kind":"step","phase":"end","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713888285,"details":2}
-{"kind":"workflow","phase":"end","name":"continue_as_new","id":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713888293,"details":"<continued_as_new>"}

package/src/tracing/processors/local/temp/traces/1767713888294_continue_as_new-19b2e908-d403-438f-af77-080d43823bea.trace

@@ -1,6 +0,0 @@
-{"kind":"workflow","phase":"start","name":"continue_as_new","id":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713889325,"details":{"value":2}}
-{"kind":"step","phase":"start","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713889333,"details":2}
-{"kind":"step","phase":"end","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713889334,"details":3}
-{"kind":"internal_step","phase":"start","name":"__internal#getTraceDestinations","id":"2","parentId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713889345,"details":{"startTime":"2026-01-06T15:38:08.294Z","workflowId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","workflowName":"continue_as_new"}}
-{"kind":"internal_step","phase":"end","name":"__internal#getTraceDestinations","id":"2","parentId":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713889345,"details":{"local":"/Users/sz/Dev/output/test_workflows/logs/runs/continue_as_new/2026-01-06-15-38-08-294Z_continue_as_new-19b2e908-d403-438f-af77-080d43823bea.json","remote":null}}
-{"kind":"workflow","phase":"end","name":"continue_as_new","id":"continue_as_new-19b2e908-d403-438f-af77-080d43823bea","timestamp":1767713889351,"details":{"output":{"result":3},"trace":{"destinations":{"local":"/Users/sz/Dev/output/test_workflows/logs/runs/continue_as_new/2026-01-06-15-38-08-294Z_continue_as_new-19b2e908-d403-438f-af77-080d43823bea.json","remote":null}}}}

package/src/tracing/processors/local/temp/traces/1767728879418_continue_as_new-20b3caf3-bdfe-4083-9840-95b8cb669c7c.trace

@@ -1,3 +0,0 @@
-{"kind":"workflow","phase":"start","name":"continue_as_new","id":"continue_as_new-20b3caf3-bdfe-4083-9840-95b8cb669c7c","timestamp":1767728879442,"details":{"value":1}}
-{"kind":"step","phase":"start","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-20b3caf3-bdfe-4083-9840-95b8cb669c7c","timestamp":1767728879450,"details":1}
-{"kind":"step","phase":"end","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-20b3caf3-bdfe-4083-9840-95b8cb669c7c","timestamp":1767728879451,"details":2}

package/src/tracing/processors/local/temp/traces/1767728961526_continue_as_new-5e315608-6e29-42c5-b79a-05f82b437b40.trace

@@ -1,4 +0,0 @@
-{"kind":"workflow","phase":"start","name":"continue_as_new","id":"continue_as_new-5e315608-6e29-42c5-b79a-05f82b437b40","timestamp":1767728961548,"details":{"value":1}}
-{"kind":"step","phase":"start","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-5e315608-6e29-42c5-b79a-05f82b437b40","timestamp":1767728961556,"details":1}
-{"kind":"step","phase":"end","name":"/app/test_workflows/dist/continue_as_new#increment","id":"1","parentId":"continue_as_new-5e315608-6e29-42c5-b79a-05f82b437b40","timestamp":1767728961557,"details":2}
-{"kind":"workflow","phase":"end","name":"continue_as_new","id":"continue_as_new-5e315608-6e29-42c5-b79a-05f82b437b40","timestamp":1767728961567,"details":"<continued_as_new>"}