@outputai/core 0.7.1-next.bd6bd49.0 → 0.7.1-next.c005dac.0

package/src/interface/workflow_activity_options.js

@@ -0,0 +1,16 @@
+import { FatalError, ValidationError } from '#errors';
+
+export const defaultOptions = {
+  activityOptions: {
+    startToCloseTimeout: '20m',
+    heartbeatTimeout: '5m',
+    retry: {
+      initialInterval: '10s',
+      backoffCoefficient: 2.0,
+      maximumInterval: '2m',
+      maximumAttempts: 3,
+      nonRetryableErrorTypes: [ ValidationError.name, FatalError.name ]
+    }
+  },
+  disableTrace: false
+};

package/src/interface/workflow_utils.js

@@ -1,5 +1,5 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { validateExecuteInParallel } from './validations/static.js';
+import { validateExecuteInParallel } from './validations/index.js';
 
 /**
  * Execute jobs in parallel with optional concurrency limit.

package/src/interface/zod_integration.spec.js

@@ -495,7 +495,7 @@ describe( 'Zod Schema Integration Tests', () => {
         await errorStep( { age: 16, email: 'invalid' } );
         expect.fail( 'Should have thrown an error' );
       } catch ( error ) {
-        expect( error.message ).toContain( 'Step error_test input validation failed' );
+        expect( error.message ).toContain( 'Step "error_test" input validation failed' );
       }
     } );
 
@@ -527,7 +527,7 @@ describe( 'Zod Schema Integration Tests', () => {
       const metadata = testStep[METADATA_ACCESS_SYMBOL];
       expect( metadata.inputSchema ).toBe( zodSchema );
       expect( metadata.inputSchema ).not.toBe( null );
-      expect( metadata.inputSchema._def ).toBeDefined(); // Zod-specific property
+      expect( metadata.inputSchema._zod?.def ).toBeDefined(); // Zod v4-specific property
     } );
 
     it( 'should handle deeply nested Zod schemas', async () => {

package/src/internal_utils/aggregations.js

@@ -1,4 +1,3 @@
-import { deepMergeWithResolver } from '#utils';
 import { Attribute } from '#trace_attribute';
 import Decimal from 'decimal.js';
 
@@ -43,12 +42,3 @@ export const aggregateAttributes = attributes => ( {
     total: attributes.filter( a => Attribute.HTTPRequestCount.TYPE === a.type ).length
   }
 } );
-
-/**
- * Combine two or more aggregation objects into a single Aggregation, adding up the totals and merging keys.
- *
- * @param {Aggregation} aggregations
- * @returns {Aggregation}
- */
-export const mergeAggregations = ( ...aggregations ) =>
-  aggregations.reduce( ( final, item ) => deepMergeWithResolver( final, item, ( a, b ) => Decimal( a ?? 0 ).add( b ?? 0 ).toNumber() ), {} );

package/src/internal_utils/aggregations.spec.js

@@ -1,6 +1,6 @@
 import { describe, expect, it } from 'vitest';
 import { Attribute } from '#trace_attribute';
