@outputai/core 0.7.1-next.de30052.0 → 0.8.0

package/src/interface/validations/schemas.js

@@ -0,0 +1,113 @@
+import * as z from 'zod';
+import { EvaluationResult } from '../evaluation_result.js';
+
+/**
+ * Detects if a value behaves like a Zod v4 Classic/Mini schema.
+ *
+ * Zod v4 schemas from different package instances do not share the same
+ * prototype, so `instanceof z.ZodType` is too fragile here. The `_zod`
+ * property is the documented v4 runtime marker, and `safeParse` is required
+ * because the validators call it directly.
+ *
+ * @param {unknown} schema - The schema to check
+ * @returns {boolean} True if the schema is a Zod schema
+ */
+export const isZodSchema = schema =>
+  Boolean(
+    schema &&
+    typeof schema === 'object' &&
+    typeof schema._zod?.def?.type === 'string' &&
+    typeof schema.safeParse === 'function'
+  );
+
+const refineSchema = ( value, ctx ) => {
+  if ( !value || isZodSchema( value ) ) {
+    return;
+  }
+
+  ctx.addIssue( {
+    code: 'invalid_type',
+    message: 'Schema must be a Zod schema'
+  } );
+};
+
+const durationSchema = z.union( [ z.string().regex(
+  /^(\d+)(ms|s|m|h|d)$/,
+  'Expected duration like "500ms", "10s", "5m", "2h", or "1d"'
+), z.number() ] );
+
+const prioritySchema = z.object( {
+  fairnessKey: z.string().optional(),
+  fairnessWeight: z.number().min( 0.0001 ).max( 1000 ).optional(),
+  priorityKey: z.number().min( 1 ).optional()
+} );
+
+const activityOptionsSchema = z.strictObject( {
+  activityId: z.string().optional(),
+  cancellationType: z.enum( [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ).optional(),
+  heartbeatTimeout: durationSchema.optional(),
+  priority: prioritySchema.optional(),
+  retry: z.strictObject( {
+    initialInterval: durationSchema.optional(),
+    backoffCoefficient: z.number().gte( 1 ).optional(),
+    maximumInterval: durationSchema.optional(),
+    maximumAttempts: z.number().gte( 1 ).int().optional(),
+    nonRetryableErrorTypes: z.array( z.string() ).optional()
+  } ).optional(),
+  scheduleToCloseTimeout: durationSchema.optional(),
+  scheduleToStartTimeout: durationSchema.optional(),
+  startToCloseTimeout: durationSchema.optional(),
+  summary: z.string().optional()
+} );
+
+const baseSchema = z.strictObject( {
+  name: z.string().regex( /^[a-z_][a-z0-9_]*$/i ),
+  description: z.string().optional(),
+  inputSchema: z.any().optional().superRefine( refineSchema ),
+  outputSchema: z.any().optional().superRefine( refineSchema ),
+  fn: z.function(),
+  options: z.object( {
+    activityOptions: activityOptionsSchema.optional()
+  } ).optional()
+} );
+
+export const stepSchema = baseSchema;
+
+export const workflowSchema = baseSchema.extend( {
+  aliases: z.array( z.string().regex( /^[a-z_][a-z0-9_]*$/i ) ).optional().default( [] ),
+  options: baseSchema.shape.options.unwrap().extend( {
+    disableTrace: z.boolean().optional().default( false )
+  } ).optional()
+} );
+
+export const evaluatorSchema = baseSchema.omit( { outputSchema: true } );
+
+export const evaluatorOutputSchema = z.instanceof( EvaluationResult );
+
+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()
+} );
+
+export const workflowInvocationOptionsSchema = z.strictObject( {
+  detached: z.boolean().optional(),
+  activityOptions: activityOptionsSchema.optional(),
+  context: z.object( {
+    control: z.object( {
+      continueAsNew: z.function().optional(),
+      isContinueAsNewSuggested: z.function().optional()
+    } ).loose().optional(),
+    info: z.object( {
+      workflowId: z.string().optional(),
+      runId: z.string().optional()
+    } ).loose().optional()
+  } ).loose().optional()
+} ).optional();
+
+export const executeInParallelSchema = z.object( {
+  jobs: z.array( z.function() ),
+  concurrency: z.number().min( 1 ).or( z.literal( Infinity ) ),
+  onJobCompleted: z.function().optional()
+} );

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

