@output.ai/core 0.1.0 → 0.1.2

package/README.md

@@ -4,45 +4,43 @@ Provides tools to develop and run a workflow, which is a well defined logical un
 
 ## Structure
 
-Workflows are defined using core functions "workflow" and "step", separate files:
+Workflows are defined using core functions ("workflow", "step", "evaluator"), these are defined in separate files, and must be placed within the same folder:
 
 ```
 └ workflows
   └ example
     ├ workflow.ts|js <- workflow entry point
-    ├ steps.ts|js <- file with each step of this workflow
+    ├ steps.ts|js <- file containing steps used by the workflow
+    ├ evaluators.ts|js <- file containing evaluating functions
     └ prompt.prompt <- a prompt file
   └ other-example
 
 ```
 
-Think that workflows is the orchestrator and steps are executors. So the workflow only call the steps and the steps call the IO operations, like APIs, DBs, LLMs, etc.
+Workflows are the orchestrator and steps are executors. So the workflow only call the steps and the steps call the IO operations, like APIs, DBs, LLMs, etc. Evaluators are just another different flavor for steps, they work the same, but must return an `EvaluationResult` object.
 
-## Workflow code
+## Components
 
-### workflow.js
+### Workflow
 
+The main code, must contain only deterministic orchestration code.
+
+File: `workflow.js`
+
+Example:
 ```js
-import { workflow } from '@output.ai/workflow';
+import { workflow, z } from '@output.ai/workflow';
 import { guessByName } from './steps.js';
 
 export default workflow( {
   name: 'guessMyProfession',
   description: 'Guess a person profession by its name',
-  inputSchema: {
-    type: 'object',
-    required: [ 'name' ],
-    properties: {
-      name: { type: 'string'}
-    }
-  },
-  outputSchema: {
-    type: 'object',
-    required: [ 'profession' ],
-    properties: {
-      profession: { type: 'string'}
-    }
-  },
+  inputSchema: z.object( {
+    name: z.string()
+  } ),
+  outputSchema: z.object( {
+    profession: z.string()
+  } ),
   fn: async input => {
     const profession = await guessByName( input.name );
     return { profession };
@@ -50,19 +48,20 @@ export default workflow( {
 })
 ```
 
-### steps.js
+### Step
 
+Re-usable units of work that can contain IO, used by the workflow.
+
+File: `steps.js`
+
+Example:
 ```js
 import { api } from './api.js'
 
 export const guessByName = step( {
   name: 'guessByName',
-  inputSchema: {
-    type: 'string'
-  },
-  outputSchema: {
-    type: 'string'
-  },
+  inputSchema: z.string(),
+  outputSchema: z.string(),
   fn: async name => {
     const res = await api.consumer( name );
     return res.body;
@@ -70,9 +69,73 @@ export const guessByName = step( {
 } )
 ```
 
-## webhooks
+### Shared Steps
+
+By default, steps are exclusive to the workflow, so it is not passible to use these steps from elsewhere. In order to have shared steps and make them accessible in different workflows, create a shared steps file. This file can be relatively imported anywhere.
+
+File: `shared_steps.js`
+
+Example:
+```js
+export const mySharedStep = step( {
+  name: 'mySharedStep',
+  ...
+} )
+```
+
+And the usage is the same as any step:
+`workflow.js`
+```js
+import { mySharedStep } from '../../tools/shared_steps.js'
+```
 
-workflows can call webhooks that will stop their execution until an answer is given back.
+### Evaluators
+
+Steps that analyze LLM response, or take other measurements are contained in evaluators.
+
+File: `evaluators.js`
+
+Example:
+```js
+import { evaluator, EvaluationStringResult } from './api.js'
+
+export const judgeResult = evaluator( {
+  name: 'judgeResult',
+  inputSchema: z.string(),
+  fn: async name => {
+    ...
+    return new EvaluationStringResult({
+      value: 'good',
+      confidence: .95
+    });
+  }
+} )
+```
+
+Its usage is the same as steps:
+`workflow.js`
+```js
+import { workflow, z } from '@output.ai/workflow';
+import { judgeResult } from './evaluators.js';
+
+export default workflow( {
+  name: 'guessMyProfession',
+  inputSchema: z.object( {
+    name: z.string()
+  } ),
+  outputSchema: z.object( {
+    result: z.string()
+  } ),
+  fn: async input => {
+    const judgment = await judgeResult( input.name );
+    return { result: judgement.value };
+  }
+})
+```
+
+## Webhooks
+
+Workflows can call webhooks that will stop their execution until an answer is given back.
 
 ```js
 import { workflow, createWebhook } from '@output.ai/workflow';
@@ -119,6 +182,21 @@ POST http://locahost:3001/workflow/feedback
   }
 ```
 
