@output.ai/core 0.0.10 → 0.0.11

package/README.md

@@ -138,4 +138,4 @@ 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 note;
+- `TRACING_ENABLED`: A "stringbool" value indicating if traces should be generated or not;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "description": "The core module of the output framework",
   "type": "module",
   "main": "src/index.js",

package/src/configs.js

@@ -2,21 +2,60 @@ import * as z from 'zod';
 
 class InvalidEnvVarsErrors extends Error {}
 
+const ipv4Validator = z.ipv4();
+const ipv6Validator = z.ipv6();
+const portValidator = z.number().int().min( 10 ).max( 65535 ).optional();
+
+const ipValidator = z.union( [ ipv4Validator, ipv6Validator ] );
+
+const likelyIpv6 = val => val.startsWith( '[' );
+
+const splitIpWithPort = val => {
+  // ipv6
+  if ( likelyIpv6( val ) ) {
+    const address = val.slice( 1, val.lastIndexOf( ']' ) );
+    const portString = val.split( ']' )[1].slice( 1 ); // remove the :
+    const port = portString ? parseInt( portString, 10 ) : undefined;
+    return { address, port };
+  }
+
+  // ipv4
+  const parts = val.split( ':' );
+  if ( parts.length !== 2 ) {
+    return { address: val, port: undefined };
+  }
+
+  const [ address, portString ] = parts;
+  const port = portString ? parseInt( portString, 10 ) : undefined;
+  return { address, port };
+};
+
+const ipWithOptionalPort = z.string().refine(
+  val => {
+    const { address, port } = splitIpWithPort( val );
+    return ipValidator.safeParse( address ).success && portValidator.safeParse( port ).success;
+  },
+  {
+    message: 'Must be a valid IP address'
+  }
+);
+
 const envVarSchema = z.object( {
   TEMPORAL_ADDRESS: z.union( [
-    z.httpUrl(),
-    z.string().regex( /^[a-z0-9_-]+:\d{2,5}$/i ) // local docker container name like worker:7233
+    z.string().regex( /^https?:\/\/.+/ ), // HTTP or HTTPS URLs
+    z.string().regex( /^[a-z0-9_-]+:\d{2,5}$/i ), // local docker container name like worker:7233
+    ipWithOptionalPort // IP address (IPv4 or IPv6) with port
   ] ),
   TEMPORAL_NAMESPACE: z.string().optional().default( 'default' ),
   TEMPORAL_API_KEY: z.string().optional(),
   CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
   API_AUTH_KEY: z.string().optional(),
-  TRACING_ENABLED: z.stringbool().optional()
+  TRACING_ENABLED: z.enum( [ 'true', 'false' ] ).optional()
 } );
 
 const { data: safeEnvVar, error } = envVarSchema.safeParse( process.env );
 if ( error ) {
-  throw new InvalidEnvVarsErrors( z.prettifyError( error ) );
+  throw new InvalidEnvVarsErrors( JSON.stringify( error.format(), null, 2 ) );
 }
 
 export const worker = {

package/src/configs.spec.js

@@ -0,0 +1,480 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+describe( 'configs', () => {
+  const originalEnv = process.env;
+
+  beforeEach( () => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  } );
+
+  afterEach( () => {
+    process.env = originalEnv;
+  } );
+
+  describe( 'Environment Variable Validation', () => {
+    describe( 'TEMPORAL_ADDRESS', () => {
+      it( 'should accept valid http URLs', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'http://localhost:7233' );
+      } );
+
+      it( 'should accept valid https URLs', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'https://temporal.example.com',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'https://temporal.example.com' );
+      } );
+
+      it( 'should accept docker container names with ports', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'temporal-server:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'temporal-server:7233' );
+      } );
+
+      it( 'should accept container names with underscores and hyphens', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'my_temporal-server:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'my_temporal-server:7233' );
+      } );
+
+      it( 'should accept IP addresses with HTTP', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://192.168.1.100:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'http://192.168.1.100:7233' );
+      } );
+
+      it( 'should accept IP addresses with HTTPS', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'https://10.0.0.1:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'https://10.0.0.1:7233' );
+      } );
+
+      it( 'should accept IP addresses without protocol for docker format', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: '172.17.0.2:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( '172.17.0.2:7233' );
+      } );
+
+      it( 'should accept IPv6 addresses with brackets and port', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: '[2001:db8::1]:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( '[2001:db8::1]:7233' );
+      } );
+
+      it( 'should accept IPv6 addresses with HTTP', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://[2001:db8::1]:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'http://[2001:db8::1]:7233' );
+      } );
+
+      it( 'should accept IPv6 addresses with HTTPS', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'https://[::1]:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.address ).toBe( 'https://[::1]:7233' );
+      } );
+
+      it( 'should reject invalid addresses', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'not-a-valid-address',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+
+      it( 'should reject addresses without ports in container format', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'temporal-server',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+
+      it( 'should reject addresses with single digit port numbers', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'temporal-server:1',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+
+      it( 'should reject when TEMPORAL_ADDRESS is missing', async () => {
+        process.env = {
+          CATALOG_ID: 'test-catalog'
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+    } );
+
+    describe( 'CATALOG_ID', () => {
+      it( 'should accept valid catalog IDs with letters and numbers', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'catalog123'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.catalogId ).toBe( 'catalog123' );
+        expect( worker.taskQueue ).toBe( 'catalog123' );
+      } );
+
+      it( 'should accept catalog IDs with dots and hyphens', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'my.catalog-id'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.catalogId ).toBe( 'my.catalog-id' );
+      } );
+
+      it( 'should accept catalog IDs with underscores', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'my_catalog_id'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.catalogId ).toBe( 'my_catalog_id' );
+      } );
+
+      it( 'should accept catalog IDs with @ symbol', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: '@my-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.catalogId ).toBe( '@my-catalog' );
+      } );
+
+      it( 'should reject catalog IDs with special characters', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'catalog!@#$'
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+
+      it( 'should reject when CATALOG_ID is missing', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233'
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+
+      it( 'should reject empty CATALOG_ID', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: ''
+        };
+
+        await expect( import( './configs.js' ) ).rejects.toThrow();
+      } );
+    } );
+
+    describe( 'Optional Fields', () => {
+      it( 'should use default namespace when TEMPORAL_NAMESPACE is not provided', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.namespace ).toBe( 'default' );
+      } );
+
+      it( 'should use custom namespace when provided', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog',
+          TEMPORAL_NAMESPACE: 'custom-namespace'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.namespace ).toBe( 'custom-namespace' );
+      } );
+
+      it( 'should handle TEMPORAL_API_KEY when provided', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog',
+          TEMPORAL_API_KEY: 'secret-api-key'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.apiKey ).toBe( 'secret-api-key' );
+      } );
+
+      it( 'should handle missing TEMPORAL_API_KEY', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { worker } = await import( './configs.js' );
+        expect( worker.apiKey ).toBeUndefined();
+      } );
+
+      it( 'should handle API_AUTH_KEY when provided', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog',
+          API_AUTH_KEY: 'api-secret-key'
+        };
+
+        const { api } = await import( './configs.js' );
+        expect( api.authKey ).toBe( 'api-secret-key' );
+      } );
+
+      it( 'should handle missing API_AUTH_KEY', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { api } = await import( './configs.js' );
+        expect( api.authKey ).toBeUndefined();
+      } );
+
+      it( 'should handle TRACING_ENABLED when true', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog',
+          TRACING_ENABLED: 'true'
+        };
+
+        const { tracing } = await import( './configs.js' );
+        expect( tracing.enabled ).toBe( 'true' );
+      } );
+
+      it( 'should handle TRACING_ENABLED when false', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog',
+          TRACING_ENABLED: 'false'
+        };
+
+        const { tracing } = await import( './configs.js' );
+        expect( tracing.enabled ).toBe( 'false' );
+      } );
+
+      it( 'should handle missing TRACING_ENABLED', async () => {
+        process.env = {
+          TEMPORAL_ADDRESS: 'http://localhost:7233',
+          CATALOG_ID: 'test-catalog'
+        };
+
+        const { tracing } = await import( './configs.js' );
+        expect( tracing.enabled ).toBeUndefined();
+      } );
+    } );
+  } );
+
+  describe( 'Exported Config Objects', () => {
+    it( 'should export worker config with all properties', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'test-catalog',
+        TEMPORAL_NAMESPACE: 'test-namespace',
+        TEMPORAL_API_KEY: 'test-api-key'
+      };
+
+      const { worker } = await import( './configs.js' );
+
+      expect( worker ).toEqual( {
+        address: 'http://localhost:7233',
+        apiKey: 'test-api-key',
+        executionTimeout: '1m',
+        maxActivities: 100,
+        maxWorkflows: 100,
+        namespace: 'test-namespace',
+        taskQueue: 'test-catalog',
+        catalogId: 'test-catalog'
+      } );
+    } );
+
+    it( 'should export api config', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'test-catalog',
+        API_AUTH_KEY: 'test-auth-key'
+      };
+
+      const { api } = await import( './configs.js' );
+
+      expect( api ).toEqual( {
+        authKey: 'test-auth-key'
+      } );
+    } );
+
+    it( 'should export tracing config', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'test-catalog',
+        TRACING_ENABLED: 'true'
+      };
+
+      const { tracing } = await import( './configs.js' );
+
+      expect( tracing ).toEqual( {
+        enabled: 'true'
+      } );
+    } );
+
+    it( 'should have correct static worker config values', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'test-catalog'
+      };
+
+      const { worker } = await import( './configs.js' );
+
+      expect( worker.executionTimeout ).toBe( '1m' );
+      expect( worker.maxActivities ).toBe( 100 );
+      expect( worker.maxWorkflows ).toBe( 100 );
+    } );
+  } );
+
+  describe( 'Error Handling', () => {
+    it( 'should throw InvalidEnvVarsErrors for invalid configuration', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'invalid',
+        CATALOG_ID: 'test-catalog'
+      };
+
+      await expect( import( './configs.js' ) ).rejects.toThrow();
+    } );
+
+    it( 'should handle multiple validation errors', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'invalid',
+        CATALOG_ID: 'invalid!@#'
+      };
+
+      await expect( import( './configs.js' ) ).rejects.toThrow();
+    } );
+  } );
+
+  describe( 'Edge Cases', () => {
+    it( 'should handle environment variables with spaces', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'test-catalog',
+        TEMPORAL_NAMESPACE: '  custom-namespace  '
+      };
+
+      const { worker } = await import( './configs.js' );
+      expect( worker.namespace ).toBe( '  custom-namespace  ' );
+    } );
+
+    it( 'should handle very long catalog IDs', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'a'.repeat( 100 )
+      };
+
+      const { worker } = await import( './configs.js' );
+      expect( worker.catalogId ).toBe( 'a'.repeat( 100 ) );
+    } );
+
+    it( 'should handle URLs with ports outside typical range', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:65535',
+        CATALOG_ID: 'test-catalog'
+      };
+
+      const { worker } = await import( './configs.js' );
+      expect( worker.address ).toBe( 'http://localhost:65535' );
+    } );
+
+    it( 'should handle container names with numbers', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'temporal123:7233',
+        CATALOG_ID: 'test-catalog'
+      };
+
+      const { worker } = await import( './configs.js' );
+      expect( worker.address ).toBe( 'temporal123:7233' );
+    } );
+
+    it( 'should handle mixed case in catalog ID', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'http://localhost:7233',
+        CATALOG_ID: 'Test.Catalog-ID_123'
+      };
+
+      const { worker } = await import( './configs.js' );
+      expect( worker.catalogId ).toBe( 'Test.Catalog-ID_123' );
+    } );
+  } );
+
+  describe( 'Complete Valid Configuration', () => {
+    it( 'should handle a complete valid configuration with all optional fields', async () => {
+      process.env = {
+        TEMPORAL_ADDRESS: 'https://temporal.cloud.example.com',
+        TEMPORAL_NAMESPACE: 'production',
+        TEMPORAL_API_KEY: 'prod-api-key-123',
+        CATALOG_ID: 'prod.catalog@v1',
+        API_AUTH_KEY: 'secure-auth-key',
+        TRACING_ENABLED: 'true'
+      };
+
+      const { worker, api, tracing } = await import( './configs.js' );
+
+      expect( worker.address ).toBe( 'https://temporal.cloud.example.com' );
+      expect( worker.namespace ).toBe( 'production' );
+      expect( worker.apiKey ).toBe( 'prod-api-key-123' );
+      expect( worker.catalogId ).toBe( 'prod.catalog@v1' );
+      expect( worker.taskQueue ).toBe( 'prod.catalog@v1' );
+      expect( api.authKey ).toBe( 'secure-auth-key' );
+      expect( tracing.enabled ).toBe( 'true' );
+    } );
+  } );
+} );

