@outputai/core 0.8.1-dev.945f2f2.0 → 0.8.1-next.aa8ed5e.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.8.1-dev.945f2f2.0",
+  "version": "0.8.1-next.aa8ed5e.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/worker/configs.js

@@ -5,6 +5,13 @@ class InvalidEnvVarsErrors extends Error { }
 
 const coalesceEmptyString = v => v === '' ? undefined : v;
 
+const durationSchema = z.preprocess(
+  coalesceEmptyString,
+  z.string()
+    .regex( /^\d+$|^\d+(\.\d+)?\s?(ms|s|m|h|d)$/i )
+    .optional()
+);
+
 const envVarSchema = z.object( {
   OUTPUT_CATALOG_ID: z.string().regex( /^[a-z0-9_.@-]+$/i ),
   OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: z.preprocess( coalesceEmptyString, z.coerce.number().int().nonnegative().default( 0 ) ),
@@ -28,6 +35,10 @@ const envVarSchema = z.object( {
   OUTPUT_ACTIVITY_HEARTBEAT_ENABLED: z.transform( v => v === undefined ? true : isStringboolTrue( v ) ),
   // Time to allow for hooks to flush before shutdown
   OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY: z.preprocess( coalesceEmptyString, z.coerce.number().int().positive().default( 3000 ) ),
+  // Set temporal worker shutdown force time
+  TEMPORAL_SHUTDOWN_FORCE_TIME: durationSchema,
+  // Set temporal worker shutdown grace time
+  TEMPORAL_SHUTDOWN_GRACE_TIME: durationSchema,
   // HTTP CONNECT proxy for Temporal gRPC connections (e.g. "proxy-host:8080").
   // Must be a bare host:port — no scheme (Temporal's native HTTP CONNECT
   // option is not a URL).
@@ -56,4 +67,6 @@ export const workerTelemetryIntervalMs = envVars.OUTPUT_WORKER_TELEMETRY_INTERVA
 export const activityHeartbeatIntervalMs = envVars.OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS;
 export const activityHeartbeatEnabled = envVars.OUTPUT_ACTIVITY_HEARTBEAT_ENABLED;
 export const processFailureShutdownDelay = envVars.OUTPUT_PROCESS_FAILURE_SHUTDOWN_DELAY;
+export const shutdownForceTime = envVars.TEMPORAL_SHUTDOWN_FORCE_TIME;
+export const shutdownGraceTime = envVars.TEMPORAL_SHUTDOWN_GRACE_TIME;
 export const grpcProxy = envVars.TEMPORAL_GRPC_PROXY;

package/src/worker/configs.spec.js

@@ -12,7 +12,9 @@ const CONFIG_KEYS = [
   'TEMPORAL_MAX_CONCURRENT_WORKFLOW_TASK_POLLS',
   'OUTPUT_WORKER_TELEMETRY_INTERVAL_MS',
   'OUTPUT_ACTIVITY_HEARTBEAT_INTERVAL_MS',
-  'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED'
+  'OUTPUT_ACTIVITY_HEARTBEAT_ENABLED',
+  'TEMPORAL_SHUTDOWN_FORCE_TIME',
+  'TEMPORAL_SHUTDOWN_GRACE_TIME'
 ];
 
 const setEnv = ( overrides = {} ) => {
@@ -65,6 +67,8 @@ describe( 'worker/configs', () => {
     expect( configs.workerTelemetryIntervalMs ).toBe( 0 );
     expect( configs.activityHeartbeatIntervalMs ).toBe( 2 * 60 * 1000 );
     expect( configs.activityHeartbeatEnabled ).toBe( true );
+    expect( configs.shutdownForceTime ).toBeUndefined();
+    expect( configs.shutdownGraceTime ).toBeUndefined();
     expect( configs.taskQueue ).toBe( 'test-catalog' );
     expect( configs.catalogId ).toBe( 'test-catalog' );
   } );
@@ -100,6 +104,35 @@ describe( 'worker/configs', () => {
     expect( configs.activityHeartbeatIntervalMs ).toBe( 60000 );
   } );
 
+  it( 'parses Temporal shutdown durations', async () => {
+    setEnv( {
+      TEMPORAL_SHUTDOWN_FORCE_TIME: '15000',
+      TEMPORAL_SHUTDOWN_GRACE_TIME: '15s'
+    } );
+    const configs = await loadConfigs();
+
+    expect( configs.shutdownForceTime ).toBe( '15000' );
+    expect( configs.shutdownGraceTime ).toBe( '15s' );
+  } );
+
+  it( 'treats empty Temporal shutdown durations as unset', async () => {
+    setEnv( {
+      TEMPORAL_SHUTDOWN_FORCE_TIME: '',
+      TEMPORAL_SHUTDOWN_GRACE_TIME: ''
+    } );
+    const configs = await loadConfigs();
+
+    expect( configs.shutdownForceTime ).toBeUndefined();
+    expect( configs.shutdownGraceTime ).toBeUndefined();
+  } );
+
+  it( 'throws when Temporal shutdown durations are invalid', async () => {
+    setEnv( { TEMPORAL_SHUTDOWN_FORCE_TIME: 'soon' } );
+    vi.resetModules();
+
+    await expect( import( './configs.js' ) ).rejects.toThrow();
+  } );
+
   it( 'allows zero for worker telemetry interval', async () => {
     setEnv( { OUTPUT_WORKER_TELEMETRY_INTERVAL_MS: '0' } );
     const configs = await loadConfigs();

package/src/worker/connection_monitor.js

@@ -2,13 +2,6 @@ import { createChildLogger } from '#logger';
 import { setTimeout as delay } from 'node:timers/promises';
 import { CancellablePromise } from '#utils';
 
-const ServingStatus = {
-  UNKNOWN: 0,
-  SERVING: 1,
-  NOT_SERVING: 2,
-  SERVICE_UNKNOWN: 3
-};
-
 const log = createChildLogger( 'Connection' );
 
 export class TemporalConnectionMonitor {
@@ -28,24 +21,20 @@ export class TemporalConnectionMonitor {
     throw new Error( 'Connection health check timed out' );
   } );
 
-  #healthcheck = async () => this.#connection.healthService.check( {} );
+  #healthcheck = async () => this.#connection.workflowService.getSystemInfo( {} );
 
   #sleep = async () => delay( this.#CHECK_INTERVAL_MS, 0, { ref: false } );
 
   #watch = async () => {
     while ( !this.#cancellation.completed ) {
       try {
-        const health = await Promise.race( [ this.#healthcheck(), this.#getTimeout(), this.#cancellation.promise ] );
+        await Promise.race( [ this.#healthcheck(), this.#getTimeout(), this.#cancellation.promise ] );
 
         // cancellation won the race
         if ( this.#cancellation.completed ) {
           break;
         }
 
-        if ( health?.status !== ServingStatus.SERVING ) {
-          throw new Error( `Connection not serving (status ${health?.status})` );
-        }
-
         log.info( this.#failures === 0 ? 'Healthy' : 'Recovered' );
         this.#failures = 0;
       } catch ( error ) {

package/src/worker/connection_monitor.spec.js

@@ -1,8 +1,6 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
 
-const SERVING = 1;
-const NOT_SERVING = 2;
 const CHECK_TIMEOUT_MS = 50;
 const CHECK_INTERVAL_MS = 100;
 
@@ -26,7 +24,7 @@ vi.mock( 'node:timers/promises', () => ( { setTimeout: delayMock } ) );
 vi.mock( '#logger', () => ( { createChildLogger: vi.fn( () => mockLogger ) } ) );
 
 const createConnection = check => ( {
-  healthService: { check }
+  workflowService: { getSystemInfo: check }
 } );
 
 const createMonitor = ( check, overrides = {} ) => new TemporalConnectionMonitor( createConnection( check ), {
@@ -52,8 +50,8 @@ describe( 'TemporalConnectionMonitor', () => {
     scheduledDelays.length = 0;
   } );
 
-  it( 'logs healthy when the connection is serving', async () => {
-    const check = vi.fn().mockResolvedValue( { status: SERVING } );
+  it( 'logs healthy when the workflow service is reachable', async () => {
+    const check = vi.fn().mockResolvedValue( {} );
     const monitor = createMonitor( check );
 
     const run = monitor.start();
@@ -90,7 +88,7 @@ describe( 'TemporalConnectionMonitor', () => {
   it( 'logs recovered after a transient failure succeeds', async () => {
     const check = vi.fn()
       .mockRejectedValueOnce( new Error( 'temporary outage' ) )
-      .mockResolvedValueOnce( { status: SERVING } );
+      .mockResolvedValueOnce( {} );
     const monitor = createMonitor( check );
 
     monitor.start();
@@ -134,21 +132,6 @@ describe( 'TemporalConnectionMonitor', () => {
     expect( monitor.running ).toBe( false );
   } );
 
-  it( 'treats non-serving health status as a failure', async () => {
-    const check = vi.fn().mockResolvedValue( { status: NOT_SERVING } );
-    const monitor = createMonitor( check );
-
-    monitor.start();
-    await flushPromises();
-
-    expect( mockLogger.warn ).toHaveBeenCalledWith( 'Connection unhealthy', {
-      error: `Connection not serving (status ${NOT_SERVING})`,
-      failures: 1
-    } );
-
-    await monitor.stop();
-  } );
-
   it( 'returns the same lifecycle promise when started more than once', async () => {
     const check = vi.fn().mockReturnValue( new Promise( () => {} ) );
     const monitor = createMonitor( check );

package/src/worker/index.js

@@ -33,7 +33,9 @@ const {
   maxConcurrentActivityTaskExecutions,
   maxCachedWorkflows,
   maxConcurrentActivityTaskPolls,
-  maxConcurrentWorkflowTaskPolls
+  maxConcurrentWorkflowTaskPolls,
+  shutdownForceTime,
+  shutdownGraceTime
 } = configs;
 
 const state = {
@@ -73,6 +75,7 @@ const execute = async () => {
   if ( proxy ) {
     log.info( 'Using gRPC proxy', { targetHost: grpcProxy } );
   }
+
   state.connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
   log.info( 'Creating connection monitor...' );
@@ -95,7 +98,9 @@ const execute = async () => {
     maxCachedWorkflows,
     maxConcurrentActivityTaskPolls,
     maxConcurrentWorkflowTaskPolls,
-    bundlerOptions: { webpackConfigHook }
+    bundlerOptions: { webpackConfigHook },
+    ...( shutdownForceTime !== undefined && { shutdownForceTime } ),
+    ...( shutdownGraceTime !== undefined && { shutdownGraceTime } )
   } );
 
   log.info( 'Setting up telemetry...' );

package/src/worker/index.spec.js

@@ -44,7 +44,9 @@ const {
     maxCachedWorkflows: 1000,
     maxConcurrentActivityTaskPolls: 5,
     maxConcurrentWorkflowTaskPolls: 5,
-    processFailureShutdownDelay: 0
+    processFailureShutdownDelay: 0,
+    shutdownForceTime: undefined,
+    shutdownGraceTime: undefined
   };
 
   const connectionMonitorInstance = {
@@ -180,6 +182,8 @@ describe( 'worker/index', () => {
     resetPromises();
     configValues.apiKey = undefined;
     configValues.grpcProxy = undefined;
+    configValues.shutdownForceTime = undefined;
+    configValues.shutdownGraceTime = undefined;
     catalogJobInstance.error = null;
     catalogJobInstance.errorCb = null;
     catalogJobInstance.running = false;
@@ -237,6 +241,8 @@ describe( 'worker/index', () => {
       maxConcurrentActivityTaskPolls: configValues.maxConcurrentActivityTaskPolls,
       maxConcurrentWorkflowTaskPolls: configValues.maxConcurrentWorkflowTaskPolls
     } ) );
+    expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownForceTime' );
+    expect( Worker.create.mock.calls[0][0] ).not.toHaveProperty( 'shutdownGraceTime' );
     expect( initInterceptorsMock ).toHaveBeenCalledWith( { activities: {}, workflows: [] } );
     expect( setupTelemetryMock ).toHaveBeenCalledWith( { worker: mockWorker } );
     expect( setupInterruptionHandlerMock ).toHaveBeenCalledWith( expect.any( Function ) );
@@ -264,6 +270,21 @@ describe( 'worker/index', () => {
     await settleWorker();
   } );
 
+  it( 'passes configured shutdown durations to the worker', async () => {
+    configValues.shutdownForceTime = '30s';
+    configValues.shutdownGraceTime = '10s';
+    const { Worker } = await import( '@temporalio/worker' );
+
+    await importWorker();
+
+    await vi.waitFor( () => expect( Worker.create ).toHaveBeenCalledWith( expect.objectContaining( {
+      shutdownForceTime: '30s',
+      shutdownGraceTime: '10s'
+    } ) ) );
+
+    await settleWorker();
+  } );
+
   it( 'runs graceful shutdown when interrupted', async () => {
     await importWorker();