@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import { z } from 'zod';
+import { EvaluationResult } from '../evaluation_result.js';
+import {
+  evaluatorOutputSchema,
+  evaluatorSchema,
+  executeInParallelSchema,
+  httpRequestSchema,
+  isZodSchema,
+  stepSchema,
+  workflowInvocationOptionsSchema,
+  workflowSchema
+} from './schemas.js';
+
+const fn = () => {};
+const validBase = {
+  name: 'valid_name',
+  description: 'Valid description',
+  inputSchema: z.object( { value: z.string() } ),
+  outputSchema: z.object( { result: z.string() } ),
+  fn,
+  options: {
+    activityOptions: {
+      startToCloseTimeout: '5m',
+      heartbeatTimeout: 1000,
+      retry: {
+        initialInterval: '10s',
+        backoffCoefficient: 2,
+        maximumInterval: '1m',
+        maximumAttempts: 3,
+        nonRetryableErrorTypes: [ 'FatalError' ]
+      },
+      priority: {
+        fairnessKey: 'tenant',
+        fairnessWeight: 1,
+        priorityKey: 2
+      },
+      summary: 'Short summary'
+    }
+  }
+};
+
+describe( 'validation schemas', () => {
+  describe( 'isZodSchema()', () => {
+    it( 'identifies Zod schemas', () => {
+      expect( isZodSchema( z.object( { name: z.string() } ) ) ).toBe( true );
+      expect( isZodSchema( z.string() ) ).toBe( true );
+      expect( isZodSchema( z.array( z.number() ) ) ).toBe( true );
+      expect( isZodSchema( z.union( [ z.string(), z.number() ] ) ) ).toBe( true );
+    } );
+
+    it( 'uses the Zod v4 runtime shape instead of instanceof', () => {
+      const schemaLikeFromAnotherPackageInstance = {
+        _zod: {
+          def: {
+            type: 'object'
+          }
+        },
+        safeParse: () => ( { success: true, data: {} } )
+      };
+
+      expect( isZodSchema( schemaLikeFromAnotherPackageInstance ) ).toBe( true );
+    } );
+
+    it( 'rejects non-Zod values', () => {
+      expect( isZodSchema( { type: 'object' } ) ).toBe( false );
+      expect( isZodSchema( {} ) ).toBe( false );
+      expect( isZodSchema( [] ) ).toBe( false );
+      expect( isZodSchema( null ) ).toBe( false );
+      expect( isZodSchema( undefined ) ).toBe( false );
+      expect( isZodSchema( 'string' ) ).toBe( false );
+    } );
+
+    it( 'rejects objects that only partially match the Zod shape', () => {
+      expect( isZodSchema( { safeParse: () => ( { success: true } ) } ) ).toBe( false );
+      expect( isZodSchema( { _zod: { def: { type: 'string' } } } ) ).toBe( false );
+      expect( isZodSchema( { _zod: { def: {} }, safeParse: () => ( { success: true } ) } ) ).toBe( false );
+      expect( isZodSchema( { _zod: null, safeParse: () => ( { success: true } ) } ) ).toBe( false );
+    } );
+  } );
+
+  describe( 'stepSchema', () => {
+    it( 'accepts a valid step definition', () => {
+      expect( stepSchema.safeParse( validBase ).success ).toBe( true );
+    } );
+
+    it( 'rejects invalid names, non-Zod schemas, invalid activity options, and unknown top-level keys', () => {
+      expect( stepSchema.safeParse( { ...validBase, name: 'invalid-name' } ).success ).toBe( false );
+      expect( stepSchema.safeParse( { ...validBase, inputSchema: { type: 'object' } } ).success ).toBe( false );
+      expect( stepSchema.safeParse( {
+        ...validBase,
+        options: { activityOptions: { retry: { maximumAttempts: 0 } } }
+      } ).success ).toBe( false );
+      expect( stepSchema.safeParse( { ...validBase, unexpected: true } ).success ).toBe( false );
+    } );
+  } );
+
+  describe( 'workflowSchema', () => {
+    it( 'accepts workflow-specific options and aliases', () => {
+      const result = workflowSchema.safeParse( {
+        ...validBase,
+        aliases: [ 'old_name' ],
+        options: {
+          ...validBase.options,
+          disableTrace: true
+        }
+      } );
+
+      expect( result.success ).toBe( true );
+    } );
+
+    it( 'defaults aliases and rejects invalid workflow fields', () => {
+      const result = workflowSchema.safeParse( validBase );
+      expect( result.success && result.data.aliases ).toEqual( [] );
+
+      expect( workflowSchema.safeParse( { ...validBase, aliases: [ 'bad-alias' ] } ).success ).toBe( false );
+      expect( workflowSchema.safeParse( {
+        ...validBase,
+        options: { ...validBase.options, disableTrace: 'yes' }
+      } ).success ).toBe( false );
+    } );
+  } );
+
+  describe( 'evaluatorSchema and evaluatorOutputSchema', () => {
+    it( 'accepts evaluator definitions without outputSchema', () => {
+      const { outputSchema: _outputSchema, ...validEvaluator } = validBase;
+      expect( evaluatorSchema.safeParse( validEvaluator ).success ).toBe( true );
+    } );
+
+    it( 'rejects evaluator definitions with outputSchema', () => {
+      expect( evaluatorSchema.safeParse( validBase ).success ).toBe( false );
+    } );
+
+    it( 'accepts only EvaluationResult instances as evaluator output', () => {
+      expect( evaluatorOutputSchema.safeParse( new EvaluationResult( { value: 'ok', confidence: 1 } ) ).success ).toBe( true );
+      expect( evaluatorOutputSchema.safeParse( { value: 'ok', confidence: 1 } ).success ).toBe( false );
+    } );
+  } );
+
+  describe( 'httpRequestSchema', () => {
+    it( 'accepts valid HTTP request payloads', () => {
+      expect( httpRequestSchema.safeParse( {
+        url: 'https://example.com',
+        method: 'POST',
+        payload: { ok: true },
+        headers: { authorization: 'Bearer token' }
+      } ).success ).toBe( true );
+    } );
+
+    it( 'rejects invalid URL protocols, methods, and header values', () => {
+      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( {
+        url: 'https://example.com',
+        method: 'GET',
+        headers: { count: 1 }
+      } ).success ).toBe( false );
+    } );
+  } );
+
+  describe( 'workflowInvocationOptionsSchema', () => {
+    it( 'accepts omitted options and valid invocation configuration', () => {
+      expect( workflowInvocationOptionsSchema.safeParse( undefined ).success ).toBe( true );
+      expect( workflowInvocationOptionsSchema.safeParse( {
+        detached: true,
+        activityOptions: { retry: { maximumAttempts: 1 } },
+        context: {
+          control: {
+            continueAsNew: fn,
+            isContinueAsNewSuggested: fn,
+            extraControl: true
+          },
+          info: {
+            workflowId: 'wf',
+            runId: 'run',
+            extraInfo: true
+          },
+          extraContext: true
+        }
+      } ).success ).toBe( true );
+    } );
+
+    it( 'rejects stale option shapes and invalid invocation values', () => {
+      expect( workflowInvocationOptionsSchema.safeParse( {
+        options: { activityOptions: { retry: { maximumAttempts: 1 } } }
+      } ).success ).toBe( false );
+      expect( workflowInvocationOptionsSchema.safeParse( { detached: 'true' } ).success ).toBe( false );
+      expect( workflowInvocationOptionsSchema.safeParse( {
+        activityOptions: { retry: { maximumAttempts: 0 } }
+      } ).success ).toBe( false );
+      expect( workflowInvocationOptionsSchema.safeParse( {
+        context: { control: { continueAsNew: 'nope' } }
+      } ).success ).toBe( false );
+    } );
+  } );
+
+  describe( 'executeInParallelSchema', () => {
+    it( 'accepts valid execution configs', () => {
+      expect( executeInParallelSchema.safeParse( { jobs: [ fn ], concurrency: 1 } ).success ).toBe( true );
+      expect( executeInParallelSchema.safeParse( { jobs: [ fn ], concurrency: Infinity, onJobCompleted: fn } ).success ).toBe( true );
+    } );
+
+    it( 'rejects invalid execution configs', () => {
+      expect( executeInParallelSchema.safeParse( { jobs: [], concurrency: 0 } ).success ).toBe( false );
+      expect( executeInParallelSchema.safeParse( { jobs: [ 'not-a-function' ], concurrency: 1 } ).success ).toBe( false );
+      expect( executeInParallelSchema.safeParse( { jobs: [ fn ], concurrency: 1, onJobCompleted: 'nope' } ).success ).toBe( false );
+    } );
+  } );
+} );

