@outputai/core 0.3.3-next.e0cece4.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.3.3-next.e0cece4.0",
+  "version": "0.4.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -45,7 +45,12 @@
     "redis": "5.12.1",
     "stacktrace-parser": "0.1.11",
     "undici": "8.1.0",
-    "winston": "3.19.0",
+    "winston": "3.19.0"
+  },
+  "peerDependencies": {
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
     "zod": "4.3.6"
   },
   "license": "Apache-2.0",

package/src/consts.js

@@ -32,3 +32,7 @@ export const BusEventType = {
 
   RUNTIME_ERROR: 'runtime_error'
 };
+
+export const WorkflowSpecialOutput = {
+  CONTINUED_AS_NEW: '<<continued_as_new>>'
+};

package/src/interface/workflow.d.ts

@@ -139,9 +139,9 @@ export type WorkflowFunction<
  */
 export type WorkflowFunctionWrapper<WorkflowFunction> =
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
-    ( input?: undefined | null, config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ( input?: undefined | null, config?: WorkflowInvocationConfiguration ) =>
     ReturnType<WorkflowFunction> :
-    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration<Parameters<WorkflowFunction>[1]> ) =>
+    ( input: Parameters<WorkflowFunction>[0], config?: WorkflowInvocationConfiguration ) =>
     ReturnType<WorkflowFunction>;
 
 /**

package/src/worker/bundler_options.js

@@ -1,9 +1,40 @@
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
+import {
+  findPackageRoot,
+  isPathDescendentFromNodeModules,
+  packageExposesWorkflows
+} from './loader_tools.js';
 
 const __dirname = dirname( fileURLToPath( import.meta.url ) );
 const workerDir = __dirname; // sdk/core/src/worker
 const interfaceDir = join( __dirname, '..', 'interface' );
+const packagesWithWorkflowsMap = new Map();
+
+/**
+ * Skip loaders for most of `node_modules`, except packages that expose workflows.
+ */
+const excludeUnlessPackageExposeWorkflows = resource => {
+  // internal parts: exclude
+  if ( resource.startsWith( workerDir ) || resource.startsWith( interfaceDir ) ) {
+    return true;
+  }
+  // not node_modules/: include
+  if ( !isPathDescendentFromNodeModules( resource ) ) {
+    return false;
+  }
+
+  const rootPath = findPackageRoot( resource );
+  if ( !rootPath ) {
+    return true;
+  }
+
+  if ( !packagesWithWorkflowsMap.has( rootPath ) ) {
+    packagesWithWorkflowsMap.set( rootPath, packageExposesWorkflows( join( rootPath, 'package.json' ) ) );
+  }
+
+  return !packagesWithWorkflowsMap.get( rootPath );
+};
 
 export const webpackConfigHook = config => {
   // Prefer the "output-workflow-bundle" export condition when resolving packages.
@@ -23,8 +54,7 @@ export const webpackConfigHook = config => {
   // Validation loader (runs first)
   config.module.rules.push( {
     test: /\.js$/,
-    // Exclude node_modules and internal core worker files
-    exclude: resource => /node_modules/.test( resource ) || resource.startsWith( workerDir ) || resource.startsWith( interfaceDir ),
+    exclude: excludeUnlessPackageExposeWorkflows,
     enforce: 'pre',
     use: {
       loader: join( __dirname, './webpack_loaders/workflow_validator/index.mjs' )
@@ -33,8 +63,7 @@ export const webpackConfigHook = config => {
   // Use AST-based loader for rewriting steps/workflows
   config.module.rules.push( {
     test: /\.js$/,
-    // Exclude node_modules and internal core worker files
-    exclude: resource => /node_modules/.test( resource ) || resource.startsWith( workerDir ) || resource.startsWith( interfaceDir ),
+    exclude: excludeUnlessPackageExposeWorkflows,
     use: {
       loader: join( __dirname, './webpack_loaders/workflow_rewriter/index.mjs' )
     }

package/src/worker/bundler_options.spec.js

@@ -0,0 +1,62 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { mkdirSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { webpackConfigHook } from './bundler_options.js';
+
+const __dirname = dirname( fileURLToPath( import.meta.url ) );
+const TEMP_BASE = join( process.cwd(), 'sdk/core/temp_test_bundler_options' );
+
+afterEach( () => {
+  rmSync( TEMP_BASE, { recursive: true, force: true } );
+} );
+
+const buildExcludes = () => {
+  const config = webpackConfigHook( {} );
+  return config.module.rules.map( rule => rule.exclude );
+};
+
+const writePackageResource = ( packagePath, pkgJson ) => {
+  const resource = join( packagePath, 'lib', 'index.js' );
+  mkdirSync( dirname( resource ), { recursive: true } );
+  writeFileSync( join( packagePath, 'package.json' ), JSON.stringify( pkgJson ) );
+  writeFileSync( resource, 'export const x = 1;\n' );
+  return resource;
+};
+
+describe( 'webpackConfigHook loader excludes', () => {
+  it( 'keeps loaders enabled for project files outside node_modules', () => {
+    for ( const exclude of buildExcludes() ) {
+      expect( exclude( join( TEMP_BASE, 'src', 'workflow.js' ) ) ).toBe( false );
+    }
+  } );
+
+  it( 'excludes worker and interface internals', () => {
+    for ( const exclude of buildExcludes() ) {
+      expect( exclude( join( __dirname, 'loader.js' ) ) ).toBe( true );
+      expect( exclude( join( __dirname, '..', 'interface', 'index.js' ) ) ).toBe( true );
+    }
+  } );
+
+  it( 'keeps loaders enabled for packages that expose workflows', () => {
+    const resource = writePackageResource(
+      join( TEMP_BASE, 'node_modules', '@acme', 'catalog' ),
+      { name: '@acme/catalog', outputai: { workflows: { expose: true } } }
+    );
+
+    for ( const exclude of buildExcludes() ) {
+      expect( exclude( resource ) ).toBe( false );
+    }
+  } );
+
+  it( 'excludes packages that do not expose workflows', () => {
+    const resource = writePackageResource(
+      join( TEMP_BASE, 'node_modules', 'plain_lib' ),
+      { name: 'plain_lib', dependencies: { '@outputai/core': '1.0.0' } }
+    );
+
+    for ( const exclude of buildExcludes() ) {
+      expect( exclude( resource ) ).toBe( true );
+    }
+  } );
+} );

package/src/worker/interceptors/workflow.js

@@ -1,8 +1,8 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew } from '@temporalio/workflow';
+import { workflowInfo, proxySinks, ApplicationFailure, ContinueAsNew, isCancellation } from '@temporalio/workflow';
 import { memoToHeaders } from '../sandboxed_utils.js';
 import { deepMerge } from '#utils';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { METADATA_ACCESS_SYMBOL, WorkflowSpecialOutput } from '#consts';
 // this is a dynamic generated file with activity configs overwrites
 import stepOptions from '../temp/__activity_options.js';
 
@@ -44,7 +44,12 @@ class WorkflowExecutionInterceptor {
        * a new trace file will be generated
        */
       if ( error instanceof ContinueAsNew ) {
-        sinks.workflow.end( '<continued_as_new>' );
+        sinks.workflow.end( WorkflowSpecialOutput.CONTINUED_AS_NEW );
+        throw error;
+      }
+
+      if ( isCancellation( error ) ) {
+        sinks.workflow.error( error );
         throw error;
       }
 

package/src/worker/interceptors/workflow.spec.js

@@ -6,6 +6,7 @@ const workflowInfoMock = vi.fn();
 const workflowStartMock = vi.fn();
 const workflowEndMock = vi.fn();
 const workflowErrorMock = vi.fn();
+const isCancellationMock = vi.fn();
 vi.mock( '@temporalio/workflow', () => ( {
   workflowInfo: ( ...args ) => workflowInfoMock( ...args ),
   proxySinks: () => ( {
@@ -26,7 +27,8 @@ vi.mock( '@temporalio/workflow', () => ( {
       super( 'ContinueAsNew' );
       this.name = 'ContinueAsNew';
     }
-  }
+  },
+  isCancellation: ( ...args ) => isCancellationMock( ...args )
 } ) );
 
 const memoToHeadersMock = vi.fn( memo => ( memo ? { ...memo, __asHeaders: true } : {} ) );
@@ -50,6 +52,7 @@ vi.mock( '../temp/__activity_options.js', () => ( { default: stepOptionsDefault
 describe( 'workflow interceptors', () => {
   beforeEach( () => {
     vi.clearAllMocks();
+    isCancellationMock.mockReturnValue( false );
     workflowInfoMock.mockReturnValue( { workflowType: 'MyWorkflow', memo: { executionContext: { id: 'ctx-1' } } } );
   } );
 
@@ -151,8 +154,25 @@ describe( 'workflow interceptors', () => {
       expect( error.details ).toEqual( [ meta ] );
     } );
 
+    it( 'calls sinks.workflow.error and rethrows cancellation errors without wrapping', async () => {
+      const { interceptors } = await import( './workflow.js' );
+      const { ApplicationFailure } = await import( '@temporalio/workflow' );
+      const { inbound } = interceptors();
+      const interceptor = inbound[0];
+      const cancellation = new Error( 'Workflow cancelled' );
+      const next = vi.fn().mockRejectedValue( cancellation );
+      isCancellationMock.mockReturnValue( true );
+
+      await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toBe( cancellation );
+      expect( isCancellationMock ).toHaveBeenCalledWith( cancellation );
+      expect( cancellation ).not.toBeInstanceOf( ApplicationFailure );
+      expect( workflowErrorMock ).toHaveBeenCalledWith( cancellation );
+      expect( workflowEndMock ).not.toHaveBeenCalled();
+    } );
+
     it( 'on ContinueAsNew calls sinks.trace.addWorkflowEventEnd and rethrows', async () => {
       const { ContinueAsNew } = await import( '@temporalio/workflow' );
+      const { WorkflowSpecialOutput } = await import( '#consts' );
       const { interceptors } = await import( './workflow.js' );
       const { inbound } = interceptors();
       const interceptor = inbound[0];
@@ -160,7 +180,7 @@ describe( 'workflow interceptors', () => {
       const next = vi.fn().mockRejectedValue( continueErr );
 
       await expect( interceptor.execute( { args: [ {} ] }, next ) ).rejects.toThrow( ContinueAsNew );
-      expect( workflowEndMock ).toHaveBeenCalledWith( '<continued_as_new>' );
+      expect( workflowEndMock ).toHaveBeenCalledWith( WorkflowSpecialOutput.CONTINUED_AS_NEW );
       expect( workflowErrorMock ).not.toHaveBeenCalled();
     } );
   } );

package/src/worker/loader.js

@@ -3,7 +3,14 @@ import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
 import { EOL } from 'node:os';
 import { fileURLToPath } from 'url';
 import { getTraceDestinations, sendHttpRequest } from '#internal_activities';
-import { importComponents, staticMatchers, activityMatchersBuilder } from './loader_tools.js';
+import {
+  activityMatchersBuilder,
+  findSharedActivitiesFromWorkflows,
+  findWorkflowsInNodeModules,
+  importComponents,
+  matchFiles,
+  staticMatchers
+} from './loader_tools.js';
 import {
   ACTIVITY_SEND_HTTP_REQUEST,
   ACTIVITY_OPTIONS_FILENAME,
@@ -13,6 +20,7 @@ import {
   ACTIVITY_GET_TRACE_DESTINATIONS
 } from '#consts';
 import { createChildLogger } from '#logger';
+import { ValidationError } from '#errors';
 
 const log = createChildLogger( 'Scanner' );
 
@@ -64,23 +72,34 @@ export async function loadActivities( rootDir, workflows ) {
   const activityOptionsMap = {};
 
   // Load workflow based activities
-  for ( const { path: workflowPath, name: workflowName } of workflows ) {
+  for ( const { path: workflowPath, name: workflowName, external } of workflows ) {
     const dir = dirname( workflowPath );
-    for await ( const { fn, metadata, path } of importComponents( dir, Object.values( activityMatchersBuilder( dir ) ) ) ) {
-      log.info( 'Component loaded', { type: metadata.type, name: metadata.name, path, workflow: workflowName } );
+    for await ( const { fn, metadata, path } of importComponents( matchFiles( dir, Object.values( activityMatchersBuilder( dir ) ) ) ) ) {
+      log.info( 'Component loaded', { type: metadata.type, name: metadata.name, path, workflow: workflowName, ...( external && { external } ) } );
       // Activities loaded from a workflow path will use the workflow name as a namespace, which is unique across the platform, avoiding collision
       const activityKey = generateActivityKey( { namespace: workflowName, activityName: metadata.name } );
+      if ( activities[activityKey] ) {
+        throw new ValidationError( `Activity "${metadata.name}" in workflow "${workflowName}" conflicts with another \
+activity in the same workflow. Activity names must be unique within a workflow.` );
+      }
       activities[activityKey] = fn;
       // propagate the custom options set on the step()/evaluator() constructor
       activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
     }
   }
 
-  // Load shared activities/evaluators
-  for await ( const { fn, metadata, path } of importComponents( rootDir, [ staticMatchers.sharedStepsDir, staticMatchers.sharedEvaluatorsDir ] ) ) {
-    log.info( 'Shared component loaded', { type: metadata.type, name: metadata.name, path } );
-    // The namespace for shared activities is fixed
+  // Load shared activities/evaluators from local and external npm modules
+  const localSharedActivities = matchFiles( rootDir, [ staticMatchers.sharedStepsDir, staticMatchers.sharedEvaluatorsDir ] );
+  const externalSharedActivities = findSharedActivitiesFromWorkflows( workflows.filter( w => w.external ) );
+  for await ( const { fn, metadata, path } of importComponents( [ ...localSharedActivities, ...externalSharedActivities ] ) ) {
+    const external = externalSharedActivities.some( a => a.path === path );
+    log.info( 'Shared component loaded', { type: metadata.type, name: metadata.name, path, ...( external && { external } ) } );
+    // Reuses the same global namespace for shared activities
     const activityKey = generateActivityKey( { namespace: SHARED_STEP_PREFIX, activityName: metadata.name } );
+    if ( activities[activityKey] ) {
+      throw new ValidationError( `Shared activity "${metadata.name}" conflicts with another shared activity. \
+Shared activity names must be unique.` );
+    }
     activities[activityKey] = fn;
     activityOptionsMap[activityKey] = metadata.options?.activityOptions ?? undefined;
   }
@@ -103,19 +122,43 @@ export async function loadActivities( rootDir, workflows ) {
  * @returns {object[]}
  */
 export async function loadWorkflows( rootDir ) {
+  const workflowNames = new Set();
   const workflows = [];
-  for await ( const { metadata, path } of importComponents( rootDir, [ staticMatchers.workflowFile ] ) ) {
+  const localWorkflows = matchFiles( rootDir, [ staticMatchers.workflowFile ] );
+  const externalWorkflows = findWorkflowsInNodeModules( rootDir );
+  for await ( const { metadata, path } of importComponents( [ ...localWorkflows, ...externalWorkflows ] ) ) {
+    const external = externalWorkflows.some( a => a.path === path );
     if ( staticMatchers.workflowPathHasShared( path ) ) {
-      throw new Error( 'Workflow directory can\'t be named "shared"' );
+      throw new ValidationError( 'Workflow directory can\'t be named "shared"' );
+    }
+    const { name, aliases } = metadata;
+    if ( workflowNames.has( name ) ) {
+      throw new ValidationError( `Workflow name "${name}" conflicts with another workflow or alias. \
+Workflow names and aliases must be unique.` );
+    }
+    if ( WORKFLOW_CATALOG === name ) {
+      throw new ValidationError( `Workflow name "${name}" is reserved for the internal catalog workflow.` );
+    }
+    workflowNames.add( name );
+    for ( const alias of aliases ?? [] ) {
+      if ( workflowNames.has( alias ) ) {
+        throw new ValidationError( `Workflow "${name}" alias "${alias}" conflicts with another workflow or alias. \
+Workflow names and aliases must be unique.` );
+      }
+      if ( WORKFLOW_CATALOG === alias ) {
+        throw new ValidationError( `Workflow "${name}" alias "${alias}" is reserved for the internal catalog workflow.` );
+      }
+      workflowNames.add( alias );
     }
-    log.info( 'Workflow loaded', { name: metadata.name, path } );
-    workflows.push( { ...metadata, path } );
+
+    log.info( 'Workflow loaded', { name, path, aliases, ...( external && { external } ) } );
+    workflows.push( { ...metadata, path, external } );
   }
   return workflows;
 };
 
 /**
- * Loads the hook files from package.json's output config section.
+ * Loads the hook files from package.json's "outputai" section.
  *
  * @param {string} rootDir
  * @returns {void}
@@ -124,7 +167,12 @@ export async function loadHooks( rootDir ) {
   const packageFile = join( rootDir, 'package.json' );
   if ( existsSync( packageFile ) ) {
     const pkg = await import( packageFile, { with: { type: 'json' } } );
-    for ( const path of pkg.default.output?.hookFiles ?? [] ) {
+    const content = pkg.default;
+    const hooks = [];
+    // @DEPRECATED: "output" is the legacy namespace for configs, can be removed after couple version (this is being added in 0.3.x)
+    hooks.push( ...( content['output']?.hookFiles ?? [] ) );
+    hooks.push( ...( content['outputai']?.hookFiles ?? [] ) );
+    for ( const path of hooks ) {
       const hookFile = join( rootDir, path );
       await import( hookFile );
       log.info( 'Hook file loaded', { path } );
@@ -132,40 +180,6 @@ export async function loadHooks( rootDir ) {
   }
 };
 
-/**
- * Validates that all workflow names and aliases are unique across the project.
- *
- * @param {object[]} workflows
- * @throws {Error} If any alias conflicts with a workflow name or another alias
- */
-function validateWorkflowNames( workflows ) {
-  const allNames = new Map();
-
-  // Register primary names (case-insensitive to prevent confusing collisions)
-  for ( const { name } of workflows ) {
-    allNames.set( name.toLowerCase(), `workflow "${name}"` );
-  }
-
-  // Check the reserved catalog name
-  allNames.set( WORKFLOW_CATALOG.toLowerCase(), 'system workflow "$catalog"' );
-
-  // Check aliases against all names
-  for ( const { name, aliases = [] } of workflows ) {
-    const lowerCaseName = name.toLowerCase();
-    for ( const alias of aliases ) {
-      const lowerAliasName = alias.toLowerCase();
-      if ( lowerAliasName === lowerCaseName ) {
-        throw new Error( `Workflow "${name}" has an alias identical to its own name` );
-      }
-      const conflict = allNames.get( lowerAliasName );
-      if ( conflict ) {
-        throw new Error( `Alias "${alias}" on workflow "${name}" conflicts with ${conflict}` );
-      }
-      allNames.set( lowerAliasName, `alias "${alias}" on workflow "${name}"` );
-    }
-  }
-}
-
 /**
  * Creates a temporary index file importing all workflows for Temporal.
  *
@@ -173,8 +187,6 @@ function validateWorkflowNames( workflows ) {
  * @returns
  */
 export function createWorkflowsEntryPoint( workflows ) {
-  validateWorkflowNames( workflows );
-
   const path = join( __dirname, 'temp', WORKFLOWS_INDEX_FILENAME );
 
   // default system catalog workflow