package/src/consts.js

@@ -1,4 +1,11 @@
 export const SEND_WEBHOOK_ACTIVITY_NAME = '__internal#sendWebhookPost';
+export const READ_TRACE_FILE = '__internal#readTraceFile';
 export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
 export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';
 export const THIS_LIB_NAME = 'core';
+export const TraceEvent = {
+  WORKFLOW_START: 'workflow_start',
+  WORKFLOW_END: 'workflow_end',
+  STEP_START: 'step_start',
+  STEP_END: 'step_end'
+};

package/src/interface/step.js

@@ -1,18 +1,18 @@
 import { setMetadata } from './metadata.js';
 import { validateStep } from './validations/static.js';
 import { validateStepInput, validateStepOutput } from './validations/runtime.js';
-import { invokeFnAndValidateOutputPreservingExecutionModel } from './utils.js';
 
 export function step( { name, description, inputSchema, outputSchema, fn } ) {
   validateStep( { name, description, inputSchema, outputSchema, fn } );
-  const wrapper = input => {
+  const wrapper = async input => {
     if ( inputSchema ) {
       validateStepInput( name, inputSchema, input );
     }
-    if ( !outputSchema ) {
-      return fn( input );
+    const output = await fn( input );
+    if ( outputSchema ) {
+      validateStepOutput( name, outputSchema, output );
     }
-    return invokeFnAndValidateOutputPreservingExecutionModel( fn, input, validateStepOutput.bind( null, name, outputSchema ) );
+    return output;
   };
 
   setMetadata( wrapper, { name, description, inputSchema, outputSchema } );

package/src/interface/utils.js

@@ -17,30 +17,3 @@ export const getInvocationDir = () => new Error()
   .at( -1 )
   .replace( /\((.+):\d+:\d+\)/, '$1' )
   .split( '/' ).slice( 0, -1 ).join( '/' );
-
-/**
- * This mouthful function will invoke a function with given arguments, and validate its return
- * using a given validator.
- *
- * It will preserver the execution model (asynchronous vs synchronous), so if the function is
- * sync the validation happens here, if it is async (returns Promise) the validation is attached
- * to a .then().
- *
- *
- * @param {Function} fn - The function to execute
- * @param {any} input - The payload to call the function
- * @param {Function} validate - The validator function
- * @returns {any} Function result (Promise or not)
- */
-export const invokeFnAndValidateOutputPreservingExecutionModel = ( fn, input, validate ) => {
-  const uniformReturn = output => {
-    validate( output );
-    return output;
-  };
-
-  const output = fn( input );
-  if ( output?.constructor === Promise ) {
-    return output.then( resolvedOutput => uniformReturn( resolvedOutput ) );
-  }
-  return uniformReturn( output );
-};

package/src/interface/utils.spec.js

@@ -1,5 +1,5 @@
-import { describe, it, expect, vi } from 'vitest';
-import { getInvocationDir, invokeFnAndValidateOutputPreservingExecutionModel } from './utils.js';
+import { describe, it, expect } from 'vitest';
+import { getInvocationDir } from './utils.js';
 
 describe( 'interface/utils', () => {
   describe( 'getInvocationDir', () => {
@@ -31,41 +31,5 @@ describe( 'interface/utils', () => {
       }
     } );
   } );
-
-  describe( 'invokeFnAndValidateOutputPreservingExecutionModel', () => {
-    it( 'validates and returns sync output', () => {
-      const fn = vi.fn( x => x * 2 );
-      const validate = vi.fn();
-      const result = invokeFnAndValidateOutputPreservingExecutionModel( fn, 3, validate );
-      expect( result ).toBe( 6 );
-      expect( validate ).toHaveBeenCalledWith( 6 );
-    } );
-
-    it( 'validates and returns async output preserving promise', async () => {
-      const fn = vi.fn( async x => x + 1 );
-      const validate = vi.fn();
-      const resultPromise = invokeFnAndValidateOutputPreservingExecutionModel( fn, 4, validate );
-      expect( resultPromise ).toBeInstanceOf( Promise );
-      const result = await resultPromise;
-      expect( result ).toBe( 5 );
-      expect( validate ).toHaveBeenCalledWith( 5 );
-    } );
-
-    it( 'propagates validator errors (sync)', () => {
-      const fn = vi.fn( x => x );
-      const validate = vi.fn( () => {
-        throw new Error( 'invalid' );
-      } );
-      expect( () => invokeFnAndValidateOutputPreservingExecutionModel( fn, 'a', validate ) ).toThrow( 'invalid' );
-    } );
-
-    it( 'propagates validator errors (async)', async () => {
-      const fn = vi.fn( async x => x );
-      const validate = vi.fn( () => {
-        throw new Error( 'invalid' );
-      } );
-      await expect( invokeFnAndValidateOutputPreservingExecutionModel( fn, 'a', validate ) ).rejects.toThrow( 'invalid' );
-    } );
-  } );
 } );
 

package/src/interface/workflow.js

@@ -1,10 +1,11 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, ApplicationFailure } from '@temporalio/workflow';
-import { getInvocationDir, invokeFnAndValidateOutputPreservingExecutionModel } from './utils.js';
+import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, ApplicationFailure, proxySinks } from '@temporalio/workflow';
+import { getInvocationDir } from './utils.js';
 import { setMetadata } from './metadata.js';
 import { FatalError, ValidationError } from '../errors.js';
 import { validateWorkflow } from './validations/static.js';
 import { validateWorkflowInput, validateWorkflowOutput } from './validations/runtime.js';