+## Options
+
+All core interface functions: workflow, step, evaluator have similar signature, with the following options:
+- name: The function name, used to call it internally and identify it in the trace files, must be a code friendly string;
+- description: Human description of the workflow/step, used for the catalog;
+- inputSchema: a zod object indicating the type of the argument received by the `fn` function. It is validated. Omit if it doesn't have input arguments;
+- outputSchema: a zod object indicating the type of that the `fn` function returns. It is validated. Omit if it is void. Evaluators do not have this option, since they must always return an EvaluationResult object;
+- fn: The actual implementation of the workflow/step, including all its logic.
+- options: Advanced options that will overwrite Temporal's ActivityOptions when calling activities.
+
+  If used on `workflow()` it will apply for all activities. If used on `step()` or `evaluator()` it will apply only to that underlying activity. If changed in both places, the end value will be a merge between the initial values, workflow values and the step values.
+
+  Order of precedence
+  `step options > workflow options > default options`
+
 ## Developing
 
 To develop workflows you need the code, which will be called the worker, the API and the engine (Temporal).
@@ -138,4 +216,10 @@ Necessary env variables to run the worker locally:
 - `TEMPORAL_API_KEY`: The API key to access remote temporal. If using local temporal, leave it blank;
 - `CATALOG_ID`: The name of the local catalog, always set this. Use your email;
 - `API_AUTH_KEY`: The API key to access the Framework API. Local can be blank, remote use the proper API Key;
-- `TRACING_ENABLED`: A "stringbool" value indicating if traces should be generated or not;
+- `TRACE_LOCAL_ON`: A "stringbool" value indicating if traces should be saved locally, needs REDIS_URL;
+- `TRACE_REMOTE_ON`: A "stringbool" value indicating if traces should be saved remotely, needs REDIS_URL and AWS_* secrets;
+- `REDIS_URL`: The redis address to connect. Only necessary when any type of trace is enabled;
+- `TRACE_REMOTE_S3_BUCKET`: The AWS S3 bucket to send the traces. Only necessary when remote trace is enabled;
+- `AWS_REGION`: AWS region to connect to send the traces, must match the bucket region. Only necessary when remote trace is enabled;
+- `AWS_ACCESS_KEY_ID`: AWS key id. Only necessary when remote trace is enabled;
+- `AWS_SECRET_ACCESS_KEY`: AWS secrete. Only necessary when remote trace is enabled;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -25,21 +25,24 @@
     "worker": "node ./src/worker/index.js"
   },
   "dependencies": {
+    "@aws-sdk/client-s3": "3.913.0",
     "@babel/generator": "7.28.3",
     "@babel/parser": "7.28.4",
     "@babel/traverse": "7.28.4",
     "@babel/types": "7.28.4",
-    "@temporalio/worker": "1.13.0",
-    "@temporalio/workflow": "1.13.0",
-    "zod": "4.1.9"
+    "@temporalio/worker": "1.13.1",
+    "@temporalio/workflow": "1.13.1",
+    "redis": "5.8.3",
+    "zod": "4.1.12"
   },
   "license": "UNLICENSED",
   "imports": {
     "#consts": "./src/consts.js",
-    "#configs": "./src/configs.js",
     "#errors": "./src/errors.js",
-    "#tracing": "./src/tracing/index.js",
+    "#utils": "./src/utils.js",
+    "#tracing": "./src/tracing/internal_interface.js",
     "#async_storage": "./src/async_storage.js",
+    "#temporal_options": "./src/temporal_options.js",
     "#internal_activities": "./src/internal_activities/index.js"
   }
 }

package/src/consts.js

@@ -1,7 +1,9 @@
 export const ACTIVITY_SEND_WEBHOOK = '__internal#sendWebhook';
