@outputai/core 0.6.0 → 0.6.1-dev.daae905.0

package/src/hooks/index.spec.js

@@ -25,6 +25,30 @@ import {
   onWorkflowStart
 } from './index.js';
 
+const workflowDetails = {
+  workflowId: 'wf-1',
+  runId: 'run-1',
+  workflowType: 'myWorkflow',
+  firstExecutionRunId: 'run-1',
+  startTime: 1710000000000,
+  runStartTime: 1710000000000,
+  attempt: 1
+};
+
+const catalogWorkflowDetails = {
+  ...workflowDetails,
+  workflowType: WORKFLOW_CATALOG
+};
+
+const activityInfo = {
+  activityId: 'act-1',
+  activityType: 'wf#step',
+  workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
+  workflowType: 'myWorkflow'
+};
+
+const eventDate = 1710000001234;
+
 describe( 'hooks/index', () => {
   beforeEach( () => {
     vi.clearAllMocks();
@@ -43,49 +67,53 @@ describe( 'hooks/index', () => {
       expect( messageBusMock.on ).toHaveBeenCalledWith( BusEventType.RUNTIME_ERROR, expect.any( Function ) );
     } );
 
-    it( 'invokes handler with activity-shaped payload, forwarding eventId', async () => {
+    it( 'invokes handler with activity-shaped payload, forwarding bus fields', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onError( handler );
 
       const err = new Error( 'act-fail' );
       await onHandlers[BusEventType.ACTIVITY_ERROR]( {
         eventId: 'evt-act-1',
-        id: 'act-1',
-        name: 'wf#step',
-        workflowId: 'wf-run-1',
-        workflowName: 'wf',
-        error: err
+        eventDate,
+        activityInfo,
+        workflowDetails,
+        outputActivityKind: 'step',
+        error: err,
+        extra: 'passthrough'
       } );
 
       expect( handler ).toHaveBeenCalledWith( {
         eventId: 'evt-act-1',
+        eventDate,
         source: 'activity',
-        activityId: 'act-1',
-        activityName: 'wf#step',
-        workflowId: 'wf-run-1',
-        workflowName: 'wf',
-        error: err
+        activityInfo,
+        workflowDetails,
+        outputActivityKind: 'step',
+        error: err,
+        extra: 'passthrough'
       } );
     } );
 
-    it( 'invokes handler with workflow-shaped payload, forwarding eventId', async () => {
+    it( 'invokes handler with workflow-shaped payload, forwarding bus fields', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onError( handler );
 
       const err = new Error( 'wf-fail' );
       await onHandlers[BusEventType.WORKFLOW_ERROR]( {
         eventId: 'evt-wf-1',
-        id: 'wf-run-2',
-        name: 'myWorkflow',
-        error: err
+        eventDate,
+        workflowDetails,
+        error: err,
+        extra: 'passthrough'
       } );
 
       expect( handler ).toHaveBeenCalledWith( {
         eventId: 'evt-wf-1',
+        eventDate,
         source: 'workflow',
-        workflowId: 'wf-run-2',
-        workflowName: 'myWorkflow',
-        error: err
+        workflowDetails,
+        error: err,
+        extra: 'passthrough'
       } );
     } );
 
@@ -94,9 +122,9 @@ describe( 'hooks/index', () => {
       onError( handler );
 
       const error = new Error( 'rt' );
-      await onHandlers[BusEventType.RUNTIME_ERROR]( { eventId: 'evt-rt-1', error } );
+      await onHandlers[BusEventType.RUNTIME_ERROR]( { eventId: 'evt-rt-1', eventDate, error } );
 
-      expect( handler ).toHaveBeenCalledWith( { eventId: 'evt-rt-1', source: 'runtime', error } );
+      expect( handler ).toHaveBeenCalledWith( { eventId: 'evt-rt-1', eventDate, source: 'runtime', error } );
     } );
   } );
 
@@ -113,59 +141,59 @@ describe( 'hooks/index', () => {
   } );
 
   describe( 'onWorkflowStart', () => {
-    it( 'skips catalog workflow and forwards eventId for real workflows', async () => {
+    it( 'skips catalog workflow and forwards bus fields for real workflows', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onWorkflowStart( handler );
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( {
-        eventId: 'evt-ignored', id: '1', name: WORKFLOW_CATALOG
+        eventId: 'evt-ignored', eventDate, workflowDetails: catalogWorkflowDetails
       } ) );
       expect( handler ).not.toHaveBeenCalled();
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_START]( {
-        eventId: 'evt-start-1', id: '2', runId: 'run-2', name: 'myWorkflow'
+        eventId: 'evt-start-1', eventDate, workflowDetails, extra: 'passthrough'
       } ) );
       expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-start-1', id: '2', runId: 'run-2', name: 'myWorkflow'
+        eventId: 'evt-start-1', eventDate, workflowDetails, extra: 'passthrough'
       } );
     } );
   } );
 
   describe( 'onWorkflowEnd', () => {
-    it( 'skips catalog workflow and forwards eventId for real workflows', async () => {
+    it( 'skips catalog workflow and forwards bus fields for real workflows', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       onWorkflowEnd( handler );
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
-        eventId: 'evt-ignored', id: '1', name: WORKFLOW_CATALOG, duration: 10
+        eventId: 'evt-ignored', eventDate, workflowDetails: catalogWorkflowDetails
       } ) );
       expect( handler ).not.toHaveBeenCalled();
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_END]( {
-        eventId: 'evt-end-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 5
+        eventId: 'evt-end-1', eventDate, workflowDetails, extra: 'passthrough'
       } ) );
       expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-end-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 5