+import { READ_TRACE_FILE, TraceEvent } from '#consts';
 
 const temporalActivityConfigs = {
   startToCloseTimeout: '20 minute',
@@ -22,44 +23,60 @@ export function workflow( { name, description, inputSchema, outputSchema, fn } )
   const workflowPath = getInvocationDir();
 
   const steps = proxyActivities( temporalActivityConfigs );
+  const sinks = proxySinks();
 
   const wrapper = async input => {
     try {
+      if ( inWorkflowContext() ) {
+        sinks.log.trace( { event: TraceEvent.WORKFLOW_START, input } );
+      }
+
       if ( inputSchema ) {
         validateWorkflowInput( name, inputSchema, input );
       }
 
       // this returns a plain function, for example, in unit tests
       if ( !inWorkflowContext() ) {
+        const output = await fn( input );
         if ( outputSchema ) {
-          return invokeFnAndValidateOutputPreservingExecutionModel( fn, input, validateWorkflowOutput.bind( null, name, outputSchema ) );
+          validateWorkflowOutput( name, outputSchema, output );
         }
-        return fn( input );
+        return output;
       }
 
+      const { memo, workflowId } = workflowInfo();
+
       Object.assign( workflowInfo().memo, { workflowPath } );
 
       // binds the methods called in the code that  Webpack loader will add, they will exposed via "this"
-      const boundFn = fn.bind( {
+      const output = await fn.call( {
         invokeStep: async ( stepName, input ) => steps[`${workflowPath}#${stepName}`]( input ),
 
-        startWorkflow: async ( name, input ) => {
-          const { memo, workflowId, workflowType } = workflowInfo();
+        startWorkflow: async ( childName, input ) => {
 
           // Checks if current memo has rootWorkflowId, which means current execution is already a child
           // Then it sets the memory for the child execution passing along who's the original workflow is and its type
           const workflowMemory = memo.rootWorkflowId ?
             { parentWorkflowId: workflowId, rootWorkflowType: memo.rootWorkflowType, rootWorkflowId: memo.rootWorkflowId } :
-            { parentWorkflowId: workflowId, rootWorkflowId: workflowId, rootWorkflowType: workflowType };
+            { parentWorkflowId: workflowId, rootWorkflowId: workflowId, rootWorkflowType: name };
 
-          return executeChild( name, { args: input ? [ input ] : [], memo: workflowMemory } );
+          return executeChild( childName, { args: input ? [ input ] : [], memo: workflowMemory } );
         }
-      } );
+      }, input );
 
       if ( outputSchema ) {
-        return invokeFnAndValidateOutputPreservingExecutionModel( boundFn, input, validateWorkflowOutput.bind( null, name, outputSchema ) );
+        validateWorkflowOutput( name, outputSchema, output );
       }
-      return boundFn( input );
+
+      sinks.log.trace( { event: TraceEvent.WORKFLOW_END, output } );
+
+      // add trace if not child
+      if ( !memo.rootWorkflowId ) {
+        const trace = await steps[READ_TRACE_FILE]( { workflowType: name, workflowId } );
+        return { output, trace };
+      }
+
+      return output;
     } catch ( error ) {
       /*
        * Any errors in the workflow will interrupt its execution since the workflow is designed to orchestrate and

package/src/internal_activities/index.js

@@ -1,12 +1,23 @@
-import { api as apiConfig } from '#configs';
 import { FatalError } from '#errors';
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
 
+const callerDir = process.argv[2];
+
+/**
+ * Send a post to a given URL
+ *
+ * @param {object} options
+ * @param {string} options.url - The target url
+ * @param {string} options.workflowId - The current workflow id
+ * @param {any} options.payload - The payload to send url
+ * @throws {FatalError}
+ */
 export const sendWebhookPost = async ( { url, workflowId, payload } ) => {
   const request = fetch( url, {
     method: 'POST',
     headers: {
-      'Content-Type': 'application/json',
-      Authentication: `Basic ${apiConfig.authKey}`
+      'Content-Type': 'application/json'
     },
     body: JSON.stringify( { workflowId, payload } ),
     signal: AbortSignal.timeout( 5000 )
@@ -26,3 +37,19 @@ export const sendWebhookPost = async ( { url, workflowId, payload } ) => {
     throw new FatalError( `Webhook fail: ${res.status}` );
   }
 };
+
+/**
+ * Read the trace file of a given execution and returns the content
+ *
+ * @param {object} options
+ * @param {string} options.workflowType - The type of the workflow
+ * @param {string} options.workflowId - The workflow execution id
+ * @returns {string[]} Each line of the trace file
+ */
+export const readTraceFile = async ( { workflowType, workflowId } ) => {
+  const dir = join( callerDir, 'logs', 'runs', workflowType );
+  const suffix = `-${workflowId}.raw`;
+  const file = join( dir, readdirSync( dir ).find( f => f.endsWith( suffix ) ) );
+
+  return existsSync( file ) ? readFileSync( file, 'utf-8' ).split( '\n' ) : null;
+};

package/src/worker/interceptors/activity.js

@@ -1,9 +1,8 @@
 import { Context } from '@temporalio/activity';
 import { Storage } from '../async_storage.js';
 import { trace } from '../tracer/index.js';
-import { TraceEvent } from '../tracer/types.js';
 import { headersToObject } from '../sandboxed_utils.js';
-import { THIS_LIB_NAME } from '#consts';
+import { THIS_LIB_NAME, TraceEvent } from '#consts';
 
 /*
   This interceptor is called for every activity execution

package/src/worker/interceptors/workflow.js

@@ -1,6 +1,5 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { proxySinks, workflowInfo } from '@temporalio/workflow';
-import { TraceEvent } from '../tracer/types.js';
+import { workflowInfo } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
 
 /*
@@ -19,24 +18,6 @@ class HeadersInjectionInterceptor {
   }
 };
 
-/*
-This interceptor captures the workflow execution start and stop to log these event for the internal tracing
-  This is not an AI comment!
-
-  It uses sinks to share them.
-  - https://docs.temporal.io/develop/typescript/observability
-*/
-class WorkflowExecutionInterceptor {
-  async execute( input, next ) {
-    const sinks = proxySinks();
-    sinks.log.trace( { event: TraceEvent.WORKFLOW_START, input: input.args } );
-    const output = await next( input );
-    sinks.log.trace( { event: TraceEvent.WORKFLOW_END, output } );
-    return output;
-  }
-};
-
 export const interceptors = () => ( {
-  outbound: [ new HeadersInjectionInterceptor( workflowInfo().workflowType ) ],
-  inbound: [ new WorkflowExecutionInterceptor( workflowInfo().workflowType ) ]
+  outbound: [ new HeadersInjectionInterceptor( workflowInfo().workflowType ) ]
 } );

package/src/worker/loader.js

@@ -1,7 +1,7 @@
 import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
-import { sendWebhookPost } from '#internal_activities';
-import { SEND_WEBHOOK_ACTIVITY_NAME, WORKFLOWS_INDEX_FILENAME } from '#consts';
+import { sendWebhookPost, readTraceFile } from '#internal_activities';
+import { SEND_WEBHOOK_ACTIVITY_NAME, WORKFLOWS_INDEX_FILENAME, READ_TRACE_FILE } from '#consts';
 import {
   iteratorOverImportedComponents,
   recursiveNavigateWhileCollecting,
@@ -21,6 +21,7 @@ export async function loadActivities( path ) {
 
   // system activities
   activities[SEND_WEBHOOK_ACTIVITY_NAME] = sendWebhookPost;
+  activities[READ_TRACE_FILE] = readTraceFile;
   return activities;
 };
 

package/src/worker/loader.spec.js

@@ -4,13 +4,16 @@ const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
 
 vi.mock( '#consts', () => ( {
   SEND_WEBHOOK_ACTIVITY_NAME: '__internal#sendWebhookPost',
+  READ_TRACE_FILE: '__internal#readTraceFile',
   WORKFLOWS_INDEX_FILENAME: '__workflows_entrypoint.js',
   METADATA_ACCESS_SYMBOL
 } ) );
 
 const sendWebhookPostMock = vi.fn();
+const readTraceFileMock = vi.fn();
 vi.mock( '#internal_activities', () => ( {
-  sendWebhookPost: sendWebhookPostMock
+  sendWebhookPost: sendWebhookPostMock,
+  readTraceFile: readTraceFileMock
 } ) );
 
 // Mock internal_utils to control filesystem-independent behavior
@@ -39,6 +42,7 @@ describe( 'worker/loader', () => {
     const activities = await loadActivities( '/root' );
     expect( activities['/a#Act1'] ).toBeTypeOf( 'function' );
     expect( activities['__internal#sendWebhookPost'] ).toBe( sendWebhookPostMock );
+    expect( activities['__internal#readTraceFile'] ).toBe( readTraceFileMock );
   } );
 
   it( 'loadWorkflows returns array of workflows with metadata', async () => {

package/src/worker/tracer/tracer_tree.js

@@ -1,7 +1,6 @@
 import { readFileSync, writeFileSync } from 'node:fs';
 import { EOL } from 'os';
-import { TraceEvent } from './types.js';
-import { THIS_LIB_NAME } from '#consts';
+import { THIS_LIB_NAME, TraceEvent } from '#consts';
 
 /**
  * Sorting function that compares two objects and ASC sort them by either .startedAt or, if not present, .timestamp

package/src/worker/tracer/tracer_tree.test.js

@@ -5,8 +5,7 @@ import { tmpdir } from 'node:os';
 import { join } from 'path';
 import { EOL } from 'os';
 import { buildLogTree } from './tracer_tree.js';
-import { TraceEvent } from './types.js';
-import { THIS_LIB_NAME } from '#consts';
+import { THIS_LIB_NAME, TraceEvent } from '#consts';
 
 const createTempDir = () => mkdtempSync( join( tmpdir(), 'flow-sdk-trace-tree-' ) );
 

package/src/worker/tracer/types.js

@@ -1,6 +0,0 @@
-export const TraceEvent = {
-  WORKFLOW_START: 'workflow_start',
-  WORKFLOW_END: 'workflow_end',
-  STEP_START: 'step_start',
-  STEP_END: 'step_end'
-};