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

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/configs.js

@@ -1,5 +1,6 @@
 import * as z from 'zod';
 import { isStringboolTrue } from '#helpers/string';
+import { workerTunerEnvSchema } from './configs_tuner_schema.js';
 
 class InvalidEnvVarsErrors extends Error { }
 
@@ -28,6 +29,8 @@ const envVarSchema = z.object( {
   // How aggressively the worker pulls tasks from Temporal.
   TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 5 ) ),
   TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 5 ) ),
+  // JSON-encoded Temporal Worker tuner options.
+  TEMPORAL_WORKER_TUNER: workerTunerEnvSchema,
   // Activity configs
   // How often the worker sends a heartbeat to the Temporal Service during activity execution
   OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 2 * 60 * 1000 ) ), // 2min
@@ -60,6 +63,7 @@ export const maxConcurrentWorkflowTaskExecutions = envVars.TEMPORAL_MAX_CONCURRE
 export const maxCachedWorkflows = envVars.TEMPORAL_MAX_CACHED_WORKFLOWS;
 export const maxConcurrentActivityTaskPolls = envVars.TEMPORAL_MAX_CONCURRENT_ACTIVITY_TASK_POLLS;
 export const maxConcurrentWorkflowTaskPolls = envVars.TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS;
+export const workerTuner = envVars.TEMPORAL_WORKER_TUNER;
 export const namespace = envVars.TEMPORAL_NAMESPACE;
 export const taskQueue = envVars.OUTPUT_CATALOG_ID;
 export const catalogId = envVars.OUTPUT_CATALOG_ID;