+        eventId: 'evt-end-1', eventDate, workflowDetails, extra: 'passthrough'
       } );
     } );
   } );
 
   describe( 'onWorkflowError', () => {
-    it( 'skips catalog workflow and forwards eventId for real workflows', async () => {
+    it( 'skips catalog workflow and forwards bus fields for real workflows', async () => {
       const handler = vi.fn().mockResolvedValue( undefined );
       const err = new Error( 'wf' );
       onWorkflowError( handler );
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        eventId: 'evt-ignored', id: '1', name: WORKFLOW_CATALOG, duration: 1, error: err
+        eventId: 'evt-ignored', eventDate, workflowDetails: catalogWorkflowDetails, error: err
       } ) );
       expect( handler ).not.toHaveBeenCalled();
 
       await Promise.resolve( onHandlers[BusEventType.WORKFLOW_ERROR]( {
-        eventId: 'evt-err-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 2, error: err
+        eventId: 'evt-err-1', eventDate, workflowDetails, error: err, extra: 'passthrough'
       } ) );
       expect( handler ).toHaveBeenCalledWith( {
-        eventId: 'evt-err-1', id: '2', runId: 'run-2', name: 'myWorkflow', duration: 2, error: err
+        eventId: 'evt-err-1', eventDate, workflowDetails, error: err, extra: 'passthrough'
       } );
     } );
   } );

package/src/interface/workflow.js

