@outputai/core 0.9.3-next.5289bca.0 → 0.9.3-next.c318502.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.9.3-next.5289bca.0",
+  "version": "0.9.3-next.c318502.0",
   "description": "The core module of the output framework",
   "type": "module",
   "engines": {

package/src/helpers/fetch.js

@@ -1,32 +1,79 @@
+import { FatalError } from '#errors';
+
+/** Matches red int "hot-red-pie", but not int "redact" */
+const wordMatcher = term => new RegExp( `(?<![a-z\\d])${term}(?![a-z\\d])`, 'i' );
+
+/** Matches red in "acquired", but not in "redact" */
+const wordEndMatcher = term => new RegExp( `${term}(?![a-z\\d])`, 'i' );
+
+/**
+ * Redacts sensitive headers
+ * @param {object} headers
+ * @returns {object} The redacted headers
+ */
+export const redactHeaders = headers => {
+  /** Header names that look sensitive by substring rules but are not secret material. */
+  const ignoreHeaders = new Set( [
+    'x-csrf-token',
+    'public-key-pins'
+  ] );
+
+  /** * Sensitive header patterns for redaction (case-insensitive). */
+  const sensitiveHeadersPatterns = [
+    // matches headers that contain these exact words
+    wordMatcher( 'authorization' ),
+    wordMatcher( 'token' ),
+    wordMatcher( 'secret' ),
+    wordMatcher( 'password' ),
+    wordMatcher( 'pwd' ),
+    wordMatcher( 'cookie' ),
+    // matches header that contain words ending with these sequences
+    wordEndMatcher( 'key' )
+  ];
+
+  return Object.entries( headers ).reduce( ( redacted, [ key, value ] ) => {
+    const lowKey = key.toLowerCase();
+    const isSensitive = !ignoreHeaders.has( lowKey ) && sensitiveHeadersPatterns.some( rx => rx.test( lowKey ) );
+    return Object.assign( redacted, { [key]: isSensitive ? '[REDACTED]' : value } );
+  }, {} );
+};
+
+/**
+ * Consume the body of a Response according it its content-type and returns it
+ * @param {Response} response
+ * @returns {string|object|undefined|null} The response body content
+ */
+const consumeBody = async response => {
+  const headers = Object.fromEntries( response.headers ) ?? {};
+  const contentType = ( headers['content-type'] ?? '' ).trim().toLowerCase();
+  const jsonMatcher = /^application\/(?:json|[^;\s]+?\+json)(?:\s*;.*)?$/i;
+  if ( jsonMatcher.test( contentType ) ) {
+    return response.json();
+  }
+  if ( contentType.startsWith( 'text/' ) ) {
+    return response.text();
+  }
+  return response.arrayBuffer().then( buf => Buffer.from( buf ).toString( 'base64' ) );
+};
+
 /**
  * Consume Fetch's HTTP Response and return a serialized version of it;
  *
  * @param {Response} response
+ * @param {options} responseOptions
+ * @param {boolean} responseOptions.includeBody - If the body must be included in the response (default false)
+ * @param {boolean} responseOptions.includeHeaders - If the redacted headers must be included in the response - headers are always redacted (default false)
  * @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
-  };
-};
+export const serializeResponse = async ( response, { includeHeaders = false, includeBody = false } = {} ) => ( {
+  url: response.url,
+  status: response.status,
+  statusText: response.statusText,
+  ok: response.ok,
+  ...( includeHeaders && { headers: redactHeaders( Object.fromEntries( response.headers ) ) } ),
+  ...( includeBody && { body: await consumeBody( response ) } )
+} );
+
 /**
  * Duck-typing to detect a Node Readable (Stream) without importing anything
  *
@@ -103,3 +150,21 @@ export const serializeBodyAndInferContentType = payload => {
 
   return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
 };
+
+const getSecretFromEnv = varName => {
+  const value = process.env[varName];
+  if ( value === undefined ) {
+    throw new FatalError( `Missing environment variable "${varName}" while hydrating headers.` );
+  }
+  return value;
+};
+
+/**
+ * Replaces $VAR_NAME tokens in header values
+ * @param {object} headers
+ * @returns {object} Hydrated headers
+ */
+export const hydrateHeaders = headers =>
+  Object.entries( headers ?? {} ).reduce( ( o, [ key, value ] ) =>
+    Object.assign( o, { [key]: ( '' + value ).replace( /\$([A-Z_][A-Z0-9_]*)/g, ( _, _var ) => getSecretFromEnv( _var ) ) } )
+  , {} );

package/src/helpers/fetch.spec.js

@@ -1,9 +1,136 @@
-import { describe, it, expect } from 'vitest';
+import { afterEach, describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
-import { serializeBodyAndInferContentType, serializeFetchResponse } from './fetch.js';
+import { hydrateHeaders, redactHeaders, serializeBodyAndInferContentType, serializeResponse } from './fetch.js';
 
-describe( 'serializeFetchResponse', () => {
-  it( 'serializes JSON response body and flattens headers', async () => {
+describe( 'redactHeaders', () => {
+  it( 'redacts sensitive header names', () => {
+    const result = redactHeaders( {
+      Authorization: 'Bearer token',
+      'X-Api-Key': 'api-key',
+      Cookie: 'session=id',
+      'x-client-secret': 'secret'
+    } );
+
+    expect( result ).toEqual( {
+      Authorization: '[REDACTED]',
+      'X-Api-Key': '[REDACTED]',
+      Cookie: '[REDACTED]',
+      'x-client-secret': '[REDACTED]'
+    } );
+  } );
+
+  it( 'preserves non-sensitive header names and ignored false positives', () => {
+    const result = redactHeaders( {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'x-csrf-token': 'csrf-token',
+      'public-key-pins': 'pin'
+    } );
+
+    expect( result ).toEqual( {
+      Accept: 'application/json',
+      'Content-Type': 'application/json',
+      'x-csrf-token': 'csrf-token',
+      'public-key-pins': 'pin'
+    } );
+  } );
+
+  it( 'handles empty headers', () => {
+    expect( redactHeaders( {} ) ).toEqual( {} );
+  } );
+} );
+
+describe( 'hydrateHeaders', () => {
+  afterEach( () => {
+    delete process.env.TOKEN;
+    delete process.env.API_KEY;
+  } );
+
+  it( 'replaces environment variable tokens in header values', () => {
+    process.env.TOKEN = 'secret-token';
+
+    expect( hydrateHeaders( {
+      Authorization: 'Bearer $TOKEN'
+    } ) ).toEqual( {
+      Authorization: 'Bearer secret-token'
+    } );
+  } );
+
+  it( 'replaces repeated and multiple environment variable tokens', () => {
+    process.env.TOKEN = 'secret-token';
+    process.env.API_KEY = 'api-key';
+
+    expect( hydrateHeaders( {
+      Authorization: 'Bearer $TOKEN',
+      'X-Composite': '$TOKEN:$API_KEY:$TOKEN'
+    } ) ).toEqual( {
+      Authorization: 'Bearer secret-token',
+      'X-Composite': 'secret-token:api-key:secret-token'
+    } );
+  } );
+
+  it( 'preserves headers without environment variable tokens', () => {
+    expect( hydrateHeaders( {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    } ) ).toEqual( {
+      Accept: 'application/json',
+      'Content-Type': 'application/json'
+    } );
+  } );
+
+  it( 'handles missing headers', () => {
+    expect( hydrateHeaders() ).toEqual( {} );
+  } );
+
+  it( 'throws when an environment variable token is missing', () => {
+    expect( () => hydrateHeaders( {
+      Authorization: 'Bearer $TOKEN'
+    } ) ).toThrow( 'Missing environment variable "TOKEN" while hydrating headers.' );
+  } );
+} );
+
+describe( 'serializeResponse', () => {
+  it( 'serializes response metadata by default', async () => {
+    const response = new Response( '{not json', {
+      status: 200,
+      statusText: 'OK',
+      headers: { 'content-type': 'application/json' }
+    } );
+
+    await expect( serializeResponse( response ) ).resolves.toEqual( {
+      url: '',
+      status: 200,
+      statusText: 'OK',
+      ok: true
+    } );
+  } );
+
+  it( 'includes redacted headers when requested', async () => {
+    const response = new Response( null, {
+      status: 204,
+      statusText: 'No Content',
+      headers: {
+        authorization: 'Bearer token',
+        'content-type': 'application/json'
+      }
+    } );
+
+    const result = await serializeResponse( response, { includeHeaders: true } );
+
+    expect( result ).toEqual( {
+      url: '',
+      status: 204,
+      statusText: 'No Content',
+      ok: true,
+      headers: {
+        authorization: '[REDACTED]',
+        'content-type': 'application/json'
+      }
+    } );
+  } );
+
+  it( 'includes JSON body when requested', async () => {
     const payload = { a: 1, b: 'two' };
     const response = new Response( JSON.stringify( payload ), {
       status: 200,
@@ -11,32 +138,39 @@ describe( 'serializeFetchResponse', () => {
       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' );
+    const result = await serializeResponse( response, { includeBody: true } );
+
+    expect( result.body ).toEqual( payload );
+  } );
+
+  it( 'includes structured syntax JSON body when requested', async () => {
+    const payload = { error: 'Invalid input' };
+    const response = new Response( JSON.stringify( payload ), {
+      status: 400,
+      statusText: 'Bad Request',
+      headers: { 'content-type': 'application/problem+json; charset=utf-8' }
+    } );
+
+    const result = await serializeResponse( response, { includeBody: true } );
+
     expect( result.body ).toEqual( payload );
   } );
 
-  it( 'serializes text/* response via text()', async () => {
+  it( 'includes text body when requested', async () => {
     const bodyText = 'hello world';
     const response = new Response( bodyText, {
       status: 201,
       statusText: 'Created',
-      headers: { 'content-type': 'text/plain; charset=utf-8' }
+      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' );
+    const result = await serializeResponse( response, { includeBody: true } );
+
     expect( result.body ).toBe( bodyText );
   } );
 
   if ( typeof ReadableStream !== 'undefined' ) {
-    it( 'serializes ReadableStream body for text/* via text()', async () => {
+    it( 'includes ReadableStream text body when requested', async () => {
       const encoder = new TextEncoder();
       const chunk = encoder.encode( 'streamed text' );
       const stream = new ReadableStream( {
@@ -51,16 +185,13 @@ describe( 'serializeFetchResponse', () => {
         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' );
+      const result = await serializeResponse( response, { includeBody: true } );
+
       expect( result.body ).toBe( 'streamed text' );
     } );
   }
 
-  it( 'serializes non-text/non-json response as base64 from arrayBuffer()', async () => {
+  it( 'includes non-text non-json response as base64 when requested', async () => {
     const bytes = Uint8Array.from( [ 0, 1, 2, 3 ] );
     const response = new Response( bytes, {
       status: 200,
@@ -68,21 +199,17 @@ describe( 'serializeFetchResponse', () => {
       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' );
+    const result = await serializeResponse( response, { includeBody: true } );
+
     expect( result.body ).toBe( Buffer.from( bytes ).toString( 'base64' ) );
   } );
 
-  it( 'defaults to base64 when content-type header is missing', async () => {
+  it( 'defaults to base64 body when content-type header is missing and body is requested', 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( '' );
+    const result = await serializeResponse( response, { includeBody: true } );
+
     expect( result.body ).toBe( Buffer.from( bytes ).toString( 'base64' ) );
   } );
 } );

package/src/helpers/trace_info.js

@@ -4,18 +4,15 @@ export class TraceInfo {
 
   /**
    * Builds the trace information propagated through workflow memo and activity headers.
-   * @param {object} options - Arguments to build trace information
-   * @param {boolean} options.disableTrace - Whether trace event emission should be disabled
    * @returns {object} trace information
    */
-  static build( { disableTrace } ) {
+  static build() {
     const info = inWorkflowContext() ? workflowInfo() : {};
     return {
       workflowId: info.workflowId,
       workflowType: info.workflowType,
       runId: info.runId,
-      startTime: info.startTime?.getTime(),
-      disableTrace
+      startTime: info.startTime?.getTime()
     };
   };
 }

package/src/helpers/trace_info.spec.js

@@ -23,24 +23,22 @@ describe( 'TraceInfo', () => {
       startTime: new Date( '2026-06-02T09:00:00.000Z' )
     } );
 
-    expect( TraceInfo.build( { disableTrace: false } ) ).toEqual( {
+    expect( TraceInfo.build() ).toEqual( {
       workflowId: 'workflow-id',
       workflowType: 'workflow-type',
       runId: 'run-id',
-      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
-      disableTrace: false
+      startTime: Date.parse( '2026-06-02T09:00:00.000Z' )
     } );
   } );
 
   it( 'builds trace info without Temporal fields outside workflow context', () => {
     inWorkflowContextMock.mockReturnValue( false );
 
-    expect( TraceInfo.build( { disableTrace: true } ) ).toEqual( {
+    expect( TraceInfo.build() ).toEqual( {
       workflowId: undefined,
       workflowType: undefined,
       runId: undefined,
-      startTime: undefined,
-      disableTrace: true
+      startTime: undefined
     } );
     expect( workflowInfoMock ).not.toHaveBeenCalled();
   } );

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

@@ -141,7 +141,8 @@ describe( 'interface validators', () => {
         url: 'https://example.com',
         method: 'POST',
         payload: { ok: true },
-        headers: { authorization: 'Bearer token' }
+        headers: { authorization: 'Bearer token' },
+        responseOptions: { includeHeaders: true, includeBody: true }
       } ) ).not.toThrow();
     } );
 
@@ -155,6 +156,12 @@ describe( 'interface validators', () => {
         url: 'https://example.com',
         method: 'OPTIONS'
       } ) ).toThrow( ValidationError );
+
+      expect( () => validateRequestPayload( {
+        url: 'https://example.com',
+        method: 'GET',
+        responseOptions: { includeHeaders: 'yes' }
+      } ) ).toThrow( ValidationError );
     } );
   } );
 

package/src/interface/validations/schemas.js

@@ -88,7 +88,11 @@ export const httpRequestSchema = z.object( {
   url: z.url( { protocol: /^https?$/ } ),
   method: z.enum( [ 'GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE' ] ),
   payload: z.any().optional(),
-  headers: z.record( z.string(), z.string() ).optional()
+  headers: z.record( z.string(), z.string() ).optional(),
+  responseOptions: z.strictObject( {
+    includeHeaders: z.boolean().optional().default( false ),
+    includeBody: z.boolean().optional().default( false )
+  } ).optional()
 } );
 
 export const workflowInvocationOptionsSchema = z.strictObject( {

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

@@ -143,11 +143,26 @@ describe( 'validation schemas', () => {
         url: 'https://example.com',
         method: 'POST',
         payload: { ok: true },
-        headers: { authorization: 'Bearer token' }
+        headers: { authorization: 'Bearer token' },
+        responseOptions: { includeHeaders: true, includeBody: true }
       } ).success ).toBe( true );
     } );
 
-    it( 'rejects invalid URL protocols, methods, and header values', () => {
+    it( 'defaults omitted response options to false', () => {
+      const result = httpRequestSchema.safeParse( {
+        url: 'https://example.com',
+        method: 'GET',
+        responseOptions: {}
+      } );
+
+      expect( result.success ).toBe( true );
+      expect( result.data.responseOptions ).toEqual( {
+        includeHeaders: false,
+        includeBody: false
+      } );
+    } );
+
+    it( 'rejects invalid URL protocols, methods, header values, and response options', () => {
       expect( httpRequestSchema.safeParse( { url: 'ftp://example.com', method: 'GET' } ).success ).toBe( false );
       expect( httpRequestSchema.safeParse( { url: 'https://example.com', method: 'OPTIONS' } ).success ).toBe( false );
       expect( httpRequestSchema.safeParse( {
@@ -155,6 +170,11 @@ describe( 'validation schemas', () => {
         method: 'GET',
         headers: { count: 1 }
       } ).success ).toBe( false );
+      expect( httpRequestSchema.safeParse( {
+        url: 'https://example.com',
+        method: 'GET',
+        responseOptions: { includeBody: 'yes' }
+      } ).success ).toBe( false );
     } );
   } );
 

package/src/interface/webhook.d.ts

@@ -3,6 +3,17 @@
  */
 export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 
+/**
+ * Controls which response fields are included in the serialized HTTP response.
+ */
+export type ResponseOptions = {
+  /** Include redacted response headers in the returned value. */
+  includeHeaders?: boolean,
+
+  /** Include the response body in the returned value. */
+  includeBody?: boolean
+};
+
 /** Represents a {Response} serialized to plain object */
 export type SerializedFetchResponse = {
   /** The response url */
@@ -18,10 +29,10 @@ export type SerializedFetchResponse = {
   ok: boolean,
 
   /** Object with response headers */
-  headers: Record<string, string>,
+  headers?: Record<string, string>,
 
   /** Response body, either JSON, text, or an arrayBuffer converted to base64 */
-  body: object | string
+  body?: unknown
 };
 
 /**
@@ -93,6 +104,7 @@ export declare function sendPostRequestAndAwaitWebhook( params: {
  * @param params.method - The HTTP method (default: 'GET')
  * @param params.payload - Request payload (only for POST/PUT)
  * @param params.headers - Headers for the request
+ * @param params.responseOptions - Controls which response fields are included
  * @returns Resolves with an HTTP response serialized to a plain object
  */
 export declare function sendHttpRequest( params: {
@@ -100,4 +112,5 @@ export declare function sendHttpRequest( params: {
   method?: HttpMethod;
   payload?: object;
   headers?: Record<string, string>;
+  responseOptions?: ResponseOptions;
 } ): Promise<SerializedFetchResponse>;

package/src/interface/webhook.js

@@ -12,10 +12,13 @@ import { validateRequestPayload } from './validations/index.js';
  * @param {string} method
  * @param {unknown} [payload]
  * @param {object} [headers]
+ * @param {object} [options.responseOptions] - Response options
+ * @param {boolean} [options.responseOptions.includeHeaders] - If the response will include the headers - Headers are always redacted (default false)
+ * @param {boolean} [options.responseOptions.includeBody] - If the response will include the body (default false)
  * @returns {Promise<object>} The serialized HTTP response
  */
-export async function sendHttpRequest( { url, method = 'GET', payload = undefined, headers = undefined } ) {
-  validateRequestPayload( { method, url, payload, headers } );
+export async function sendHttpRequest( { url, method = 'GET', payload = undefined, headers = undefined, responseOptions = {} } ) {
+  validateRequestPayload( { method, url, payload, headers, responseOptions } );
   const res = await proxyActivities( {
     startToCloseTimeout: '3m',
     retry: {
@@ -23,7 +26,7 @@ export async function sendHttpRequest( { url, method = 'GET', payload = undefine
       maximumAttempts: 3,
       nonRetryableErrorTypes: [ FatalError.name ]
     }
-  } )[ACTIVITY_SEND_HTTP_REQUEST]( { method, url, payload, headers } );
+  } )[ACTIVITY_SEND_HTTP_REQUEST]( { method, url, payload, headers, responseOptions } );
   return res.output;
 };
 

package/src/interface/webhook.spec.js

@@ -82,7 +82,12 @@ describe( 'interface/webhook', () => {
     const res = await sendHttpRequest( args );
 
     // validated
-    expect( validateRequestPayloadMock ).toHaveBeenCalledWith( { ...args, payload: undefined, headers: undefined } );
+    expect( validateRequestPayloadMock ).toHaveBeenCalledWith( {
+      ...args,
+      payload: undefined,
+      headers: undefined,
+      responseOptions: {}
+    } );
 
     // activity proxied with specified options
     expect( proxyActivitiesMock ).toHaveBeenCalledTimes( 1 );
@@ -95,10 +100,40 @@ describe( 'interface/webhook', () => {
     } ) );
 
     // activity invoked with the same args
-    expect( activityFnMock ).toHaveBeenCalledWith( { ...args, payload: undefined, headers: undefined } );
+    expect( activityFnMock ).toHaveBeenCalledWith( {
+      ...args,
+      payload: undefined,
+      headers: undefined,
+      responseOptions: {}
+    } );
     expect( res ).toEqual( fakeSerializedResponse );
   } );
 
+  it( 'sendHttpRequest forwards response options', async () => {
+    const { sendHttpRequest } = await import( './webhook.js' );
+
+    activityFnMock.mockResolvedValueOnce( activityEnvelope( { ok: true } ) );
+
+    const args = {
+      url: 'https://example.com/api',
+      method: 'GET',
+      responseOptions: { includeHeaders: true, includeBody: true }
+    };
+
+    await sendHttpRequest( args );
+
+    expect( validateRequestPayloadMock ).toHaveBeenCalledWith( {
+      ...args,
+      payload: undefined,
+      headers: undefined
+    } );
+    expect( activityFnMock ).toHaveBeenCalledWith( {
+      ...args,
+      payload: undefined,
+      headers: undefined
+    } );
+  } );
+
   it( 'sendPostRequestAndAwaitWebhook posts wrapped payload and resolves on resume signal', async () => {
     const { sendPostRequestAndAwaitWebhook } = await import( './webhook.js' );
 
@@ -121,6 +156,7 @@ describe( 'interface/webhook', () => {
     expect( callArgs.url ).toBe( url );
     expect( callArgs.payload ).toEqual( { workflowId: 'wf-123', payload: { x: 1 } } );
     expect( callArgs.headers ).toEqual( { a: 'b' } );
+    expect( callArgs.responseOptions ).toEqual( {} );
 
     // Returns a promise (async function) for the eventual webhook result
     expect( typeof promise.then ).toBe( 'function' );

package/src/interface/workflow.js

@@ -8,25 +8,12 @@ import { deepMerge } from '#helpers/object';
 import { defaultOptions } from './workflow_activity_options.js';
 import { createWorkflow } from '#helpers/component';
 import {
-  ACTIVITY_WRAPPER_VERSION_FIELD,
   ACTIVITY_GET_TRACE_DESTINATIONS,
   METADATA_ACCESS_SYMBOL,
   SHARED_STEP_PREFIX,
   WORKFLOW_WRAPPER_VERSION_FIELD
 } from '#consts';
 
-/**
- * @temp
- * This is to keep backwards compatibility [OUT-468]
- */
-const parseActivityOutput = p => Object.hasOwn( p ?? {}, ACTIVITY_WRAPPER_VERSION_FIELD ) ? p.output : p;
-
-/**
- * @temp This is a TEMP fallback method to allow workflow child checks on replays without memo. [OUT-468]
- * This workflows for most scenarios, only does not supports recursion with the same name.
- */
-const checkChildFallback = ( { workflowType, name, aliases } ) => workflowType !== name && !aliases.includes( workflowType );
-
 /**
  * Create a new workflow and return a wrapper function around its fn handler
  */
@@ -54,12 +41,11 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
         return output;
       }
 
-      const { workflowId, workflowType, memo, root } = workflowInfo();
+      const { workflowId, memo, root } = workflowInfo();
 
       // if the stack already includes this workflowId, means the workflow() function was called
       // from within a running workflow, meaning it is suppose to start a child workflow
-      const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) :
-        checkChildFallback( { workflowType, aliases, name } );
+      const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) : false;
 
       if ( isChild ) {
         const result = await executeChild( name, {
@@ -81,19 +67,23 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       memo.stack = [ ...memo.stack ?? [], workflowId ];
       // Parent options have prevalence on nested calls, child will be overwritten
       memo.activityOptions = deepMerge( activityOptions, memo.activityOptions );
-      // Trace info is only added in the root workflow
-      if ( isRoot ) {
-        memo.traceInfo = TraceInfo.build( { disableTrace } );
+      // Trace info is only added in the root and only when trace is not disabled
+      if ( isRoot && !disableTrace ) {
+        memo.traceInfo = TraceInfo.build();
       }
 
       const steps = proxyActivities( memo.activityOptions );
-      const traceDest = isRoot && parseActivityOutput( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) );
+      const traceDestinations = isRoot && {
+        trace: {
+          destinations: disableTrace ? {} : ( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) ).output ?? {}
+        }
+      };
 
       try {
         validator.validateInput( input );
 
         // Creates an activity caller based on a prefix
-        const createCaller = prefix => async ( t, ...args ) => parseActivityOutput( await steps[`${prefix}#${t}`]( ...args ) );
+        const createCaller = prefix => async ( t, ...args ) => ( await steps[`${prefix}#${t}`]( ...args ) ).output;
 
         // This are functions used by the AST to replace direct activity (step/evaluator) calls
         const dispatchers = {
@@ -107,15 +97,11 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
         const output = await fn.call( dispatchers, input, WorkflowContext.build() );
         validator.validateOutput( output );
 
-        return {
-          [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-          output,
-          ...( traceDest && { trace: { destinations: traceDest } } )
-        };
+        return { [WORKFLOW_WRAPPER_VERSION_FIELD]: 1, output, ...traceDestinations };
       } catch ( error ) {
-        if ( isRoot && traceDest ) {
+        if ( traceDestinations ) {
           // Append the trace destinations so it is carried to interceptor
-          error[METADATA_ACCESS_SYMBOL] = { trace: { destinations: traceDest } };
+          error[METADATA_ACCESS_SYMBOL] = traceDestinations;
         }
         throw error;
       }

package/src/interface/workflow.spec.js

@@ -356,7 +356,8 @@ describe( 'workflow()', () => {
 
       await expect( parentWorkflow( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { child: 'ok' }
+        output: { child: 'ok' },
+        trace: { destinations: {} }
       } );
       expect( childFn ).not.toHaveBeenCalled();
       expect( executeChildMock ).toHaveBeenCalledWith( 'indirect_child_wf', expect.objectContaining( {
@@ -373,30 +374,6 @@ describe( 'workflow()', () => {
       expect( getTraceDestinations ).toHaveBeenCalledWith( info.memo.traceInfo );
     } );
 
-    it( 'falls back to workflow type matching when replaying an old child call without memo.stack', async () => {
-      const { workflow } = await import( './workflow.js' );
-      const { ParentClosePolicy } = await import( '@temporalio/workflow' );
-      setWorkflowInfo( { workflowType: 'old_parent_wf', memo: { traceInfo: { workflowId: 'root-workflow' } } } );
-      executeChildMock.mockResolvedValueOnce( { output: { child: 'replayed' } } );
-      const fn = vi.fn();
-
-      const wf = workflow( workflowDefinition( {
-        name: 'old_child_wf',
-        inputSchema: z.object( { id: z.number() } ),
-        outputSchema: z.object( { child: z.string() } ),
-        fn
-      } ) );
-
-      await expect( wf( { id: 7 } ) ).resolves.toEqual( { child: 'replayed' } );
-      expect( fn ).not.toHaveBeenCalled();
-      expect( executeChildMock ).toHaveBeenCalledWith( 'old_child_wf', expect.objectContaining( {
-        args: [ { id: 7 } ],
-        parentClosePolicy: ParentClosePolicy.TERMINATE,
-        memo: { traceInfo: { workflowId: 'root-workflow' } }
-      } ) );
-      expect( proxyActivitiesMock ).not.toHaveBeenCalled();
-    } );
-
     it( 'does not fallback to child execution when the replayed workflow type matches an alias', async () => {
       const { workflow } = await import( './workflow.js' );
       setWorkflowInfo( { workflowType: 'old_root_wf', memo: {} } );
@@ -429,7 +406,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'workflow execution path', () => {
-    it( 'initializes root memo, gets trace destinations, validates output, and returns an envelope', async () => {
+    it( 'initializes root memo, skips trace destinations when trace is disabled, validates output, and returns an envelope', async () => {
       const { workflow } = await import( './workflow.js' );
       const getTraceDestinations = vi.fn().mockResolvedValue( activityOutput( { local: '/tmp/root-trace' } ) );
       const info = setWorkflowInfo( { workflowType: 'root_wf', memo: {} } );
@@ -451,23 +428,17 @@ describe( 'workflow()', () => {
       await expect( wf( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
         output: { ok: true },
-        trace: { destinations: { local: '/tmp/root-trace' } }
+        trace: { destinations: {} }
       } );
       expect( info.memo.stack ).toEqual( [ 'workflow-123' ] );
-      expect( info.memo.traceInfo ).toEqual( {
-        workflowId: 'workflow-123',
-        workflowType: 'root_wf',
-        runId: 'run-123',
-        startTime: new Date( '2025-01-01T00:00:00.000Z' ).getTime(),
-        disableTrace: true
-      } );
+      expect( info.memo.traceInfo ).toBeUndefined();
       expect( info.memo.activityOptions ).toEqual( expect.objectContaining( {
         startToCloseTimeout: '5m',
         heartbeatTimeout: '5m',
         retry: expect.objectContaining( { maximumAttempts: 5 } )
       } ) );
       expect( proxyActivitiesMock ).toHaveBeenCalledWith( info.memo.activityOptions );
-      expect( getTraceDestinations ).toHaveBeenCalledWith( info.memo.traceInfo );
+      expect( getTraceDestinations ).not.toHaveBeenCalled();
     } );
 
     it( 'runs non-root workflow execution without rebuilding trace info or fetching trace destinations', async () => {
@@ -514,10 +485,10 @@ describe( 'workflow()', () => {
       expect( getTraceDestinations ).not.toHaveBeenCalled();
     } );
 
-    it( 'omits trace from the root result when getTraceDestinations returns no destinations', async () => {
+    it( 'returns empty trace destinations when getTraceDestinations returns no destinations', async () => {
       const { workflow } = await import( './workflow.js' );
       setWorkflowInfo( { workflowType: 'no_trace_dest_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ) } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
 
       const wf = workflow( workflowDefinition( {
         name: 'no_trace_dest_wf',
@@ -525,46 +496,10 @@ describe( 'workflow()', () => {
         fn: async () => ( { ok: true } )
       } ) );
 
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true }
-      } );
-    } );
-
-    it( 'supports old unwrapped trace destination activity results during replay', async () => {
-      const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'old_trace_payload_wf' } );
-      mockActivities( {
-        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( { local: '/tmp/old-trace' } )
-      } );
-
-      const wf = workflow( workflowDefinition( {
-        name: 'old_trace_payload_wf',
-        outputSchema: z.object( { ok: z.boolean() } ),
-        fn: async () => ( { ok: true } )
-      } ) );
-
       await expect( wf( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
         output: { ok: true },
-        trace: { destinations: { local: '/tmp/old-trace' } }
-      } );
-    } );
-
-    it( 'supports old null trace destination activity results during replay', async () => {
-      const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'old_null_trace_payload_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( null ) } );
-
-      const wf = workflow( workflowDefinition( {
-        name: 'old_null_trace_payload_wf',
-        outputSchema: z.object( { ok: z.boolean() } ),
-        fn: async () => ( { ok: true } )
-      } ) );
-
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { ok: true }
+        trace: { destinations: {} }
       } );
     } );
 
@@ -621,7 +556,8 @@ describe( 'workflow()', () => {
 
       await expect( wf( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'step-output', evalResult: 'eval-output' }
+        output: { stepResult: 'step-output', evalResult: 'eval-output' },
+        trace: { destinations: {} }
       } );
       expect( step ).toHaveBeenCalledWith( { a: 1 }, { b: 2 } );
       expect( evaluator ).toHaveBeenCalledWith( { c: 3 } );
@@ -651,39 +587,12 @@ describe( 'workflow()', () => {
 
       await expect( wf( {} ) ).resolves.toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'shared-step-output', evalResult: 'shared-eval-output' }
+        output: { stepResult: 'shared-step-output', evalResult: 'shared-eval-output' },
+        trace: { destinations: {} }
       } );
       expect( sharedStep ).toHaveBeenCalledWith();
       expect( sharedEvaluator ).toHaveBeenCalledWith( { x: 1 } );
     } );
-
-    it( 'supports old unwrapped step and evaluator activity results during replay', async () => {
-      const { workflow } = await import( './workflow.js' );
-      setWorkflowInfo( { workflowType: 'old_activity_payload_wf' } );
-      const step = vi.fn().mockResolvedValue( 'legacy-step-output' );
-      const evaluator = vi.fn().mockResolvedValue( 'legacy-eval-output' );
-      mockActivities( {
-        [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ),
-        'old_activity_payload_wf#stepA': step,
-        'old_activity_payload_wf#evalA': evaluator
-      } );
-
-      const wf = workflow( workflowDefinition( {
-        name: 'old_activity_payload_wf',
-        outputSchema: z.object( { stepResult: z.string(), evalResult: z.string() } ),
-        async fn() {
-          return {
-            stepResult: await this.invokeStep( 'stepA' ),
-            evalResult: await this.invokeEvaluator( 'evalA' )
-          };
-        }
-      } ) );
-
-      await expect( wf( {} ) ).resolves.toEqual( {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output: { stepResult: 'legacy-step-output', evalResult: 'legacy-eval-output' }
-      } );
-    } );
   } );
 
   describe( 'error handling', () => {
@@ -722,10 +631,10 @@ describe( 'workflow()', () => {
       expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: { local: '/tmp/trace' } } } );
     } );
 
-    it( 'rethrows root workflow errors without metadata when trace destinations are unavailable', async () => {
+    it( 'attaches empty trace destinations to root workflow errors when no destinations are available', async () => {
       const { workflow } = await import( './workflow.js' );
       setWorkflowInfo( { workflowType: 'root_error_no_trace_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ) } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
       const error = new Error( 'root failed without trace' );
 
       const wf = workflow( workflowDefinition( {
@@ -736,13 +645,13 @@ describe( 'workflow()', () => {
       } ) );
 
       await expect( wf( {} ) ).rejects.toBe( error );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: {} } } );
     } );
 
-    it( 'preserves existing error details when trace destinations are unavailable', async () => {
+    it( 'preserves existing error details when no trace destinations are available', async () => {
       const { workflow } = await import( './workflow.js' );
       setWorkflowInfo( { workflowType: 'root_error_existing_details_no_trace_wf' } );
-      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( null ) ) } );
+      mockActivities( { [ACTIVITY_GET_TRACE_DESTINATIONS]: vi.fn().mockResolvedValue( activityOutput( {} ) ) } );
       const error = new Error( 'root failed without trace' );
       error.details = [ { domain: { reason: 'bad-input' } } ];
 
@@ -755,7 +664,7 @@ describe( 'workflow()', () => {
 
       await expect( wf( {} ) ).rejects.toBe( error );
       expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
-      expect( error[METADATA_ACCESS_SYMBOL] ).toBeUndefined();
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( { trace: { destinations: {} } } );
     } );
 
     it( 'attaches trace metadata to existing root ApplicationFailure without wrapping it', async () => {

package/src/internal_activities/index.js

@@ -1,6 +1,6 @@
 import { FatalError } from '#errors';
 import { EnvHttpProxyAgent, fetch } from 'undici';
-import { serializeFetchResponse, serializeBodyAndInferContentType } from '#helpers/fetch';
+import { serializeResponse, serializeBodyAndInferContentType, hydrateHeaders } from '#helpers/fetch';
 import { createChildLogger } from '#logger';
 import { getDestinations } from '#tracing';
 import { createInternalStep } from '#helpers/component';
@@ -18,17 +18,20 @@ const dispatcher = new EnvHttpProxyAgent( { allowH2: false } );
  * @param {string} options.url - The target 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 {object} [options.headers] - The headers for the request.
  * @param {number} [options.timeout] - The timeout for the request (default 30s)
+ * @param {object} [options.responseOptions] - Options regarding the response
+ * @param {boolean} [options.responseOptions.includeHeaders] - If the response will include the headers - Headers are always redacted (default false)
+ * @param {boolean} [options.responseOptions.includeBody] - If the response will include the body (default false)
  * @returns {object} The serialized HTTP response
  * @throws {FatalError}
  */
 export const sendHttpRequest = createInternalStep( {
   name: ACTIVITY_SEND_HTTP_REQUEST,
-  handler: async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
+  handler: async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000, responseOptions = {} } ) => {
     const args = {
       method,
-      headers: new Headers( headers ?? {} ),
+      headers: new Headers( hydrateHeaders( headers ) ),
       signal: AbortSignal.timeout( timeout ),
       dispatcher
     };
@@ -57,7 +60,7 @@ export const sendHttpRequest = createInternalStep( {
       throw new FatalError( `${method} ${url} ${response.status}` );
     }
 
-    return serializeFetchResponse( response );
+    return serializeResponse( response, responseOptions );
   }
 } );
 

package/src/internal_activities/index.spec.js

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { FatalError } from '#errors';
 import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
-import { serializeBodyAndInferContentType, serializeFetchResponse } from '#helpers/fetch';
+import { serializeBodyAndInferContentType, serializeResponse } from '#helpers/fetch';
 import { getTraceDestinations, sendHttpRequest } from './index.js';
 
 const getDestinationsMock = vi.hoisted( () => vi.fn() );
@@ -34,8 +34,9 @@ vi.mock( '#helpers/string', () => ( {
 } ) );
 
 vi.mock( '#helpers/fetch', () => ( {
+  hydrateHeaders: vi.fn( headers => headers ?? {} ),
   serializeBodyAndInferContentType: vi.fn(),
-  serializeFetchResponse: vi.fn()
+  serializeResponse: vi.fn()
 } ) );
 
 const url = 'https://growthx.ai';
@@ -69,7 +70,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
   beforeEach( async () => {
     fetchMock.mockReset();
     serializeBodyAndInferContentType.mockReset();
-    serializeFetchResponse.mockReset();
+    serializeResponse.mockReset();
   } );
 
   it( 'succeeds and returns serialized JSON response', async () => {
@@ -87,7 +88,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
       contentType: 'application/json; charset=UTF-8'
     } );
     const fakeSerialized = { sentinel: true };
-    serializeFetchResponse.mockResolvedValueOnce( fakeSerialized );
+    serializeResponse.mockResolvedValueOnce( fakeSerialized );
 
     const result = await sendHttpRequest( { url, method, payload } );
 
@@ -98,11 +99,26 @@ describe( 'internal_activities/sendHttpRequest', () => {
       method,
       dispatcher: expect.any( EnvHttpProxyAgentMock )
     } ) );
-    expect( serializeFetchResponse ).toHaveBeenCalledTimes( 1 );
-    const respArg = serializeFetchResponse.mock.calls[0][0];
+    expect( serializeResponse ).toHaveBeenCalledTimes( 1 );
+    const respArg = serializeResponse.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( serializeResponse.mock.calls[0][1] ).toEqual( {} );
+    expect( result ).toBe( fakeSerialized );
+  } );
+
+  it( 'passes response options to response serialization', async () => {
+    const responseOptions = { includeHeaders: true, includeBody: true };
+    const fakeSerialized = { sentinel: true };
+
+    fetchMock.mockResolvedValueOnce( response( { status: 200 } ) );
+    serializeResponse.mockResolvedValueOnce( fakeSerialized );
+
+    const result = await sendHttpRequest( { url, method, responseOptions } );
+
+    expect( serializeResponse ).toHaveBeenCalledTimes( 1 );
+    expect( serializeResponse.mock.calls[0][1] ).toBe( responseOptions );
     expect( result ).toBe( fakeSerialized );
   } );
 
@@ -111,7 +127,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
 
     await expect( sendHttpRequest( { url, method } ) ).rejects
       .toThrow( new FatalError( 'GET https://growthx.ai 500' ) );
-    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeResponse ).not.toHaveBeenCalled();
     expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
   } );
 
@@ -120,7 +136,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
 
     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( serializeResponse ).not.toHaveBeenCalled();
     expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
   } );
 
@@ -131,7 +147,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
 
     await expect( sendHttpRequest( { url, method } ) ).rejects
       .toThrow( new FatalError( 'GET https://growthx.ai Error: getaddrinfo ENOTFOUND nonexistent.example.test' ) );
-    expect( serializeFetchResponse ).not.toHaveBeenCalled();
+    expect( serializeResponse ).not.toHaveBeenCalled();
     expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
   } );
 
@@ -142,7 +158,7 @@ describe( 'internal_activities/sendHttpRequest', () => {
 
     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( serializeResponse ).not.toHaveBeenCalled();
     expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
   } );
 } );
@@ -157,12 +173,10 @@ describe( 'internal_activities/getTraceDestinations', () => {
       workflowId: 'workflow-id',
       runId: 'run-id',
       workflowType: 'workflow',
-      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
-      disableTrace: false
+      startTime: Date.parse( '2026-06-02T09:00:00.000Z' )
     };
     const destinations = {
-      local: '/tmp/project/logs/runs/workflow/trace.json',
-      remote: null
+      local: '/tmp/project/logs/runs/workflow/trace.json'
     };
     getDestinationsMock.mockReturnValueOnce( destinations );
 

package/src/tracing/trace_engine.js

@@ -4,7 +4,6 @@ import { serializeError } from './tools/utils.js';
 import { isStringboolTrue } from '#helpers/string';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
-import { ComponentType } from '#consts';
 import { createChildLogger } from '#logger';
 import { EventAction } from './trace_consts.js';
 import { BaseAttribute } from './trace_attribute.js';
@@ -36,9 +35,11 @@ const processors = [
  * @returns {object} A trace destinations object: { [dest-name]: 'path' }
  */
 export const getDestinations = traceInfo =>
-  processors.reduce( ( o, p ) =>
-    Object.assign( o, { [p.name.toLowerCase()]: p.enabled && !traceInfo.disableTrace ? p.getDestination( traceInfo ) : null } )
-  , {} );
+  Object.fromEntries(
+    processors
+      .filter( p => p.enabled )
+      .map( p => [ p.name.toLowerCase(), p.getDestination( traceInfo ) ] )
+  );
 
 /**
  * Starts processors based on env vars and attach them to the main bus to listen trace events
@@ -69,12 +70,9 @@ const serializeDetails = details => details instanceof Error ? serializeError( d
  * @returns {void}
  */
 export const addEventAction = ( action, { kind, name, id, parentId, details, traceInfo } ) => {
-  // Ignores internal steps in the actual trace files, ignore trace if the flag is true
-  if ( kind !== ComponentType.INTERNAL_STEP && !traceInfo.disableTrace ) {
-    traceBus.emit( 'entry', {
-      traceInfo,
-      entry: { kind, action, name, id, parentId, timestamp: Date.now(), details: serializeDetails( details ) }
-    } );
+  if ( traceInfo ) {
+    const entry = { kind, action, name, id, parentId, timestamp: Date.now(), details: serializeDetails( details ) };
+    traceBus.emit( 'entry', { entry, traceInfo } );
   }
 };
 

package/src/tracing/trace_engine.spec.js

@@ -38,8 +38,7 @@ const traceInfo = {
   workflowId: 'w1',
   runId: 'r1',
   workflowType: 'WF',
-  startTime: 1,
-  disableTrace: false
+  startTime: 1
 };
 
 describe( 'tracing/trace_engine', () => {
@@ -88,19 +87,19 @@ describe( 'tracing/trace_engine', () => {
     expect( payload.entry.details ).toBe( 'done' );
   } );
 
-  it( 'addEventAction() does not emit when traceInfo.disableTrace is true', async () => {
+  it( 'addEventAction() does not emit when traceInfo is absent', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     const { init, addEventAction } = await loadTraceEngine();
     await init();
 
     addEventAction( 'start', {
       kind: 'step', name: 'X', id: '1', parentId: 'p', details: {},
-      traceInfo: { ...traceInfo, disableTrace: true }
+      traceInfo: undefined
     } );
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'addEventAction() does not emit when kind is INTERNAL_STEP', async () => {
+  it( 'addEventAction() emits when kind is INTERNAL_STEP', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     const { init, addEventAction } = await loadTraceEngine();
     await init();
@@ -109,7 +108,13 @@ describe( 'tracing/trace_engine', () => {
       kind: 'internal_step', name: 'Internal', id: '1', parentId: 'p', details: {},
       traceInfo
     } );
-    expect( localExecMock ).not.toHaveBeenCalled();
+    expect( localExecMock ).toHaveBeenCalledTimes( 1 );
+    expect( localExecMock.mock.calls[0][0].entry ).toMatchObject( {
+      kind: 'internal_step',
+      name: 'Internal',
+      id: '1',
+      parentId: 'p'
+    } );
   } );
 
   it( 'addEventActionWithContext() uses storage when available', async () => {
@@ -185,11 +190,11 @@ describe( 'tracing/trace_engine', () => {
     expect( localExecMock ).not.toHaveBeenCalled();
   } );
 
-  it( 'addEventActionWithContext() does not emit when storage traceInfo.disableTrace is true', async () => {
+  it( 'addEventActionWithContext() does not emit when storage traceInfo is absent', async () => {
     process.env.OUTPUT_TRACE_LOCAL_ON = '1';
     storageLoadMock.mockReturnValue( {
       parentId: 'ctx-p',
-      traceInfo: { ...traceInfo, disableTrace: true }
+      traceInfo: undefined
     } );
     const { init, addEventActionWithContext } = await loadTraceEngine();
     await init();
@@ -209,20 +214,10 @@ describe( 'tracing/trace_engine', () => {
   } );
 
   describe( 'getDestinations()', () => {
-    it( 'returns null for both when traces are off (env vars unset)', async () => {
+    it( 'returns an empty object when traces are off (env vars unset)', async () => {
       const { getDestinations } = await loadTraceEngine();
       const result = getDestinations( traceInfo );
-      expect( result ).toEqual( { local: null, remote: null } );
-      expect( localGetDestinationMock ).not.toHaveBeenCalled();
-      expect( s3GetDestinationMock ).not.toHaveBeenCalled();
-    } );
-
-    it( 'returns null for both when traceInfo.disableTrace is true', async () => {
-      process.env.OUTPUT_TRACE_LOCAL_ON = '1';
-      process.env.OUTPUT_TRACE_REMOTE_ON = '1';
-      const { getDestinations } = await loadTraceEngine();
-      const result = getDestinations( { ...traceInfo, disableTrace: true } );
-      expect( result ).toEqual( { local: null, remote: null } );
+      expect( result ).toEqual( {} );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
     } );
@@ -247,7 +242,7 @@ describe( 'tracing/trace_engine', () => {
       process.env.OUTPUT_TRACE_REMOTE_ON = '0';
       const { getDestinations } = await loadTraceEngine();
       const result = getDestinations( traceInfo );
-      expect( result ).toEqual( { local: '/local/path.json', remote: null } );
+      expect( result ).toEqual( { local: '/local/path.json' } );
       expect( localGetDestinationMock ).toHaveBeenCalledWith( traceInfo );
       expect( s3GetDestinationMock ).not.toHaveBeenCalled();
     } );
@@ -257,7 +252,7 @@ describe( 'tracing/trace_engine', () => {
       process.env.OUTPUT_TRACE_REMOTE_ON = 'true';
       const { getDestinations } = await loadTraceEngine();
       const result = getDestinations( traceInfo );
-      expect( result ).toEqual( { local: null, remote: 'https://bucket.s3.amazonaws.com/key.json' } );
+      expect( result ).toEqual( { remote: 'https://bucket.s3.amazonaws.com/key.json' } );
       expect( localGetDestinationMock ).not.toHaveBeenCalled();
       expect( s3GetDestinationMock ).toHaveBeenCalledWith( traceInfo );
     } );

package/src/worker/interceptors/activity.spec.js

@@ -16,8 +16,7 @@ const traceInfoMock = vi.hoisted( () => ( {
   workflowId: 'wf-1',
   runId: 'run-1',
   workflowType: 'myWorkflow',
-  startTime: 1710000000000,
-  disableTrace: false
+  startTime: 1710000000000
 } ) );
 const workflowDetailsMock = vi.hoisted( () => ( {
   workflowId: 'wf-1',