package/src/interface/webhook.js

@@ -2,7 +2,7 @@
 import { defineSignal, setHandler, proxyActivities, workflowInfo, proxySinks, uuid4, Trigger } from '@temporalio/workflow';
 import { ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 import { FatalError } from '#errors';
-import { validateRequestPayload } from './validations/static.js';
+import { validateRequestPayload } from './validations/index.js';
 
 /**
  * Call the internal activity to make a HTTP request and returns its response.

package/src/interface/webhook.spec.js

@@ -6,7 +6,7 @@ vi.mock( '#consts', () => ( {
 } ) );
 
 const validateRequestPayloadMock = vi.fn();
-vi.mock( './validations/static.js', () => ( {
+vi.mock( './validations/index.js', () => ( {
   validateRequestPayload: validateRequestPayloadMock
 } ) );
 

package/src/interface/workflow.d.ts

@@ -79,20 +79,21 @@ export type WorkflowContext<
 };
 
 /**
- * Configuration for workflow invocations.
+ * Options for workflow invocations.
  *
  * Allows overriding Temporal Activity options for this workflow.
  */
-export type WorkflowInvocationConfiguration<Context extends WorkflowContext = WorkflowContext> = {
+export type WorkflowInvocationOptions<Context extends WorkflowContext = WorkflowContext> = {
 
   /**
    * Temporal activity options for this invocation (overrides the workflow's default activity options).
    */
-  options?: TemporalActivityOptions,
+  activityOptions?: TemporalActivityOptions,
 
   /**
-   * Configures whether this workflow runs detached.
-   * Detached workflows called without explicitly awaiting the result are "fire-and-forget" and may outlive the parent.
+   * Configures whether this workflow runs detached:
+   * - `detached=true` maps to `ParentClosePolicy.ABANDON`: if parent closes before child, the child keeps executing.
+   * - `detached=false` maps to `ParentClosePolicy.TERMINATE`: if parent closes before child, the child is terminated.
    */
   detached?: boolean,
 
@@ -140,19 +141,19 @@ export type WorkflowFunction<
  *
  * It accepts the same input and returns the same value, calling the user function inside.
  *
- * The second argument is a WorkflowInvocationConfiguration object, allowing workflows configuration overwrite.
+ * The second argument is a WorkflowInvocationOptions object, allowing workflows configuration overwrite.
  *
  * It adds input and output validation based on the `inputSchema`, `outputSchema`.
  *
  * @param input - The workflow input; it matches the schema defined by `inputSchema`.
- * @param config - Additional configuration for the invocation.
+ * @param options - Additional options for the invocation.
  * @returns A value matching the schema defined by `outputSchema`.
  */
 export type WorkflowFunctionWrapper<WorkflowFunction> =
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
-    ( input?: undefined | null, config?: WorkflowInvocationConfiguration ) =>
+    ( input?: undefined | null, options?: WorkflowInvocationOptions ) =>
     ReturnType<WorkflowFunction> :
-    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration ) =>
+    ( input: Parameters<WorkflowFunction>[0], options?: WorkflowInvocationOptions ) =>
     ReturnType<WorkflowFunction>;
 
 /**

package/src/interface/workflow.js

@@ -1,202 +1,114 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 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 { WorkflowValidator } from './validations/index.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 { defaultOptions } from './workflow_activity_options.js';
 import {
-  ACTIVITY_GET_TRACE_DESTINATIONS,
   ACTIVITY_WRAPPER_VERSION_FIELD,
+  ACTIVITY_GET_TRACE_DESTINATIONS,
   METADATA_ACCESS_SYMBOL,
   SHARED_STEP_PREFIX,
-  Signal,
   WORKFLOW_WRAPPER_VERSION_FIELD
 } from '#consts';
 
-const defaultOptions = {
-  activityOptions: {
-    startToCloseTimeout: '20m',
-    heartbeatTimeout: '5m',
-    retry: {
-      initialInterval: '10s',
-      backoffCoefficient: 2.0,
-      maximumInterval: '2m',
-      maximumAttempts: 3,
-      nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
-    }
-  },
-  disableTrace: false
-};
+/**
+ * @temp
+ * This is to keep backwards compatibility [OUT-468]
+ */
+const parseActivityOutput = p => Object.hasOwn( p ?? {}, ACTIVITY_WRAPPER_VERSION_FIELD ) ? p.output : p;
 
 /**
- * Checks if the activity result uses the internal wrapper
+ * @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 isActivityResultWrapped = result => result?.[ACTIVITY_WRAPPER_VERSION_FIELD] > 0;
+const checkChildFallback = ( { workflowType, name, aliases } ) => workflowType !== name && !aliases.includes( workflowType );
 
+/**
+ * Create a new workflow and return a wrapper function around its fn handler
+ */
 export function workflow( { name, description, inputSchema, outputSchema, fn, options = {}, aliases = [] } ) {
-  validateWorkflow( { name, description, inputSchema, outputSchema, fn, options, aliases } );
+  WorkflowValidator.validateDefinition( { name, description, inputSchema, outputSchema, fn, options, aliases } );
 
   const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
-  const steps = proxyActivities( activityOptions );
-
-  /**
-   * Wraps the `fn` function of the workflow
-   *
-   * @param {unknown} input - The input, must match the inputSchema
-   * @param {object} extra - Workflow configurations (received directly only in unit tests)
-   * @returns {unknown} The result, will match the outputSchema
-   */
+  const validator = new WorkflowValidator( { name, inputSchema, outputSchema } );
+
   const wrapper = async ( input, extra = {} ) => {
+    validator.validateInvocationOptions( extra );
+
     // this returns a plain function, for example, in unit tests
     if ( !inWorkflowContext() ) {
-      validateWithSchema( inputSchema, input, `Workflow ${name} input` );
-      const output = await fn( input, deepMerge( WorkflowContext.build(), extra.context ) );
-      validateWithSchema( outputSchema, output, `Workflow ${name} output` );
+      validator.validateInput( input );
+      const output = await fn( input, deepMerge( WorkflowContext.build(), extra?.context ) );
+      validator.validateOutput( output );
       return output;
     }
 
-    const { workflowId, memo, root } = workflowInfo();
-    const context = WorkflowContext.build();
+    const { workflowId, workflowType, 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 } );
+
+    if ( isChild ) {
+      const result = await executeChild( name, {
+        args: undefined === input ? [] : [ input ],
+        workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
+        parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
+        memo: {
+          ...memo, // Preserve memo and mix activityOptions, if provided
+          ...( extra?.activityOptions && {
+            activityOptions: deepMerge( memo?.activityOptions ?? {}, extra?.activityOptions )
+          } )
+        }
+      } );
+      return result.output;
+    }
 
     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, {
-      traceInfo: memo.traceInfo ?? TraceInfo.build( { disableTrace } ),
-      activityOptions: memo.activityOptions ?? activityOptions
-    } );
-
-    /**
-     * Run the internal activity to retrieve the workflow trace destinations
-     * This only happens at the root workflow because nested share the same trace file
-     * @IMPORTANT Keep support for deprecated non-wrapped activity result to allow for Temporal replays.
-     * @TODO [OUT-468]
-    */
-    const getTraceDestinations = async () => {
-      const result = await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo );
-      return isActivityResultWrapped( result ) ? result.output : result;
-    };
-
-    // Creates the result wrapper with information about the workflow
-    const workflowResult = {
-      [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-      aggregations: null,
-      ...( isRoot && {
-        trace: {
-          destinations: await getTraceDestinations()
-        }
-      } )
-    };
-
-    // Combine aggregations in the workflow result aggregations, mutating it
-    const mergeAggregationsInWorkflowResult = aggregations => {
-      workflowResult.aggregations = mergeAggregations( workflowResult.aggregations, aggregations );
-    };
-
-    setHandler( defineSignal( Signal.SEND_AGGREGATIONS ), aggregations => {
-      mergeAggregationsInWorkflowResult( aggregations );
-    } );
-
-    /**
-     * @IMPORTANT Keep support for deprecated add_attribute Signal to allow for Temporal replays.
-     * @TODO This can be removed 30days after this release
-     */
-    setHandler( defineSignal( 'add_attribute' ), attribute => {
-      mergeAggregationsInWorkflowResult( aggregateAttributes( [ attribute ] ) );
-    } );
-
-    /**
-     * Invoke a step and unwraps the result to extract and merge "aggregations" and return only the output.
-     *
-     * @IMPORTANT Keep support for deprecated non-wrapped activity result to allow for Temporal replays.
-     * @TODO [OUT-468]
-     * @param {Function} step
-     * @param  {...any} args
-     * @returns {any} The step "output"
-     */
-    const callStepAndUnwrapResult = async ( step, ...args ) => {
-      const result = await step( ...args );
-      if ( !isActivityResultWrapped( result ) ) {
-        return result;
-      }
-      const { output, aggregations } = result;
-      if ( aggregations ) {
-        mergeAggregationsInWorkflowResult( aggregations );
-      }
-      return output;
-    };
+    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 } );
+    }
+
+    const steps = proxyActivities( memo.activityOptions );
+    const traceDest = isRoot && parseActivityOutput( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) );
 
     try {
-      // validation comes after setting memo to have that info already set for interceptor even if validations fail
-      validateWithSchema( inputSchema, input, `Workflow ${name} input` );
+      validator.validateInput( input );
 
+      // Creates an activity caller based on a prefix
+      const createCaller = prefix => async ( t, ...args ) => parseActivityOutput( await steps[`${prefix}#${t}`]( ...args ) );
+
+      // This are functions used by the AST to replace direct activity (step/evaluator) calls
       const dispatchers = {
-        /* This are shortcuts to invoke activities as steps/evaluators both shared and non shared */
-        invokeStep: async ( stepName, input, options ) =>
-          callStepAndUnwrapResult( steps[`${name}#${stepName}`], input, options ),
-        invokeSharedStep: async ( stepName, input, options ) =>
-          callStepAndUnwrapResult( steps[`${SHARED_STEP_PREFIX}#${stepName}`], input, options ),
-        invokeEvaluator: async ( evaluatorName, input, options ) =>
-          callStepAndUnwrapResult( steps[`${name}#${evaluatorName}`], input, options ),
-        invokeSharedEvaluator: async ( evaluatorName, input, options ) =>
-          callStepAndUnwrapResult( steps[`${SHARED_STEP_PREFIX}#${evaluatorName}`], input, options ),
-
-        // Start a new child workflow
-        startWorkflow: async ( childName, input, extra = {} ) => {
-          try {
-            const result = await executeChild( childName, {
-              args: undefined === input ? [] : [ input ],
-              workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
-              parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
-              memo: {
-                ...memo,
-                ...( extra?.options?.activityOptions && { activityOptions: deepMerge( activityOptions, extra.options.activityOptions ) } )
-              }
-            } );
-            /**
-             * @IMPORTANT Keep support for deprecated ".attributes" from workflow results to allow for Temporal replays.
-             * @TODO [OUT-468]
-             */
-            if ( result?.attributes ) {
-              mergeAggregationsInWorkflowResult( aggregateAttributes( result.attributes ) );
-            }
-            if ( result?.aggregations ) {
-              mergeAggregationsInWorkflowResult( result.aggregations );
-            }
-            return result.output;
-          } catch ( error ) {
-            /**
-             * @IMPORTANT Keep support for deprecated ".attributes" from workflow errors to allow for Temporal replays.
-             * @TODO [OUT-468]
-             */
-            const attributesFromError = extractErrorDetail( error, 'attributes' );
-            if ( attributesFromError ) {
-              mergeAggregationsInWorkflowResult( aggregateAttributes( attributesFromError ) );
-            }
-            const aggregationsFromError = extractErrorDetail( error, 'aggregations' );
-            if ( aggregationsFromError ) {
-              mergeAggregationsInWorkflowResult( aggregationsFromError );
-            }
-            throw error;
-          }
-        }
+        invokeStep: createCaller( name ),
+        invokeSharedStep: createCaller( SHARED_STEP_PREFIX ),
+        invokeEvaluator: createCaller( name ),
+        invokeSharedEvaluator: createCaller( SHARED_STEP_PREFIX )
       };
 
-      workflowResult.output = await fn.call( dispatchers, input, context );
-
-      validateWithSchema( outputSchema, workflowResult.output, `Workflow ${name} output` );
+      // The workflow function execution with "this" set with the dispatchers
+      const output = await fn.call( dispatchers, input, WorkflowContext.build() );
+      validator.validateOutput( output );
 
-      return workflowResult;
-    } catch ( e ) {
-      // Append the result as metadata of the error, so it can be read by the interceptor.
-      e[METADATA_ACCESS_SYMBOL] = { ...( e[METADATA_ACCESS_SYMBOL] ?? {} ), ...workflowResult };
-      throw e;
+      return {
+        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+        output,
+        ...( traceDest && { trace: { destinations: traceDest } } )
+      };
+    } catch ( error ) {
+      if ( isRoot && traceDest ) {
+        // Append the trace destinations so it is carried to interceptor
+        error[METADATA_ACCESS_SYMBOL] = { trace: { destinations: traceDest } };
+      }
+      throw error;
     }
   };