-export const ACTIVITY_READ_TRACE_FILE = '__internal#readTraceFile';
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+export const SHARED_STEP_PREFIX = '__shared#';
 export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';
+export const ACTIVITY_OPTIONS_FILENAME = '__activity_options.js';
+export const WORKFLOW_CATALOG = '$catalog';
 export const ComponentType = {
   EVALUATOR: 'evaluator',
   INTERNAL_STEP: 'internal_step',

package/src/index.d.ts

@@ -1,5 +1,6 @@
 // Import Zod types for dual schema support
 import type { z } from 'zod';
+import type { ActivityOptions } from '@temporalio/workflow';
 
 // Re-export Zod for consumers to use
 export { z } from 'zod';
@@ -19,6 +20,17 @@ export { z } from 'zod';
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 type AnyZodSchema = z.ZodType<any, any, any>;
 
+/**
+ * Activity retry options accepted by step/evaluator/workflow definitions.
+ * Uses Temporal's ActivityOptions['retry'] type.
+ */
+export type Options = { retry?: ActivityOptions['retry'] };
+
+/**
+ * @typedef {object} Options
+ * @property {import('@temporalio/workflow').ActivityOptions['retry']} [retry]
+ */
+
 /*
 ╭─────────╮
 │ S T E P │╮
@@ -43,6 +55,7 @@ type AnyZodSchema = z.ZodType<any, any, any>;
  * @param {z.ZodType} options.inputSchema - Zod schema for the fn input
  * @param {z.ZodType} options.outputSchema - Zod schema for the fn output
  * @param {function} options.fn - The function logic: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Function with signature: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
  */
 export async function step<
@@ -54,6 +67,7 @@ export async function step<
   inputSchema: InputSchema;
   outputSchema: OutputSchema;
   fn: ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
+  options?: Options;
 } ): ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
 
 /**
@@ -64,6 +78,7 @@ export async function step<
  * @param {string} [options.description] - Description of the step
  * @param {z.ZodType} options.inputSchema - Zod schema for the fn input
  * @param {function} options.fn - The function logic: `(input: z.infer<InputSchema>) => Promise<void>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Function with signature: `(input: z.infer<InputSchema>) => Promise<void>`
  */
 export async function step<
@@ -73,6 +88,7 @@ export async function step<
   description?: string;
   inputSchema: InputSchema;
   fn: ( input: z.infer<InputSchema> ) => Promise<void>;
+  options?: Options;
 } ): ( input: z.infer<InputSchema> ) => Promise<void>;
 
 /**
@@ -83,6 +99,7 @@ export async function step<
  * @param {string} [options.description] - Description of the step
  * @param {z.ZodType} options.outputSchema - Zod schema for the fn output
  * @param {function} options.fn - The function logic: `() => Promise<z.infer<OutputSchema>>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Function with signature: `() => Promise<z.infer<OutputSchema>>`
  */
 export async function step<
@@ -92,6 +109,7 @@ export async function step<
   description?: string;
   outputSchema: OutputSchema;
   fn: () => Promise<z.infer<OutputSchema>>;
+  options?: Options;
 } ): () => Promise<z.infer<OutputSchema>>;
 
 /**
@@ -101,12 +119,14 @@ export async function step<
  * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
  * @param {string} [options.description] - Description of the step
  * @param {function} options.fn - The function logic: `() => Promise<void>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Function with signature: `() => Promise<void>`
  */
 export async function step( options: {
   name: string;
   description?: string;
   fn: () => Promise<void>;
+  options?: Options;
 } ): () => Promise<void>;
 
 /*
@@ -132,6 +152,7 @@ export async function step( options: {
  * @param {z.ZodType} options.inputSchema - Zod schema for workflow input
  * @param {z.ZodType} options.outputSchema - Zod schema for workflow output
  * @param {function} options.fn - Workflow logic: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Callable workflow function: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
  */
 export function workflow<
@@ -142,7 +163,8 @@ export function workflow<
   description?: string,
   inputSchema: InputSchema,
   outputSchema: OutputSchema,
-  fn: ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>
+  fn: ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>,
+  options?: Options
 } ): ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
 
 /**
@@ -153,6 +175,7 @@ export function workflow<
  * @param {string} [options.description] - Description of the workflow
  * @param {z.ZodType} options.inputSchema - Zod schema for workflow input
  * @param {function} options.fn - Workflow logic: `(input: z.infer<InputSchema>) => Promise<void>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Callable workflow function: `(input: z.infer<InputSchema>) => Promise<void>`
  */
 export function workflow<
