@outputai/core 0.4.1-dev.622e67b.0 → 0.4.1-dev.7aa9a5f.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.4.1-dev.622e67b.0",
+  "version": "0.4.1-dev.7aa9a5f.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -33,6 +33,7 @@
   },
   "dependencies": {
     "@aws-sdk/client-s3": "3.1038.0",
+    "@aws-sdk/lib-storage": "3.1038.0",
     "@babel/generator": "7.29.1",
     "@babel/parser": "7.29.2",
     "@babel/traverse": "7.29.0",
@@ -42,6 +43,8 @@
     "@temporalio/common": "1.17.0",
     "@temporalio/worker": "1.17.0",
     "@temporalio/workflow": "1.17.0",
+    "decimal.js": "10.6.0",
+    "json-stream-stringify": "3.1.6",
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
     "undici": "8.1.0",
@@ -64,6 +67,7 @@
     "#logger": "./src/logger.js",
     "#utils": "./src/utils/index.js",
     "#tracing": "./src/tracing/internal_interface.js",
+    "#trace_attribute": "./src/tracing/trace_attribute.js",
     "#async_storage": "./src/async_storage.js",
     "#internal_activities": "./src/internal_activities/index.js"
   },

package/src/activity_integration/tracing.d.ts

@@ -1,3 +1,6 @@
+import type { Attribute } from '#trace_attribute';
+
+export { Attribute } from '#trace_attribute';
 /**
  * Creates a new event.
  *
@@ -32,14 +35,6 @@ export declare function addEventError( args: { id: string; details: unknown } ):
  *
  * @param args
  * @param args.eventId - The id of the event to attach the attribute to.
- * @param args.name - The attribute name
- * @param args.value - The attribute value
- */
-export declare function addEventAttribute( args: { eventId: string; name: string, value: unknown } ): void;
-
-/**
- * Known attributes.
+ * @param args.attribute - The attribute to attach to the event.
  */
-export declare const Attribute: {
-  COST: 'cost';
-};
+export declare function addEventAttribute( args: { eventId: string; attribute: Attribute.Instance } ): void;

package/src/activity_integration/tracing.js

@@ -1,5 +1,7 @@
 import { addEventActionWithContext, EventAction } from '#tracing';
 
+export { Attribute } from '#trace_attribute';
+
 /**
  * Creates a new event.
  *
@@ -42,12 +44,5 @@ export const addEventError = ( { id, details } ) => addEventActionWithContext( E
  * @param {unknown} args.value - The attribute value
  * @returns {void}
  */
-export const addEventAttribute = ( { eventId, name, value } ) =>
-  addEventActionWithContext( EventAction.ADD_ATTR, { id: eventId, details: { name, value } } );
-
-/**
- * Known attributes
- */
-export const Attribute = {
-  COST: 'cost'
-};
+export const addEventAttribute = ( { eventId, attribute } ) =>
+  addEventActionWithContext( EventAction.ADD_ATTR, { id: eventId, details: attribute } );

package/src/consts.js

@@ -33,6 +33,10 @@ export const BusEventType = {
   RUNTIME_ERROR: 'runtime_error'
 };
 
+export const Signal = {
+  ADD_ATTRIBUTE: 'add_attribute'
+};
+
 export const WorkflowSpecialOutput = {
   CONTINUED_AS_NEW: '<<continued_as_new>>'
 };

package/src/interface/aggregations.js

@@ -0,0 +1,24 @@
+import { Attribute } from '#trace_attribute';
+import Decimal from 'decimal.js';
+
+export const aggregateAttributes = attributes => ( {
+  cost: {
+    total: attributes
+      .filter( a => [ Attribute.HTTPRequestCost.TYPE, Attribute.LLMUsage.TYPE ].includes( a.type ) )
+      .reduce( ( sum, a ) => sum.add( a.total ), Decimal( 0 ) ).toNumber()
+  },
+  tokens: {
+    total: attributes
+      .filter( a => Attribute.LLMUsage.TYPE === a.type )
+      .reduce( ( sum, a ) => sum.add( a.tokensUsed ), Decimal( 0 ) ).toNumber(),
+    ...Object.entries( attributes
+      .filter( a => Attribute.LLMUsage.TYPE === a.type )
+      .flatMap( a => a.usage )
+      .reduce( ( obj, a ) => Object.assign( obj, { [a.type]: ( obj[a.type] ?? Decimal( 0 ) ).add( a.amount ) } ), {} ) )
+      .reduce( ( obj, [ k, v ] ) => Object.assign( obj, { [k]: v.toNumber() } ), {} ) // convert all values to number
+
+  },
+  httpRequests: {
+    total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
+  }
+} );