-import { aggregateAttributes, mergeAggregations } from './aggregations.js';
+import { aggregateAttributes } from './aggregations.js';
 
 describe( 'aggregateAttributes', () => {
   it( 'returns zeroed aggregations when there are no attributes', () => {
@@ -90,50 +90,3 @@ describe( 'aggregateAttributes', () => {
   } );
 } );
 
-describe( 'mergeAggregations', () => {
-  it( 'returns an empty object when no aggregations are provided', () => {
-    expect( mergeAggregations() ).toEqual( {} );
-  } );
-
-  it( 'sums nested aggregation values', () => {
-    expect( mergeAggregations(
-      {
-        cost: { total: 1.2 },
-        tokens: { total: 10, input: 6 },
-        httpRequests: { total: 2 }
-      },
-      {
-        cost: { total: 0.3 },
-        tokens: { total: 5, input: 2, output: 3 },
-        httpRequests: { total: 1 }
-      }
-    ) ).toEqual( {
-      cost: { total: 1.5 },
-      tokens: { total: 15, input: 8, output: 3 },
-      httpRequests: { total: 3 }
-    } );
-  } );
-
-  it( 'handles undefined or partial aggregation objects', () => {
-    expect( mergeAggregations(
-      undefined,
-      { cost: { total: 2 } },
-      { tokens: { total: 4, reasoning: 1 } },
-      { httpRequests: { total: 3 } }
-    ) ).toEqual( {
-      cost: { total: 2 },
-      tokens: { total: 4, reasoning: 1 },
-      httpRequests: { total: 3 }
-    } );
-  } );
-
-  it( 'does not mutate source aggregation objects', () => {
-    const first = { cost: { total: 1 }, tokens: { total: 2 }, httpRequests: { total: 3 } };
-    const second = { cost: { total: 4 }, tokens: { total: 5 }, httpRequests: { total: 6 } };
-
-    mergeAggregations( first, second );
-
-    expect( first ).toEqual( { cost: { total: 1 }, tokens: { total: 2 }, httpRequests: { total: 3 } } );
-    expect( second ).toEqual( { cost: { total: 4 }, tokens: { total: 5 }, httpRequests: { total: 6 } } );
-  } );
-} );

package/src/internal_utils/errors.js

@@ -1,10 +1,16 @@
+import { ApplicationFailure } from '@temporalio/common';
+
 /**
- * Extract a property from the error .details.
- * If error does not have details, navigate up the .cause chain.
- *
- * @param {Error} e
- * @param {string} key
- * @returns {any} The value of the property
+ * Builds a Temporal ApplicationFailure based on an error attaching info to its details
+ * @param {Error} error
+ * @param {unknown} info
+ * @returns {ApplicationFailure}
  */
-export const extractErrorDetail = ( e, key ) =>
-  e ? ( e.details?.find?.( d => d[key] )?.[key] ?? extractErrorDetail( e.cause, key ) ) : null;
+export const buildApplicationFailureWithDetails = ( error, info ) =>
+  ApplicationFailure.create( {
+    message: error.message,
+    type: error.type ?? error.constructor?.name ?? error.name,
+    nonRetryable: error.nonRetryable,
+    details: ( Array.isArray( error.details ) ? error.details : [] ).concat( info ),
+    cause: error
+  } );

package/src/internal_utils/errors.spec.js

@@ -1,43 +1,89 @@
 import { describe, expect, it } from 'vitest';
-import { extractErrorDetail } from './errors.js';
+import { ApplicationFailure } from '@temporalio/common';
+import { buildApplicationFailureWithDetails } from './errors.js';
 
-describe( 'extractErrorDetail', () => {
-  it( 'returns a matching value from error details', () => {
-    const error = new Error( 'failed' );
-    error.details = [
-      { requestId: 'req-1' },
-      { workflowId: 'workflow-1' }
-    ];
+class CustomFailure extends Error {}
 
-    expect( extractErrorDetail( error, 'workflowId' ) ).toBe( 'workflow-1' );
+describe( 'buildApplicationFailureWithDetails', () => {
+  it( 'wraps a regular error in an ApplicationFailure with appended details', () => {
+    const error = new Error( 'step failed' );
+    const info = { aggregations: { cost: { total: 1 } } };
+
+    const failure = buildApplicationFailureWithDetails( error, info );
+
+    expect( failure ).toBeInstanceOf( ApplicationFailure );
+    expect( failure ).toMatchObject( {
+      message: 'step failed',
+      type: 'Error',
+      nonRetryable: false,
+      details: [ info ],
+      cause: error
+    } );
   } );
 
-  it( 'walks the cause chain until it finds matching details', () => {
-    const root = new Error( 'root' );
-    root.details = [ { traceId: 'trace-1' } ];
-    const wrapped = new Error( 'wrapped', { cause: root } );
+  it( 'uses the original constructor name for custom errors', () => {
+    const error = new CustomFailure( 'custom failed' );
+    const info = { trace: { destinations: { local: '/tmp/trace' } } };
 
-    expect( extractErrorDetail( wrapped, 'traceId' ) ).toBe( 'trace-1' );
+    const failure = buildApplicationFailureWithDetails( error, info );
+
+    expect( failure ).toMatchObject( {
+      message: 'custom failed',
+      type: 'CustomFailure',
+      details: [ info ],
+      cause: error
+    } );
   } );
 
-  it( 'prefers details from the current error over causes', () => {
-    const root = new Error( 'root' );
-    root.details = [ { traceId: 'root-trace' } ];
-    const wrapped = new Error( 'wrapped', { cause: root } );
-    wrapped.details = [ { traceId: 'wrapped-trace' } ];
+  it( 'preserves existing details and appends new info without mutating the original error', () => {
+    const existingDetails = [ { domain: { reason: 'bad-input' } } ];
+    const error = new Error( 'step failed' );
+    error.details = existingDetails;
+    const info = { aggregations: { httpRequests: { total: 1 } } };
+
+    const failure = buildApplicationFailureWithDetails( error, info );
 
-    expect( extractErrorDetail( wrapped, 'traceId' ) ).toBe( 'wrapped-trace' );
+    expect( failure.details ).toEqual( [
+      { domain: { reason: 'bad-input' } },
+      info
+    ] );
+    expect( error.details ).toBe( existingDetails );
+    expect( error.details ).toEqual( [ { domain: { reason: 'bad-input' } } ] );
   } );
 
-  it( 'returns null when the key is not found', () => {
-    const root = new Error( 'root' );
-    root.details = [ { traceId: 'trace-1' } ];
-    const wrapped = new Error( 'wrapped', { cause: root } );
+  it( 'ignores non-array details on the original error', () => {
+    const error = new Error( 'step failed' );
+    error.details = { domain: { reason: 'bad-input' } };
+    const info = { aggregations: { tokens: { total: 3 } } };
 
-    expect( extractErrorDetail( wrapped, 'missing' ) ).toBeNull();
+    const failure = buildApplicationFailureWithDetails( error, info );
+
+    expect( failure.details ).toEqual( [ info ] );
   } );
 
-  it( 'returns null for empty errors', () => {
-    expect( extractErrorDetail( null, 'traceId' ) ).toBeNull();
+  it( 'preserves ApplicationFailure type, nonRetryable flag, and details while avoiding self-cause', () => {
+    const original = ApplicationFailure.create( {
+      message: 'application failed',
+      type: 'DomainFailure',
+      nonRetryable: true,
+      details: [ { domain: { reason: 'bad-input' } } ]
+    } );
+    const info = { aggregations: { cost: { total: 2 } } };
+
+    const failure = buildApplicationFailureWithDetails( original, info );
+
+    expect( failure ).toBeInstanceOf( ApplicationFailure );
+    expect( failure ).not.toBe( original );
+    expect( failure.cause ).toBe( original );
+    expect( failure.cause ).not.toBe( failure );
+    expect( failure ).toMatchObject( {
+      message: 'application failed',
+      type: 'DomainFailure',
+      nonRetryable: true,
+      details: [
+        { domain: { reason: 'bad-input' } },
+        info
+      ]
+    } );
   } );
 } );

package/src/worker/bundle.js

@@ -0,0 +1,26 @@
+import { bundleWorkflowCode } from '@temporalio/worker';
+import { loadWorkflows, loadActivities, createWorkflowsEntryPoint } from './loader.js';
+import { webpackConfigHook } from './bundler_options.js';
+import { workflowInterceptorModules } from './interceptors/modules.js';
+
+/**
+ * Bundle a project's workflows exactly as the worker does, without a Temporal server.
+ *
+ * Mirrors the worker's startup prep (`loadWorkflows` -> `loadActivities` ->
+ * `createWorkflowsEntryPoint`) and then runs the same bundler (`bundleWorkflowCode`)
+ * with the same inputs `Worker.create` derives — `webpackConfigHook` and
+ * `workflowInterceptorModules` — so it stays in parity with worker startup. Rejects if
+ * the Temporal webpack bundler fails, e.g. a `node:` built-in in the workflow's
+ * transitive import graph.
+ *
+ * @param {string} rootDir directory to discover workflows in
+ * @returns {Promise<import('@temporalio/worker').WorkflowBundleWithSourceMap>}
+ */
+export async function bundleWorkflows( rootDir ) {
+  const workflows = await loadWorkflows( rootDir );
+  // Writes worker/temp/__activity_options.js, which the workflow interceptor module
+  // imports — the worker generates it via loadActivities() before Worker.create bundles.
+  await loadActivities( rootDir, workflows );
+  const workflowsPath = createWorkflowsEntryPoint( workflows );
+  return bundleWorkflowCode( { workflowsPath, workflowInterceptorModules, webpackConfigHook } );
+}

package/src/worker/bundle.spec.js

@@ -0,0 +1,52 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Stub the activity interceptor so the real interceptors/index.js imports cleanly.
+vi.mock( './interceptors/activity.js', () => ( { ActivityExecutionInterceptor: class {} } ) );
+
+vi.mock( '@temporalio/worker', () => ( {
+  bundleWorkflowCode: vi.fn().mockResolvedValue( { code: '', sourceMap: '' } )
+} ) );
+
+vi.mock( './loader.js', () => ( {
+  loadWorkflows: vi.fn().mockResolvedValue( [] ),
+  loadActivities: vi.fn().mockResolvedValue( {} ),
+  createWorkflowsEntryPoint: vi.fn().mockReturnValue( '/fake/workflows/entrypoint.js' )
+} ) );
+
+vi.mock( './bundler_options.js', () => ( { webpackConfigHook: vi.fn() } ) );
+
+import { bundleWorkflowCode } from '@temporalio/worker';
+import { loadWorkflows, loadActivities, createWorkflowsEntryPoint } from './loader.js';
+import { webpackConfigHook } from './bundler_options.js';
+import { initInterceptors } from './interceptors/index.js';
+import { workflowInterceptorModules } from './interceptors/modules.js';
+import { bundleWorkflows } from './bundle.js';
+
+describe( 'output-worker --check parity', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    loadWorkflows.mockResolvedValue( [] );
+    loadActivities.mockResolvedValue( {} );
+    createWorkflowsEntryPoint.mockReturnValue( '/fake/workflows/entrypoint.js' );
+    bundleWorkflowCode.mockResolvedValue( { code: '', sourceMap: '' } );
+  } );
+
+  it( 'worker registers the shared workflow interceptor modules', () => {
+    const { workflowModules } = initInterceptors( { activities: {}, workflows: [], connection: {} } );
+    // The check (bundleWorkflows) and the worker must register the very same modules.
+    expect( workflowModules ).toBe( workflowInterceptorModules );
+  } );
+
+  it( 'check bundles with the same inputs Worker.create derives', async () => {
+    await bundleWorkflows( '/project' );
+
+    expect( loadWorkflows ).toHaveBeenCalledWith( '/project' );
+    expect( loadActivities ).toHaveBeenCalledWith( '/project', [] );
+    expect( createWorkflowsEntryPoint ).toHaveBeenCalledWith( [] );
+    expect( bundleWorkflowCode ).toHaveBeenCalledWith( {
+      workflowsPath: '/fake/workflows/entrypoint.js',
+      workflowInterceptorModules,
+      webpackConfigHook
+    } );
+  } );
+} );

package/src/worker/check.js

@@ -0,0 +1,24 @@
+import { bundleWorkflows } from './bundle.js';
+
+// `output-worker --check` entry: bundle the workflows exactly as the worker would, then
+// exit 0 (ok) / 1 (fail). The exit code is the signal. Workflow-discovery logs write to
+// stdout via the worker logger, so mute stdout to keep output clean for CI/tooling; only
+// real errors surface, on stderr. Catches bad workflow imports (e.g. `node:` built-ins)
+// at build/CI time instead of crash-looping the worker at startup.
+const callerDir = process.argv[2] ?? process.cwd();
+
+process.stdout.write = ( ...args ) => {
+  const callback = args.find( arg => typeof arg === 'function' );
+  if ( callback ) {
+    callback();
+  }
+  return true;
+};
+
+( async () => {
+  await bundleWorkflows( callerDir );
+  process.exit( 0 );
+} )().catch( error => {
+  console.error( error );
+  process.exit( 1 );
+} );

package/src/worker/index.js

@@ -74,7 +74,7 @@ const callerDir = process.argv[2];
     workflowsPath,
     activities,
     sinks,
-    interceptors: initInterceptors( { activities, workflows, connection } ),
+    interceptors: initInterceptors( { activities, workflows } ),
     maxConcurrentWorkflowTaskExecutions,
     maxConcurrentActivityTaskExecutions,
     maxCachedWorkflows,

package/src/worker/index.spec.js

@@ -130,7 +130,7 @@ describe( 'worker/index', () => {
       maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
       maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
     } ) );
-    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [], connection: mockConnection } );
+    expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
     expect( registerShutdownMock ).toHaveBeenCalledWith( { worker: mockWorker, log: mockLog } );
     expect( setupTelemetryMock ).toHaveBeenCalledWith( { worker: mockWorker } );
     expect( startCatalogMock ).toHaveBeenCalledWith( {

package/src/worker/interceptors/activity.js

@@ -2,14 +2,11 @@ import { Context, activityInfo as activityInfoFn } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import * as Tracing from '#tracing';
 import { headersToObject } from './headers.js';
-import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL, Signal } from '#consts';
-import { activityHeartbeatEnabled, activityHeartbeatIntervalMs, namespace } from '../configs.js';
+import { ACTIVITY_WRAPPER_VERSION_FIELD, BusEventType, METADATA_ACCESS_SYMBOL } from '#consts';
+import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
 import { messageBus } from '#bus';
-import { Client } from '@temporalio/client';
-import { createChildLogger } from '#logger';
 import { aggregateAttributes } from '#internal_utils/aggregations';
-
-const log = createChildLogger( 'ActivityInterceptor' );
+import { buildApplicationFailureWithDetails } from '#internal_utils/errors';
 
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
@@ -28,7 +25,7 @@ const log = createChildLogger( 'ActivityInterceptor' );
   - Headers injected by the workflow interceptor
 */
 export class ActivityExecutionInterceptor {
-  constructor( { activities, workflows, connection } ) {
+  constructor( { activities, workflows } ) {
     // convert activities{} object to a map: activityType:kind
     this.activityKindMap = new Map( Object.entries( activities )
       .map( ( [ type, fn ] ) => ( [ type, fn[METADATA_ACCESS_SYMBOL].type ] ) ) );
@@ -37,12 +34,11 @@ export class ActivityExecutionInterceptor {
     this.workflowsPathMap = new Map( workflows.flatMap( ( { name, aliases, path } ) =>
       [ name, ...aliases ?? [] ].map( a => ( [ a, path ] ) )
     ) );
-    this.connection = connection;
   };
 
   async execute( input, next ) {
     const activityInfo = activityInfoFn();
-    const { workflowExecution: { workflowId, runId }, activityId, activityType, workflowType } = activityInfo;
+    const { workflowExecution: { runId }, activityId, activityType, workflowType } = activityInfo;
     const { traceInfo, workflowDetails } = headersToObject( input.headers );
     const outputActivityKind = this.activityKindMap.get( activityType );
     const workflowFilename = this.workflowsPathMap.get( workflowType );
@@ -61,19 +57,6 @@ export class ActivityExecutionInterceptor {
 
     const addAttribute = attribute => state.attributes.push( attribute );
 
-    const sendAggregationsViaSignal = async () => {
-      if ( state.attributes.length > 0 ) {
-        try {
-          const client = new Client( { connection: this.connection, namespace } );
-          const workflowHandle = client.workflow.getHandle( workflowId );
-          await workflowHandle.signal( Signal.SEND_AGGREGATIONS, aggregateAttributes( state.attributes ) );
-        } catch ( error ) {
-          const errorContext = { message: error.message, stack: error.stack, activityId, activityType, workflowId, workflowType, runId };
-          log.warn( `Signal "${Signal.SEND_AGGREGATIONS}" failed`, errorContext );
-        }
-      }
-    };
-
     // Adds context accessible information
     const storageContext = {
       parentId: activityId,
@@ -107,9 +90,9 @@ export class ActivityExecutionInterceptor {
       messageBus.emit( BusEventType.ACTIVITY_ERROR, { activityInfo, workflowDetails, outputActivityKind, error } );
       Tracing.addEventError( { id: activityId, details: error, traceInfo } );
 
-      await sendAggregationsViaSignal();
+      const aggregations = state.attributes.length > 0 ? aggregateAttributes( state.attributes ) : null;
 
-      throw error;
+      throw aggregations ? buildApplicationFailureWithDetails( error, { aggregations } ) : error;
     } finally {
       clearInterval( state.heartbeat );
     }