@@ -161,7 +184,8 @@ export function workflow<
   name: string,
   description?: string,
   inputSchema: InputSchema,
-  fn: ( input: z.infer<InputSchema> ) => Promise<void>
+  fn: ( input: z.infer<InputSchema> ) => Promise<void>,
+  options?: Options
 } ): ( input: z.infer<InputSchema> ) => Promise<void>;
 
 /**
@@ -172,6 +196,7 @@ export function workflow<
  * @param {string} [options.description] - Description of the workflow
  * @param {z.ZodType} options.outputSchema - Zod schema for workflow output
  * @param {function} options.fn - Workflow logic: `() => Promise<z.infer<OutputSchema>>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Callable workflow function: `() => Promise<z.infer<OutputSchema>>`
  */
 export function workflow<
@@ -180,7 +205,8 @@ export function workflow<
   name: string,
   description?: string,
   outputSchema: OutputSchema,
-  fn: () => Promise<z.infer<OutputSchema>>
+  fn: () => Promise<z.infer<OutputSchema>>,
+  options?: Options
 } ): () => Promise<z.infer<OutputSchema>>;
 
 /**
@@ -190,12 +216,14 @@ export function workflow<
  * @param {string} options.name - Unique workflow name
  * @param {string} [options.description] - Description of the workflow
  * @param {function} options.fn - Workflow logic: `() => Promise<void>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Callable workflow function: `() => Promise<void>`
  */
 export function workflow( options : {
   name: string,
   description?: string,
-  fn: () => Promise<void>
+  fn: () => Promise<void>,
+  options?: Options
 } ): () => Promise<void>;
 
 /*
@@ -309,6 +337,7 @@ export class EvaluationBooleanResult extends EvaluationResult {
  * @param {string} [options.description] - Description of the evaluator
  * @param {z.ZodType} options.inputSchema - Zod schema for the fn input
  * @param {function} options.fn - The function logic: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Function with signature: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
  */
 export async function evaluator<
@@ -319,6 +348,7 @@ export async function evaluator<
   description?: string;
   inputSchema: InputSchema;
   fn: ( input: z.infer<InputSchema> ) => Promise<Result>;
+  options?: Options;
 } ): ( input: z.infer<InputSchema> ) => Promise<Result>;
 
 /**
@@ -329,6 +359,7 @@ export async function evaluator<
  * @param {string} [options.description] - Description of the evaluator
  * @param {z.ZodType} options.inputSchema - Zod schema for the fn input
  * @param {function} options.fn - The function logic: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
+ * @param {Options} [options.options] - Activity retry options
  * @returns {function} Function with signature: `(input: z.infer<InputSchema>) => Promise<z.infer<OutputSchema>>`
  */
 export async function evaluator<
@@ -338,6 +369,7 @@ export async function evaluator<
   name: string;
   description?: string;
   fn: ( input: z.infer<InputSchema> ) => Promise<Result>;
+  options?: Options;
 } ): ( input: z.infer<InputSchema> ) => Promise<Result>;
 
 /*

package/src/interface/evaluator.js

@@ -1,6 +1,6 @@
-import { setMetadata } from './metadata.js';
 import { validateEvaluator } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
+import { setMetadata } from '#utils';
 import { ValidationError } from '#errors';
 import { ComponentType } from '#consts';
 import * as z from 'zod';
@@ -48,7 +48,8 @@ export class EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    if ( !EvaluationResult.#schema.safeParse( args ) ) {
+    const result = EvaluationResult.#schema.safeParse( args );
+    if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
     this.value = args.value;
@@ -73,7 +74,8 @@ export class EvaluationStringResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    if ( !EvaluationStringResult.#valueSchema.safeParse( args.value ) ) {
+    const result = EvaluationStringResult.#valueSchema.safeParse( args.value );
+    if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
     super( args );
@@ -96,7 +98,8 @@ export class EvaluationBooleanResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    if ( !EvaluationBooleanResult.#valueSchema.safeParse( args.value ) ) {
+    const result = EvaluationBooleanResult.#valueSchema.safeParse( args.value );
+    if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
     super( args );
@@ -119,15 +122,16 @@ export class EvaluationNumberResult extends EvaluationResult {
    * @param {string} [args.reasoning] - The reasoning behind the result
    */
   constructor( args ) {
-    if ( !EvaluationNumberResult.#valueSchema.safeParse( args.value ) ) {
+    const result = EvaluationNumberResult.#valueSchema.safeParse( args.value );
+    if ( result.error ) {
       throw new EvaluationResultValidationError( z.prettifyError( result.error ) );
     }
     super( args );
   }
 };
 