package/src/interface/aggregations.spec.js

@@ -0,0 +1,91 @@
+import { describe, expect, it } from 'vitest';
+import { Attribute } from '#trace_attribute';
+import { aggregateAttributes } from './aggregations.js';
+
+describe( 'aggregateAttributes', () => {
+  it( 'returns zeroed aggregations when there are no attributes', () => {
+    expect( aggregateAttributes( [] ) ).toEqual( {
+      cost: { total: 0 },
+      tokens: { total: 0 },
+      httpRequests: { total: 0 }
+    } );
+  } );
+
+  it( 'aggregates costs, token usage, and HTTP request count by attribute type', () => {
+    const attributes = [
+      {
+        type: Attribute.HTTPRequestCount.TYPE,
+        url: 'https://api.example.test/a',
+        requestId: 'req-1'
+      },
+      {
+        type: Attribute.HTTPRequestCount.TYPE,
+        url: 'https://api.example.test/b',
+        requestId: 'req-2'
+      },
+      {
+        type: Attribute.HTTPRequestCost.TYPE,
+        url: 'https://api.example.test/a',
+        requestId: 'req-1',
+        total: 0.2
+      },
+      {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'gpt-4o',
+        total: 0.3,
+        tokensUsed: 120,
+        usage: [
+          { type: 'input', ppm: 1, amount: 100, total: 0.1 },
+          { type: 'output', ppm: 2, amount: 20, total: 0.2 }
+        ]
+      },
+      {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'gpt-4o-mini',
+        total: 0.05,
+        tokensUsed: 30,
+        usage: [
+          { type: 'input', ppm: 1, amount: 25, total: 0.025 },
+          { type: 'reasoning', ppm: 5, amount: 5, total: 0.025 }
+        ]
+      },
+      {
+        type: 'unrelated',
+        total: 100,
+        tokensUsed: 100
+      }
+    ];
+
+    expect( aggregateAttributes( attributes ) ).toEqual( {
+      cost: { total: 0.55 },
+      tokens: {
+        total: 150,
+        input: 125,
+        output: 20,
+        reasoning: 5
+      },
+      httpRequests: { total: 2 }
+    } );
+  } );
+
+  it( 'uses LLMUsage.tokensUsed for total tokens instead of summing usage amounts', () => {
+    const attributes = [
+      {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'provider-model',
+        total: 0.1,
+        tokensUsed: 42,
+        usage: [
+          { type: 'input', ppm: 1, amount: 10, total: 0.01 },
+          { type: 'output', ppm: 1, amount: 5, total: 0.005 }
+        ]
+      }
+    ];
+
+    expect( aggregateAttributes( attributes ).tokens ).toEqual( {
+      total: 42,
+      input: 10,
+      output: 5
+    } );
+  } );
+} );

package/src/interface/workflow.js

@@ -1,11 +1,13 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy, continueAsNew } from '@temporalio/workflow';
+import { defineSignal, setHandler } from '@temporalio/workflow';
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
-import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL } from '#consts';
+import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL, Signal } from '#consts';
 import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 import { Context } from './workflow_context.js';