@@ -1,8 +1,14 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy, continueAsNew } from '@temporalio/workflow';
+import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy } from '@temporalio/workflow';
 import { defineSignal, setHandler } from '@temporalio/workflow';
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
+import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
+import { FatalError, ValidationError } from '#errors';
+import { WorkflowContext } from '#internal_utils/workflow_context';
+import { aggregateAttributes, mergeAggregations } from '#internal_utils/aggregations';
+import { extractErrorDetail } from '#internal_utils/errors';
+import { TraceInfo } from '#internal_utils/trace_info';
 import {
   ACTIVITY_GET_TRACE_DESTINATIONS,
   ACTIVITY_WRAPPER_VERSION_FIELD,
@@ -11,11 +17,6 @@ import {
   Signal,
   WORKFLOW_WRAPPER_VERSION_FIELD
 } from '#consts';
-import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
-import { FatalError, ValidationError } from '#errors';
-import { Context } from './workflow_context.js';
-import { aggregateAttributes, mergeAggregations } from '#internal_utils/aggregations';
-import { extractErrorDetail } from '#internal_utils/errors';
 
 const defaultOptions = {
   activityOptions: {
@@ -54,37 +55,21 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
     // this returns a plain function, for example, in unit tests
     if ( !inWorkflowContext() ) {
       validateWithSchema( inputSchema, input, `Workflow ${name} input` );
-      const context = Context.build( {
-        workflowId: 'test-workflow',
-        runId: 'test-run',
-        continueAsNew: async () => {},
-        isContinueAsNewSuggested: () => false
-      } );
-      const output = await fn( input, deepMerge( context, extra.context ) );
+      const output = await fn( input, deepMerge( WorkflowContext.build(), extra.context ) );
       validateWithSchema( outputSchema, output, `Workflow ${name} output` );
       return output;
     }
 
-    const { workflowId, runId, memo, startTime } = workflowInfo();
-    const context = Context.build( { workflowId, runId, continueAsNew, isContinueAsNewSuggested: () => workflowInfo().continueAsNewSuggested } );
-
-    // Root workflows will not have the execution context yet, since it is set here.
-    const isRoot = !memo.executionContext;
-
-    /* Creates the execution context object or preserve if it already exists:
-       It will always contain the information about the root workflow
-       It will be used to as context for tracing (connecting events) */
-    const executionContext = memo.executionContext ?? {
-      workflowId,
-      runId,
-      workflowName: name,
-      disableTrace,
-      startTime: startTime.getTime()
-    };
+    const { workflowId, memo, root } = workflowInfo();
+    const context = WorkflowContext.build();
+
+    const isRoot = !root;
 
+    // Creates the immutable memo that will be used by all nested workflows/activities
+    // Preserves all info that already exists in the memo object, so new child workflows inherit this
     Object.assign( memo, {
-      executionContext,
-      activityOptions: memo.activityOptions ?? activityOptions // Also preserve the original activity options
+      traceInfo: memo.traceInfo ?? TraceInfo.build( { disableTrace } ),
+      activityOptions: memo.activityOptions ?? activityOptions
     } );
 
     /**
@@ -94,7 +79,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
      * @TODO [OUT-468]
     */
     const getTraceDestinations = async () => {
-      const result = await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( executionContext );
+      const result = await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo );
       return isActivityResultWrapped( result ) ? result.output : result;
     };
 
@@ -166,12 +151,11 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
         startWorkflow: async ( childName, input, extra = {} ) => {
           try {
             const result = await executeChild( childName, {
-              args: input ? [ input ] : [],
+              args: undefined === input ? [] : [ input ],
               workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
               parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
               memo: {
-                executionContext,
-                parentId: workflowId,
+                ...memo,
                 ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
               }
             } );

package/src/interface/workflow.spec.js

@@ -5,6 +5,8 @@ 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 workflowContextBuildMock = vi.hoisted( () => vi.fn() );
+const traceInfoBuildMock = vi.hoisted( () => vi.fn() );
 const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
 const executeChildMock = vi.fn().mockResolvedValue( undefined );
 const continueAsNewMock = vi.fn().mockResolvedValue( undefined );
@@ -31,6 +33,7 @@ const proxyActivitiesMock = vi.fn( () => {
 const workflowInfoReturn = {
   workflowId: 'wf-test-123',
   workflowType: 'test_wf',
+  runId: 'run-test-123',
   memo: {},
   startTime: new Date( '2025-01-01T00:00:00Z' ),
   continueAsNewSuggested: false
@@ -56,6 +59,14 @@ vi.mock( '@temporalio/workflow', () => ( {
   setHandler: ( ...args ) => setHandlerMock( ...args )
 } ) );
 
+vi.mock( '#internal_utils/workflow_context', () => ( {
+  WorkflowContext: { build: workflowContextBuildMock }
+} ) );
+
+vi.mock( '#internal_utils/trace_info', () => ( {
+  TraceInfo: { build: traceInfoBuildMock }
+} ) );
+
 vi.mock( '#consts', async importOriginal => {
   const actual = await importOriginal();
   return {
@@ -70,8 +81,20 @@ describe( 'workflow()', () => {
     vi.clearAllMocks();
     inWorkflowContextMock.mockReturnValue( true );
     defineSignalMock.mockImplementation( name => name );
-    workflowInfoMock.mockReturnValue( { ...workflowInfoReturn } );
     workflowInfoReturn.memo = {};
+    delete workflowInfoReturn.root;
+    workflowInfoMock.mockReturnValue( { ...workflowInfoReturn } );
+    workflowContextBuildMock.mockReturnValue( {
+      control: {},
+      info: { workflowId: 'test-workflow', runId: 'test-run' }
+    } );
+    traceInfoBuildMock.mockImplementation( ( { disableTrace } ) => ( {
+      workflowId: 'trace-workflow-id',
+      workflowType: 'trace-workflow-type',
+      runId: 'trace-run-id',
+      startTime: 12345,
+      disableTrace
+    } ) );
     proxyActivitiesMock.mockImplementation( () => {
       stepSpyRef.current = vi.fn().mockResolvedValue( {} );
       return createStepsProxy( stepSpyRef.current );
@@ -230,7 +253,7 @@ describe( 'workflow()', () => {
   } );
 
   describe( 'root workflow (in workflow context)', () => {
-    it( 'unwraps wrapped trace destinations and assigns executionContext to memo', async () => {
+    it( 'unwraps wrapped trace destinations and assigns traceInfo to memo', async () => {
       traceDestinationsStepMock.mockResolvedValueOnce( {
         output: { local: '/tmp/wrapped-trace' },
         aggregations: null,
@@ -255,12 +278,15 @@ describe( 'workflow()', () => {
         aggregations: null
       } );
       const memo = workflowInfoMock().memo;
-      expect( memo.executionContext ).toEqual( {
-        workflowId: 'wf-test-123',
-        workflowName: 'wrapped_trace_wf',
-        disableTrace: false,
-        startTime: new Date( '2025-01-01T00:00:00Z' ).getTime()
-      } );
+      expect( memo.traceInfo ).toEqual( {
+        workflowId: 'trace-workflow-id',
+        workflowType: 'trace-workflow-type',
+        runId: 'trace-run-id',
+        startTime: 12345,
+        disableTrace: false
+      } );
+      expect( traceInfoBuildMock ).toHaveBeenCalledWith( { disableTrace: false } );
+      expect( traceDestinationsStepMock ).toHaveBeenCalledWith( memo.traceInfo );
     } );
 
     it( 'collects batched aggregation signals from failed activities', async () => {
@@ -290,7 +316,7 @@ describe( 'workflow()', () => {
       expect( result.aggregations.httpRequests ).toEqual( { total: 1 } );
     } );
 
-    it( 'sets executionContext.disableTrace when options.disableTrace is true', async () => {
+    it( 'sets traceInfo.disableTrace when options.disableTrace is true', async () => {
       const { workflow } = await import( './workflow.js' );
 
       const wf = workflow( {
@@ -303,15 +329,23 @@ describe( 'workflow()', () => {
       } );
 
       await wf( {} );
-      expect( workflowInfoMock().memo.executionContext.disableTrace ).toBe( true );
+      expect( workflowInfoMock().memo.traceInfo ).toEqual( expect.objectContaining( {
+        workflowId: 'trace-workflow-id',
+        workflowType: 'trace-workflow-type',
+        runId: 'trace-run-id',
+        disableTrace: true
+      } ) );
+      expect( traceInfoBuildMock ).toHaveBeenCalledWith( { disableTrace: true } );
     } );
   } );
 
-  describe( 'child workflow (memo.executionContext already set)', () => {
+  describe( 'child workflow (memo.traceInfo already set)', () => {
     it( 'does not call getTraceDestinations and returns an internal output envelope', async () => {
+      const traceInfo = { workflowId: 'parent-1', workflowType: 'parent_wf', runId: 'parent-run' };
       workflowInfoMock.mockReturnValue( {
         ...workflowInfoReturn,
-        memo: { executionContext: { workflowId: 'parent-1', workflowName: 'parent_wf' } }
+        root: { workflowId: 'root-wf', runId: 'root-run' },
+        memo: { traceInfo }
       } );
       const { workflow } = await import( './workflow.js' );
 
@@ -325,6 +359,7 @@ describe( 'workflow()', () => {
 
       const result = await wf( {} );
       expect( traceDestinationsStepMock ).not.toHaveBeenCalled();
+      expect( workflowInfoMock().memo.traceInfo ).toBe( traceInfo );
       expect( result ).toEqual( {
         [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
         output: { x: 'child' },
@@ -445,10 +480,22 @@ describe( 'workflow()', () => {
         workflowId: expect.stringMatching( /^wf-test-123-/ ),
         parentClosePolicy: ParentClosePolicy.TERMINATE,
         memo: expect.objectContaining( {
-          executionContext: expect.any( Object ),
-          parentId: 'wf-test-123'
+          traceInfo: {
+            workflowId: 'trace-workflow-id',
+            workflowType: 'trace-workflow-type',
+            runId: 'trace-run-id',
+            startTime: 12345,
+            disableTrace: false
+          },
+          activityOptions: expect.objectContaining( {
+            startToCloseTimeout: '20m',
+            heartbeatTimeout: '5m'
+          } )
         } )
       } );
+      const [ , childOptions ] = executeChildMock.mock.calls[0];
+      expect( childOptions.memo ).not.toHaveProperty( 'executionContext' );
+      expect( childOptions.memo ).not.toHaveProperty( 'parentId' );
     } );
 
     it( 'uses ABANDON when extra.detached is true', async () => {
@@ -469,11 +516,12 @@ describe( 'workflow()', () => {
 
       await wf( {} );
       expect( executeChildMock ).toHaveBeenCalledWith( 'child_wf', expect.objectContaining( {
+        args: [ null ],
         parentClosePolicy: ParentClosePolicy.ABANDON
       } ) );
     } );
 
-    it( 'passes empty args when input is null/omitted', async () => {
+    it( 'passes empty args when input is omitted', async () => {
       const { workflow } = await import( './workflow.js' );
       executeChildMock.mockResolvedValueOnce( { output: {}, aggregations: null } );
 
@@ -494,6 +542,47 @@ describe( 'workflow()', () => {
       } ) );
     } );
 
+    it( 'merges per-child activity options into the propagated memo', async () => {
+      const { workflow } = await import( './workflow.js' );
+      executeChildMock.mockResolvedValueOnce( { output: {}, aggregations: null } );
+
+      const wf = workflow( {
+        name: 'child_options_wf',
+        description: 'Child options',
+        inputSchema: z.object( {} ),
+        outputSchema: z.object( {} ),
+        async fn() {
+          await this.startWorkflow( 'child_wf', { id: 1 }, {
+            options: {
+              activityOptions: {
+                startToCloseTimeout: '2m',
+                retry: { maximumAttempts: 7 }
+              }
+            }
+          } );
+          return {};
+        }
+      } );
+
+      await wf( {} );
+      expect( executeChildMock ).toHaveBeenCalledWith( 'child_wf', expect.objectContaining( {
+        memo: expect.objectContaining( {
+          traceInfo: expect.objectContaining( {
+            workflowId: 'trace-workflow-id',
+            runId: 'trace-run-id'
+          } ),
+          activityOptions: expect.objectContaining( {
+            startToCloseTimeout: '2m',
+            heartbeatTimeout: '5m',
+            retry: expect.objectContaining( {
+              initialInterval: '10s',
+              maximumAttempts: 7
+            } )
+          } )
+        } )
+      } ) );
+    } );
+
     it( 'returns child output and merges child workflow aggregations into the root aggregations', async () => {
       const { workflow } = await import( './workflow.js' );
       executeChildMock.mockResolvedValueOnce( {

package/src/internal_activities/index.js

@@ -56,11 +56,11 @@ export const sendHttpRequest = async ( { url, method, payload = undefined, heade
 setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
 
 /**
- * Invokes a trace method that resolves all trace output paths based on the executionContext
+ * Invokes a trace method that resolves all trace output paths based on the traceInfo
  *
- * @param {object} executionContext
+ * @param {object} traceInfo
  * @returns {object} Information about enabled destinations
  */
-export const getTraceDestinations = executionContext => getDestinations( executionContext );
+export const getTraceDestinations = traceInfo => getDestinations( traceInfo );
 
 setMetadata( getTraceDestinations, { type: ComponentType.INTERNAL_STEP } );

package/src/internal_activities/index.spec.js

@@ -2,7 +2,13 @@ import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MockAgent, setGlobalDispatcher } from 'undici';
 import { FatalError } from '#errors';
 import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
-import { sendHttpRequest } from './index.js';
+import { getTraceDestinations, sendHttpRequest } from './index.js';
+
+const getDestinationsMock = vi.hoisted( () => vi.fn() );
+
+vi.mock( '#tracing', () => ( {
+  getDestinations: getDestinationsMock
+} ) );
 
 vi.mock( '#logger', () => {
   const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
@@ -100,3 +106,27 @@ describe( 'internal_activities/sendHttpRequest', () => {
     expect( serializeBodyAndInferContentType ).not.toHaveBeenCalled();
   } );
 } );
+
+describe( 'internal_activities/getTraceDestinations', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'returns trace destinations for the given traceInfo', () => {
+    const traceInfo = {
+      workflowId: 'workflow-id',
+      runId: 'run-id',
+      workflowType: 'workflow',
+      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
+      disableTrace: false
+    };
+    const destinations = {
+      local: '/tmp/project/logs/runs/workflow/trace.json',
+      remote: null
+    };
+    getDestinationsMock.mockReturnValueOnce( destinations );
+
+    expect( getTraceDestinations( traceInfo ) ).toBe( destinations );
+    expect( getDestinationsMock ).toHaveBeenCalledWith( traceInfo );
+  } );
+} );

package/src/internal_utils/temporal_context.js

@@ -0,0 +1,12 @@
+export const createWorkflowDetails = info => ( {
+  attempt: info.attempt,
+  continuedFromExecutionRunId: info.continuedFromExecutionRunId,
+  firstExecutionRunId: info.firstExecutionRunId,
+  parent: info.parent,
+  root: info.root,
+  runId: info.runId,
+  runStartTime: info.runStartTime.getTime(),
+  startTime: info.startTime.getTime(),
+  workflowId: info.workflowId,
+  workflowType: info.workflowType
+} );

package/src/internal_utils/temporal_context.spec.ts

@@ -0,0 +1,83 @@
+import type { WorkflowInfo } from '@temporalio/workflow';
+import { describe, expect, it } from 'vitest';
+import { createWorkflowDetails } from './temporal_context.js';
+
+/*
+  This spec is TypeScript on purpose.
+  createWorkflowDetails() accepts a small projection of Temporal's WorkflowInfo,
+  so the fixture below uses Pick<WorkflowInfo, ...> to catch Temporal type drift
+  without exposing or maintaining the full native object in hook payloads.
+*/
+type WorkflowDetailsSource = Pick<
+  WorkflowInfo,
+  'attempt' |
+  'continuedFromExecutionRunId' |
+  'firstExecutionRunId' |
+  'parent' |
+  'root' |
+  'runId' |
+  'runStartTime' |
+  'startTime' |
+  'workflowId' |
+  'workflowType'
+>;
+
+describe( 'createWorkflowDetails', () => {
+  it( 'creates hook-safe workflow details from Temporal workflow info', () => {
+    const parent = { workflowId: 'parent-wf', runId: 'parent-run', namespace: 'default' };
+    const root = { workflowId: 'root-wf', runId: 'root-run' };
+    const workflowInfo = {
+      attempt: 2,
+      continuedFromExecutionRunId: 'previous-run',
+      firstExecutionRunId: 'first-run',
+      parent,
+      root,
+      runId: 'current-run',
+      runStartTime: new Date( '2026-06-02T09:30:00.000Z' ),
+      startTime: new Date( '2026-06-02T09:00:00.000Z' ),
+      workflowId: 'workflow-id',
+      workflowType: 'prompt'
+    } satisfies WorkflowDetailsSource;
+
+    expect( createWorkflowDetails( workflowInfo ) ).toEqual( {
+      attempt: 2,
+      continuedFromExecutionRunId: 'previous-run',
+      firstExecutionRunId: 'first-run',
+      parent,
+      root,
+      runId: 'current-run',
+      runStartTime: Date.parse( '2026-06-02T09:30:00.000Z' ),
+      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
+      workflowId: 'workflow-id',
+      workflowType: 'prompt'
+    } );
+  } );
+
+  it( 'preserves absent optional workflow relationships as undefined', () => {
+    const workflowInfo = {
+      attempt: 1,
+      continuedFromExecutionRunId: undefined,
+      firstExecutionRunId: 'first-run',
+      parent: undefined,
+      root: undefined,
+      runId: 'current-run',
+      runStartTime: new Date( '2026-06-02T09:30:00.000Z' ),
+      startTime: new Date( '2026-06-02T09:00:00.000Z' ),
+      workflowId: 'workflow-id',
+      workflowType: 'prompt'
+    } satisfies WorkflowDetailsSource;
+
+    expect( createWorkflowDetails( workflowInfo ) ).toEqual( {
+      attempt: 1,
+      continuedFromExecutionRunId: undefined,
+      firstExecutionRunId: 'first-run',
+      parent: undefined,
+      root: undefined,
+      runId: 'current-run',
+      runStartTime: Date.parse( '2026-06-02T09:30:00.000Z' ),
+      startTime: Date.parse( '2026-06-02T09:00:00.000Z' ),
+      workflowId: 'workflow-id',
+      workflowType: 'prompt'
+    } );
+  } );
+} );

package/src/internal_utils/trace_info.js

@@ -0,0 +1,21 @@
+import { inWorkflowContext, workflowInfo } from '@temporalio/workflow';
+
+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 } ) {
+    const info = inWorkflowContext() ? workflowInfo() : {};
+    return {
+      workflowId: info.workflowId,
+      workflowType: info.workflowType,
+      runId: info.runId,
+      startTime: info.startTime?.getTime(),
+      disableTrace
+    };
+  };
+}