-export function evaluator( { name, description, inputSchema, fn } ) {
-  validateEvaluator( { name, description, inputSchema, fn } );
+export function evaluator( { name, description, inputSchema, fn, options } ) {
+  validateEvaluator( { name, description, inputSchema, fn, options } );
 
   const wrapper = async input => {
     validateWithSchema( inputSchema, input, `Evaluator ${name} input` );
@@ -141,6 +145,6 @@ export function evaluator( { name, description, inputSchema, fn } ) {
     return output;
   };
 
-  setMetadata( wrapper, { name, description, inputSchema, type: ComponentType.EVALUATOR } );
+  setMetadata( wrapper, { name, description, inputSchema, type: ComponentType.EVALUATOR, options } );
   return wrapper;
 };

package/src/interface/step.js

@@ -1,10 +1,10 @@
-import { setMetadata } from './metadata.js';
+import { setMetadata } from '#utils';
 import { validateStep } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { ComponentType } from '#consts';
 
-export function step( { name, description, inputSchema, outputSchema, fn } ) {
-  validateStep( { name, description, inputSchema, outputSchema, fn } );
+export function step( { name, description, inputSchema, outputSchema, fn, options } ) {
+  validateStep( { name, description, inputSchema, outputSchema, fn, options } );
 
   const wrapper = async input => {
     validateWithSchema( inputSchema, input, `Step ${name} input` );
@@ -16,6 +16,6 @@ export function step( { name, description, inputSchema, outputSchema, fn } ) {
     return output;
   };
 
-  setMetadata( wrapper, { name, description, inputSchema, outputSchema, type: ComponentType.STEP } );
+  setMetadata( wrapper, { name, description, inputSchema, outputSchema, type: ComponentType.STEP, options } );
   return wrapper;
 };

package/src/interface/validations/static.js

@@ -17,12 +17,26 @@ const refineSchema = ( value, ctx ) => {
   } );
 };
 
-const stepAndWorkflowSchema = z.object( {
+export const durationStringSchema = z.string().regex(
+  /^(\d+)(ms|s|m|h|d)$/,
+  'Expected duration like "500ms", "10s", "5m", "2h", or "1d"'
+);
+
+const stepAndWorkflowSchema = 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()
+  fn: z.function(),
+  options: z.strictObject( {
+    retry: z.strictObject( {
+      initialInterval: durationStringSchema.optional(),
+      backoffCoefficient: z.number().gte( 1 ).optional(),
+      maximumInterval: durationStringSchema.optional(),
+      maximumAttempts: z.number().gte( 1 ).int().optional(),
+      nonRetryableErrorTypes: z.array( z.string() ).optional()
+    } ).optional()
+  } ).optional()
 } );
 
 const evaluatorSchema = stepAndWorkflowSchema.omit( { outputSchema: true } );

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

@@ -65,6 +65,26 @@ describe( 'interface/validator', () => {
       const error = new StaticValidationError( '✖ Invalid input: expected function, received string\n  → at fn' );
       expect( () => validateStep( { ...validArgs, fn: 'not-fn' } ) ).toThrow( error );
     } );
+
+    it( 'passes with options.retry (second-level options)', () => {
+      const args = {
+        ...validArgs,
+        options: {
+          retry: {
+            initialInterval: '1s',
+            backoffCoefficient: 2,
+            maximumInterval: '10s',
+            maximumAttempts: 3,
+            nonRetryableErrorTypes: [ 'SomeError' ]
+          }
+        }
+      };
+      expect( () => validateStep( args ) ).not.toThrow();
+    } );
+
+    it( 'rejects unknown top-level keys due to strictObject', () => {
+      expect( () => validateStep( { ...validArgs, extra: 123 } ) ).toThrow( StaticValidationError );
+    } );
   } );
 
   describe( 'validateWorkflow', () => {

package/src/interface/workflow.js

@@ -1,28 +1,29 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { proxyActivities, inWorkflowContext, executeChild, workflowInfo } from '@temporalio/workflow';
 import { getInvocationDir } from './utils.js';
-import { setMetadata } from './metadata.js';
-import { FatalError, ValidationError } from '#errors';
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
-import { ACTIVITY_READ_TRACE_FILE } from '#consts';
+import { SHARED_STEP_PREFIX } from '#consts';
+import { mergeActivityOptions, setMetadata } from '#utils';
+import { FatalError, ValidationError } from '#errors';
 
-const temporalActivityConfigs = {
-  startToCloseTimeout: '20 minute',
+const defaultActivityOptions = {
+  startToCloseTimeout: '20m',
   retry: {
     initialInterval: '10s',
     backoffCoefficient: 2.0,
-    maximumInterval: '2 minutes',
+    maximumInterval: '2m',
     maximumAttempts: 3,
     nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
   }
 };
 
-export function workflow( { name, description, inputSchema, outputSchema, fn } ) {
-  validateWorkflow( { name, description, inputSchema, outputSchema, fn } );
+export function workflow( { name, description, inputSchema, outputSchema, fn, options } ) {
+  validateWorkflow( { name, description, inputSchema, outputSchema, fn, options } );
   const workflowPath = getInvocationDir();
 
-  const steps = proxyActivities( temporalActivityConfigs );
+  const activityOptions = mergeActivityOptions( defaultActivityOptions, options );
+  const steps = proxyActivities( activityOptions );
 
   const wrapper = async input => {
     validateWithSchema( inputSchema, input, `Workflow ${name} input` );
@@ -34,33 +35,35 @@ export function workflow( { name, description, inputSchema, outputSchema, fn } )
       return output;
     }
 
-    const { workflowId, memo } = workflowInfo();
+    const { workflowId, memo, startTime } = workflowInfo();
 
-    // keep trace id and helm from memo if present (child workflow)
-    const traceId = memo.traceId ?? workflowId;
-    const traceHelm = memo.traceHelm ?? name;
+    // Create the execution context object or preserve if it already exists:
+    // It will always contains the information about the root workflow
+    // It will be used to as context for tracing (connecting events)
+    const executionContext = memo.executionContext ?? {
+      workflowId,
+      workflowName: name,
+      startTime: startTime.getTime()
+    };
 
-    Object.assign( memo, { traceId, traceHelm } );
+    Object.assign( memo, {
+      executionContext,
+      activityOptions: memo.activityOptions ?? activityOptions // Also preserve the original activity options
+    } );
 
-    // binds the methods called in the code that  Webpack loader will add, they will exposed via "this"
+    // binds the methods called in the code that Webpack loader will add, they will exposed via "this"
     const output = await fn.call( {
-      invokeStep: async ( stepName, input ) => steps[`${workflowPath}#${stepName}`]( input ),
-      invokeEvaluator: async ( evaluatorName, input ) => steps[`${workflowPath}#${evaluatorName}`]( input ),
+      invokeStep: async ( stepName, input, options ) => steps[`${workflowPath}#${stepName}`]( input, options ),
+      invokeSharedStep: async ( stepName, input, options ) => steps[`${SHARED_STEP_PREFIX}#${stepName}`]( input, options ),
+      invokeEvaluator: async ( evaluatorName, input, options ) => steps[`${workflowPath}#${evaluatorName}`]( input, options ),
 
       startWorkflow: async ( childName, input ) => {
-        return executeChild( childName, { args: input ? [ input ] : [], memo: { traceId, traceHelm, parentId: workflowId } } );
+        return executeChild( childName, { args: input ? [ input ] : [], memo: { executionContext, parentId: workflowId } } );
       }
     }, input );
 
     validateWithSchema( outputSchema, output, `Workflow ${name} output` );
 
-    // Adds trace file content to the output if it is the root workflow
-    // @TODO this will be replaced in favor of a persistent storage elsewhere
-    if ( !memo.parentId ) {
-      const trace = await steps[ACTIVITY_READ_TRACE_FILE]( { traceId, traceHelm } );
-      return { output, trace };
-    }
-
     return output;
   };