+import { aggregateAttributes } from './aggregations.js';
 
 const defaultOptions = {
   activityOptions: {
@@ -22,6 +24,9 @@ const defaultOptions = {
   disableTrace: false
 };
 
+export const extractErrorDetail = ( e, key ) =>
+  e ? ( e.details?.find?.( d => d[key] )?.[key] ?? extractErrorDetail( e.cause, key ) ) : null;
+
 export function workflow( { name, description, inputSchema, outputSchema, fn, options = {}, aliases = [] } ) {
   validateWorkflow( { name, description, inputSchema, outputSchema, fn, options, aliases } );
 
@@ -69,7 +74,9 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
 
     // Run the internal activity to retrieve the workflow trace destinations (only for root workflows, not nested)
     const traceDestinations = isRoot ? ( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( executionContext ) ) : null;
-    const traceObject = { trace: { destinations: traceDestinations } };
+
+    const attributes = [];
+    setHandler( defineSignal( Signal.ADD_ATTRIBUTE ), e => attributes.push( e ) );
 
     try {
       // validation comes after setting memo to have that info already set for interceptor even if validations fail
@@ -91,17 +98,25 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
          * @param {import('@temporalio/workflow').ActivityOptions} extra.options
          * @returns {Promise<unknown>}
          */
-        startWorkflow: async ( childName, input, extra = {} ) =>
-          executeChild( childName, {
-            args: input ? [ input ] : [],
-            workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
-            parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
-            memo: {
-              executionContext,
-              parentId: workflowId,
-              ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
-            }
-          } )
+        startWorkflow: async ( childName, input, extra = {} ) => {
+          try {
+            const result = await executeChild( childName, {
+              args: input ? [ input ] : [],
+              workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
+              parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
+              memo: {
+                executionContext,
+                parentId: workflowId,
+                ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
+              }
+            } );
+            attributes.push( ...( result.attributes ?? [] ) );
+            return result.output;
+          } catch ( error ) {
+            attributes.push( ...( extractErrorDetail( error, 'attributes' ) ?? [] ) );
+            throw error;
+          }
+        }
       };
 
       const output = await fn.call( dispatchers, input, context );
@@ -110,14 +125,17 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
 
       if ( isRoot ) {
         // Append the trace info to the result of the workflow
-        return { output, ...traceObject };
+        return { output, trace: { destinations: traceDestinations }, attributes, aggregations: aggregateAttributes( attributes ) };
       }
 
-      return output;
+      return { output, attributes };
     } catch ( e ) {
-      // Append the trace info as metadata of the error, so it can be read by the interceptor.
+      // Append the extra info as metadata of the error, so it can be read by the interceptor.
+      e[METADATA_ACCESS_SYMBOL] = { ...( e[METADATA_ACCESS_SYMBOL] ?? {} ), attributes };
+      // if it is roo also add trace/aggregations
       if ( isRoot ) {
-        e[METADATA_ACCESS_SYMBOL] = { ...( e[METADATA_ACCESS_SYMBOL] ?? {} ), ...traceObject };
+        e[METADATA_ACCESS_SYMBOL].trace = { destinations: traceDestinations };
+        e[METADATA_ACCESS_SYMBOL].aggregations = aggregateAttributes( attributes );
       }
       throw e;
     }

package/src/interface/workflow.spec.js

@@ -1,7 +1,10 @@
+import { Signal } from '#consts';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { z } from 'zod';
 
 const inWorkflowContextMock = vi.hoisted( () => vi.fn( () => true ) );
+const defineSignalMock = vi.hoisted( () => vi.fn( name => name ) );
+const setHandlerMock = vi.hoisted( () => vi.fn() );
 const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
 const executeChildMock = vi.fn().mockResolvedValue( undefined );
 const continueAsNewMock = vi.fn().mockResolvedValue( undefined );
@@ -41,7 +44,16 @@ vi.mock( '@temporalio/workflow', () => ( {
   workflowInfo: workflowInfoMock,
   uuid4: () => '550e8400e29b41d4a716446655440000',
   ParentClosePolicy: { TERMINATE: 'TERMINATE', ABANDON: 'ABANDON' },
-  continueAsNew: continueAsNewMock
+  ChildWorkflowFailure: class ChildWorkflowFailure extends Error {
+    constructor( message, cause ) {
+      super( message );
+      this.name = 'ChildWorkflowFailure';
+      this.cause = cause;
+    }
+  },
+  continueAsNew: continueAsNewMock,
+  defineSignal: ( ...args ) => defineSignalMock( ...args ),
+  setHandler: ( ...args ) => setHandlerMock( ...args )
 } ) );
 
 vi.mock( '#consts', async importOriginal => {
@@ -53,10 +65,17 @@ vi.mock( '#consts', async importOriginal => {
   };
 } );
 
+const emptyAggregations = {
+  cost: { total: 0 },
+  tokens: { total: 0 },
+  httpRequests: { total: 0 }
+};
+
 describe( 'workflow()', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     inWorkflowContextMock.mockReturnValue( true );
+    defineSignalMock.mockImplementation( name => name );
     workflowInfoMock.mockReturnValue( { ...workflowInfoReturn } );
     workflowInfoReturn.memo = {};
     proxyActivitiesMock.mockImplementation( () => {
@@ -217,7 +236,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'root workflow (in workflow context)', () => {
-    it( 'calls getTraceDestinations, returns { output, trace } and assigns executionContext to memo', async () => {
+    it( 'calls getTraceDestinations, returns root trace data and assigns executionContext to memo', async () => {
       const { workflow } = await import( './workflow.js' );
 
       const wf = workflow( {
@@ -232,7 +251,9 @@ describe( 'workflow()', () => {
       expect( traceDestinationsStepMock ).toHaveBeenCalledTimes( 1 );
       expect( result ).toEqual( {
         output: { v: 42 },
-        trace: { destinations: { local: '/tmp/trace' } }
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [],
+        aggregations: emptyAggregations
       } );
       const memo = workflowInfoMock().memo;
       expect( memo.executionContext ).toEqual( {
@@ -243,6 +264,68 @@ describe( 'workflow()', () => {
       } );
     } );
 
+    it( 'collects attribute signals and returns aggregated attributes', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { Attribute } = await import( '#trace_attribute' );
+      const handlers = { addAttribute: () => {} };
+      setHandlerMock.mockImplementation( ( signalName, handler ) => {
+        if ( signalName === Signal.ADD_ATTRIBUTE ) {
+          handlers.addAttribute = handler;
+        }
+      } );
+
+      const httpRequest = {
+        type: Attribute.HTTPRequestCount.TYPE,
+        url: 'https://api.example.test/items',
+        requestId: 'req-1'
+      };
+      const httpCost = {
+        type: Attribute.HTTPRequestCost.TYPE,
+        url: 'https://api.example.test/items',
+        requestId: 'req-1',
+        total: 2.5
+      };
+      const llmUsage = {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'gpt-4o',
+        total: 0.25,
+        usage: [
+          { type: 'input', ppm: 5, amount: 20_000, total: 0.1 },
+          { type: 'output', ppm: 30, amount: 5_000, total: 0.15 }
+        ],
+        tokensUsed: 25_000
+      };
+
+      const wf = workflow( {
+        name: 'attr_wf',
+        description: 'Attributes',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( { ok: z.boolean() } ),
+        fn: async () => {
+          handlers.addAttribute( httpRequest );
+          handlers.addAttribute( httpCost );
+          handlers.addAttribute( llmUsage );
+          return { ok: true };
+        }
+      } );
+
+      const result = await wf( {} );
+      expect( result ).toEqual( {
+        output: { ok: true },
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [ httpRequest, httpCost, llmUsage ],
+        aggregations: {
+          cost: { total: 2.75 },
+          tokens: {
+            total: 25_000,
+            input: 20_000,
+            output: 5_000
+          },
+          httpRequests: { total: 1 }
+        }
+      } );
+    } );
+
     it( 'sets executionContext.disableTrace when options.disableTrace is true', async () => {
       const { workflow } = await import( './workflow.js' );
 
@@ -261,7 +344,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'child workflow (memo.executionContext already set)', () => {
-    it( 'does not call getTraceDestinations and returns plain output', async () => {
+    it( 'does not call getTraceDestinations and returns an internal output envelope', async () => {
       workflowInfoMock.mockReturnValue( {
         ...workflowInfoReturn,
         memo: { executionContext: { workflowId: 'parent-1', workflowName: 'parent_wf' } }
@@ -278,7 +361,7 @@ describe( 'workflow()', () => {
 
       const result = await wf( {} );
       expect( traceDestinationsStepMock ).not.toHaveBeenCalled();
-      expect( result ).toEqual( { x: 'child' } );
+      expect( result ).toEqual( { output: { x: 'child' }, attributes: [] } );
     } );
   } );
 
@@ -381,6 +464,7 @@ describe( 'workflow()', () => {
     it( 'calls executeChild with correct args and TERMINATE when not detached', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, attributes: [] } );
 
       const wf = workflow( {
         name: 'parent_wf',
@@ -408,6 +492,7 @@ describe( 'workflow()', () => {
     it( 'uses ABANDON when extra.detached is true', async () => {
       const { workflow } = await import( './workflow.js' );
       const { ParentClosePolicy } = await import( '@temporalio/workflow' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, attributes: [] } );
 
       const wf = workflow( {
         name: 'detach_wf',
@@ -428,6 +513,7 @@ describe( 'workflow()', () => {
 
     it( 'passes empty args when input is null/omitted', async () => {
       const { workflow } = await import( './workflow.js' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, attributes: [] } );
 
       const wf = workflow( {
         name: 'no_input_wf',
@@ -445,11 +531,96 @@ describe( 'workflow()', () => {
         args: []
       } ) );
     } );
+
+    it( 'returns child output and merges child attributes into the root result', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { Attribute } = await import( '#trace_attribute' );
+      const childAttribute = {
+        type: Attribute.LLMUsage.TYPE,
+        modelId: 'gpt-4o',
+        total: 0.4,
+        tokensUsed: 20,
+        usage: [
+          { type: 'input', ppm: 10, amount: 20, total: 0.4 }
+        ]
+      };
+      executeChildMock.mockResolvedValueOnce( {
+        output: { child: 'ok' },
+        attributes: [ childAttribute ]
+      } );
+
+      const wf = workflow( {
+        name: 'merge_child_wf',
+        description: 'Merge child attributes',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( { child: z.string() } ),
+        async fn() {
+          return this.startWorkflow( 'child_wf', { id: 1 } );
+        }
+      } );
+
+      const result = await wf( {} );
+      expect( result ).toEqual( {
+        output: { child: 'ok' },
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [ childAttribute ],
+        aggregations: {
+          cost: { total: 0.4 },
+          tokens: {
+            total: 20,
+            input: 20
+          },
+          httpRequests: { total: 0 }
+        }
+      } );
+    } );
+
+    it( 'merges child error attributes before rethrowing to root metadata', async () => {
+      const { workflow } = await import( './workflow.js' );
+      const { ChildWorkflowFailure } = await import( '@temporalio/workflow' );
+      const { METADATA_ACCESS_SYMBOL } = await import( '#consts' );
+      const { Attribute } = await import( '#trace_attribute' );
+      const childAttribute = {
+        type: Attribute.HTTPRequestCost.TYPE,
+        url: 'https://api.example.test',
+        requestId: 'req-child',
+        total: 2
+      };
+      const childError = new ChildWorkflowFailure( 'child failed', {
+        message: 'Child workflow execution failed',
+        details: [ { attributes: [ childAttribute ] } ]
+      } );
+      executeChildMock.mockRejectedValueOnce( childError );
+
+      const wf = workflow( {
+        name: 'child_error_wf',
+        description: 'Child error attributes',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( {} ),
+        async fn() {
+          await this.startWorkflow( 'child_wf', { id: 1 } );
+          return {};
+        }
+      } );
+
+      await expect( wf( {} ) ).rejects.toThrow( 'child failed' );
+      expect( childError[METADATA_ACCESS_SYMBOL] ).toEqual( {
+        attributes: [ childAttribute ],
+        trace: { destinations: { local: '/tmp/trace' } },
+        aggregations: {
+          cost: { total: 2 },
+          tokens: { total: 0 },
+          httpRequests: { total: 0 }
+        }
+      } );
+    } );
   } );
 
   describe( 'error handling (root workflow)', () => {
-    it( 'rethrows error from fn and rejects with same message', async () => {
+    it( 'rethrows error from fn with trace attributes and aggregation metadata', async () => {
       const { workflow } = await import( './workflow.js' );
+      const { METADATA_ACCESS_SYMBOL } = await import( '#consts' );
+      const error = new Error( 'workflow failed' );
 
       const wf = workflow( {
         name: 'err_wf',
@@ -457,11 +628,16 @@ describe( 'workflow()', () => {
         inputSchema: z.object( {} ),
         outputSchema: z.object( {} ),
         fn: async () => {
-          throw new Error( 'workflow failed' );
+          throw error;
         }
       } );
 
       await expect( wf( {} ) ).rejects.toThrow( 'workflow failed' );
+      expect( error[METADATA_ACCESS_SYMBOL] ).toEqual( {
+        trace: { destinations: { local: '/tmp/trace' } },
+        attributes: [],
+        aggregations: emptyAggregations
+      } );
     } );
   } );
 } );

package/src/tracing/processors/local/index.js

@@ -1,9 +1,11 @@
-import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readdirSync, readFileSync, rmSync, createWriteStream } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'url';
 import buildTraceTree from '../../tools/build_trace_tree.js';
-import { safeFormatJSON } from '../../tools/utils.js';
 import { EOL } from 'node:os';
+import { JsonStreamStringify } from 'json-stream-stringify';
+
+import { pipeline } from 'stream/promises';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 
@@ -109,7 +111,7 @@ export const init = () => {
  * @param {object} args.executionContext - Execution info: workflowId, workflowName, startTime
  * @returns {void}
  */
-export const exec = ( { entry, executionContext } ) => {
+export const exec = async ( { entry, executionContext } ) => {
   const { workflowId, workflowName, startTime } = executionContext;
   const tempFilePath = createTempFilePath( executionContext );
   addEntry( entry, tempFilePath );
@@ -126,7 +128,11 @@ export const exec = ( { entry, executionContext } ) => {
   const path = join( dir, buildTraceFilename( { startTime, workflowId } ) );
 
   mkdirSync( dir, { recursive: true } );
-  writeFileSync( path, safeFormatJSON( content ) + EOL, 'utf-8' );
+
+  await pipeline(
+    new JsonStreamStringify( content ),
+    createWriteStream( path )
+  );
 };
 
 /**