@outputai/core 0.8.1-next.e92f632.0 → 0.8.2-dev.e78f6b4.0

package/src/{activity_integration → sdk/runtime}/context.spec.js

@@ -5,7 +5,7 @@ vi.mock( '#async_storage', () => ( {
   Storage: { load: loadMock }
 } ) );
 
-describe( 'getExecutionContext', () => {
+describe( 'Context.getActivityContext', () => {
   beforeEach( () => {
     vi.clearAllMocks();
     vi.resetModules();
@@ -13,8 +13,8 @@ describe( 'getExecutionContext', () => {
 
   it( 'returns null when no context is stored', async () => {
     loadMock.mockReturnValue( undefined );
-    const { getExecutionContext } = await import( './index.js' );
-    expect( getExecutionContext() ).toBeNull();
+    const { Context } = await import( './index.js' );
+    expect( Context.getActivityContext() ).toBeNull();
   } );
 
   it( 'returns activity execution context from storage', async () => {
@@ -28,8 +28,8 @@ describe( 'getExecutionContext', () => {
       activityInfo,
       workflowFilename: '/workflows/myWorkflow.js'
     } );
-    const { getExecutionContext } = await import( './index.js' );
-    expect( getExecutionContext() ).toEqual( {
+    const { Context } = await import( './index.js' );
+    expect( Context.getActivityContext() ).toEqual( {
       activityInfo,
       workflowFilename: '/workflows/myWorkflow.js'
     } );

package/src/sdk/runtime/events.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Tools to interact with Events
+ */
+export declare const Event: {
+  /**
+   * Emits a custom event on the in-process message bus.
+   *
+   * When called inside an Output activity context, the framework automatically
+   * attaches `activityInfo`, `workflowDetails`, and `outputActivityKind` onto the emitted payload.
+   *
+   * @param eventName - The name of the event to emit
+   * @param payload - An optional payload to send to the event
+   */
+  emit( eventName: string, payload?: object ): void;
+};

package/src/sdk/runtime/events.js

@@ -0,0 +1,18 @@
+import { messageBus } from '#bus';
+import { Storage } from '#async_storage';
+
+export const Event = {
+  emit: ( eventName, payload ) => {
+    const ctx = Storage.load();
+
+    messageBus.emit( `external:${eventName}`, {
+      ...payload ?? {},
+      ...( ctx && {
+        activityInfo: ctx.activityInfo,
+        workflowDetails: ctx.workflowDetails,
+        outputActivityKind: ctx.outputActivityKind
+      } )
+    } );
+  }
+};
+

package/src/{activity_integration → sdk/runtime}/events.spec.js

@@ -11,12 +11,11 @@ vi.mock( '#bus', () => ( {
   messageBus: { emit: emitMock }
 } ) );
 
-import { emitEvent } from './events.js';
+import { Event } from './events.js';
 
-// `eventId` stamping is the bus layer's responsibility (see bus.spec.js + the
-// integration tests in event_id_integration.spec.js). Assertions here use
-// `objectContaining` so they don't have to know about that enrichment.
-describe( 'emitEvent', () => {
+// `eventId` stamping is the bus layer's responsibility (see bus.spec.js).
+// Assertions here use `objectContaining` so they don't have to know about that enrichment.
+describe( 'Event.emit', () => {
   beforeEach( () => {
     vi.clearAllMocks();
   } );
@@ -39,7 +38,7 @@ describe( 'emitEvent', () => {
       outputActivityKind: 'step'
     } );
 
-    emitEvent( 'cost:llm:request', { modelId: 'gpt-4o' } );
+    Event.emit( 'cost:llm:request', { modelId: 'gpt-4o' } );
 
     expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', expect.objectContaining( {
       activityInfo,
@@ -52,7 +51,7 @@ describe( 'emitEvent', () => {
   it( 'emits payload without context when storage is missing', () => {
     loadMock.mockReturnValue( undefined );
 
-    emitEvent( 'foo:bar', { x: 1 } );
+    Event.emit( 'foo:bar', { x: 1 } );
 
     expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', { x: 1 } );
   } );
@@ -75,7 +74,7 @@ describe( 'emitEvent', () => {
       outputActivityKind: 'step'
     } );
 
-    emitEvent( 'lifecycle:start' );
+    Event.emit( 'lifecycle:start' );
 
     expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', expect.objectContaining( {
       activityInfo,
@@ -102,7 +101,7 @@ describe( 'emitEvent', () => {
       outputActivityKind: 'step'
     } );
 
-    emitEvent( 'cost:http:request', {
+    Event.emit( 'cost:http:request', {
       activityInfo: { activityId: 'should-be-overridden' },
       workflowDetails: { workflowId: 'should-be-overridden' },
       outputActivityKind: 'should-be-overridden',

package/src/sdk/runtime/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * > [!WARNING]
+ * > **Internal use only.** Not part of the public API; may change without notice.
+ *
+ * These are helpers for other SDK modules integration.
+ * These need Temporal activity runtime to work, as they access state, emit events and use node:* modules.
+ *
+ * @packageDocumentation
+ */
+export * from './context.js';
+export * from './events.js';
+export * from './tracing.js';

package/src/sdk/runtime/index.js

@@ -0,0 +1,3 @@
+export * from './context.js';
+export * from './events.js';
+export * from './tracing.js';

package/src/sdk/runtime/tracing.d.ts

@@ -0,0 +1,46 @@
+import { Attribute } from '#trace_attribute';
+
+/**
+ * Tools to interact with Tracing
+ */
+export declare const Tracing: {
+  Attribute: typeof Attribute;
+
+  /**
+   * Creates a new event.
+   *
+   * @param args
+   * @param args.id - A unique id for the Event.
+   * @param args.kind - The kind of Event, like HTTP, DiskWrite, DBOp, etc.
+   * @param args.name - The human-friendly name of the Event: query, request, create.
+   * @param args.details - Arbitrary data to add to this event, it will be used as the "input" field.
+   */
+  addEventStart( args: { id: string; kind: string; name: string; details: unknown } ): void;
+
+  /**
+   * Concludes an event.
+   *
+   * @param args
+   * @param args.id - The id of the event to conclude.
+   * @param args.details - Arbitrary data to add to this event, it will be used as the "output" field.
+   */
+  addEventEnd( args: { id: string; details: unknown } ): void;
+
+  /**
+   * Concludes an event with an error.
+   *
+   * @param args
+   * @param args.id - The id of the event to conclude.
+   * @param args.details - Arbitrary data to add to this event, it will be used as the "error" field.
+   */
+  addEventError( args: { id: string; details: unknown } ): void;
+
+  /**
+   * Adds an attribute to an event.
+   *
+   * @param args
+   * @param args.eventId - The id of the event to attach the attribute to.
+   * @param args.attribute - The attribute to attach to the event.
+   */
+  addEventAttribute( args: { eventId: string; attribute: Attribute.Instance } ): void;
+};

package/src/sdk/runtime/tracing.js

@@ -0,0 +1,11 @@
+import { addEventActionWithContext as send, EventAction } from '#tracing';
+
+import { Attribute } from '#trace_attribute';
+
+export const Tracing = {
+  Attribute,
+  addEventStart: ( { id, kind, name, details } ) => send( EventAction.START, { kind, name, details, id } ),
+  addEventEnd: ( { id, details } ) => send( EventAction.END, { id, details } ),
+  addEventError: ( { id, details } ) => send( EventAction.ERROR, { id, details } ),
+  addEventAttribute: ( { eventId, attribute } ) => send( EventAction.ADD_ATTR, { id: eventId, details: attribute } )
+};

package/src/tracing/processors/s3/redis_client.spec.js

@@ -1,11 +1,5 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-vi.mock( '#utils', () => ( {
-  throws: e => {
-    throw e;
-  }
-} ) );
-
 const logCalls = { warn: [], error: [] };
 vi.mock( '#logger', () => ( {
   createChildLogger: () => ( {

package/src/tracing/processors/s3/s3_client.spec.js

@@ -1,11 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 
-vi.mock( '#utils', () => ( {
-  throws: e => {
-    throw e;
-  }
-} ) );
-
 const getVarsMock = vi.fn();
 vi.mock( './configs', () => ( { getVars: () => getVarsMock() } ) );
 

package/src/tracing/trace_engine.js

@@ -1,7 +1,7 @@
 import { Storage } from '#async_storage';
 import { EventEmitter } from 'node:events';
 import { serializeError } from './tools/utils.js';
-import { isStringboolTrue } from '#utils';
+import { isStringboolTrue } from '#helpers/string';
 import * as localProcessor from './processors/local/index.js';
 import * as s3Processor from './processors/s3/index.js';
 import { ComponentType } from '#consts';

package/src/worker/catalog_workflow/catalog_job.js

@@ -3,7 +3,7 @@ import { WorkflowExecutionAlreadyStartedError, WorkflowIdConflictPolicy } from '
 import { WORKFLOW_CATALOG } from '#consts';
 import { catalogId, taskQueue } from '../configs.js';
 import { createChildLogger } from '#logger';
-import { CancellablePromise } from '#utils';
+import { CancellablePromise } from '#helpers/promise';
 
 const log = createChildLogger( 'Catalog' );
 

package/src/worker/catalog_workflow/index.spec.js

@@ -7,9 +7,6 @@ vi.mock( '#consts', () => ( {
   METADATA_ACCESS_SYMBOL
 } ) );
 
-const setMetadata = ( target, values ) =>
-  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
-
 describe( 'createCatalog', () => {
   it( 'builds catalog with activities grouped by workflow path and returns Catalog with CatalogWorkflow entries', async () => {
     const { createCatalog } = await import( './index.js' );
@@ -32,40 +29,40 @@ describe( 'createCatalog', () => {
     ];
 
     const activity1 = () => {};
-    setMetadata( activity1, {
+    activity1[METADATA_ACCESS_SYMBOL] = {
       name: 'A1',
       path: '/flows/flow1#A1',
       description: 'desc-a1',
       inputSchema: z.object( { in: z.literal( 'a1' ) } ),
       outputSchema: z.object( { out: z.literal( 'a1' ) } )
-    } );
+    };
 
     const activity2 = () => {};
-    setMetadata( activity2, {
+    activity2[METADATA_ACCESS_SYMBOL] = {
       name: 'A2',
       path: '/flows/flow1#A2',
       description: 'desc-a2',
       inputSchema: z.object( { in: z.literal( 'a2' ) } ),
       outputSchema: z.object( { out: z.literal( 'a2' ) } )
-    } );
+    };
 
     const activity3 = () => {};
-    setMetadata( activity3, {
+    activity3[METADATA_ACCESS_SYMBOL] = {
       name: 'B1',
       path: '/flows/flow2#B1',
       description: 'desc-b1',
       inputSchema: z.object( { in: z.literal( 'b1' ) } ),
       outputSchema: z.object( { out: z.literal( 'b1' ) } )
-    } );
+    };
 
     const activity4 = () => {};
-    setMetadata( activity4, {
+    activity4[METADATA_ACCESS_SYMBOL] = {
       name: 'X',
       path: '/other#X',
       description: 'desc-x',
       inputSchema: z.object( { in: z.literal( 'x' ) } ),
       outputSchema: z.object( { out: z.literal( 'x' ) } )
-    } );
+    };
 
     const activities = {
       '/flows/flow1#A1': activity1,

package/src/worker/configs.js

@@ -1,10 +1,17 @@
 import * as z from 'zod';
-import { isStringboolTrue } from '#utils';
+import { isStringboolTrue } from '#helpers/string';
 
 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

@@ -1,13 +1,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
-};
+import { CancellablePromise } from '#helpers/promise';
 
 const log = createChildLogger( 'Connection' );
 
@@ -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/global_functions.js

@@ -0,0 +1,14 @@
+import { messageBus } from '#bus';
+import { ACTIVITY_LOGGER_SYMBOL, BusEventType } from '#consts';
+import { activityInfo as activityInfoFn } from '@temporalio/activity';
+import { assignImmutableProperty } from '#helpers/object';
+
+/**
+ * Sets global functions on globalThis
+ */
+export const bindGlobalFunctions = () => {
+  /** Defines the activity logger function, accessible in activity context via logger interface */
+  assignImmutableProperty( globalThis, ACTIVITY_LOGGER_SYMBOL, ( { level, message, metadata } ) =>
+    messageBus.emit( BusEventType.ACTIVITY_LOG, { level, message, metadata, activityInfo: activityInfoFn() } )
+  );
+};

package/src/worker/global_functions.spec.js

@@ -0,0 +1,55 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+const {
+  ACTIVITY_LOGGER_SYMBOL,
+  BusEventType
+} = vi.hoisted( () => ( {
+  ACTIVITY_LOGGER_SYMBOL: Symbol( 'activity_logger' ),
+  BusEventType: {
+    ACTIVITY_LOG: 'activity:log'
+  }
+} ) );
+
+const messageBusMock = vi.hoisted( () => ( {
+  emit: vi.fn()
+} ) );
+const activityInfoMock = vi.hoisted( () => vi.fn( () => ( {
+  activityId: 'act-1',
+  activityType: 'myStep'
+} ) ) );
+
+vi.mock( '#consts', () => ( { ACTIVITY_LOGGER_SYMBOL, BusEventType } ) );
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '@temporalio/activity', () => ( {
+  activityInfo: activityInfoMock
+} ) );
+
+describe( 'worker/global_functions', () => {
+  beforeEach( () => {
+    vi.clearAllMocks();
+    delete globalThis[ACTIVITY_LOGGER_SYMBOL];
+  } );
+
+  it( 'binds activity logger global function that emits activity log events with metadata', async () => {
+    const { bindGlobalFunctions } = await import( './global_functions.js' );
+    const metadata = { requestId: 'req-1' };
+
+    bindGlobalFunctions();
+    globalThis[ACTIVITY_LOGGER_SYMBOL]( {
+      level: 'debug',
+      message: 'activity detail',
+      metadata
+    } );
+
+    expect( activityInfoMock ).toHaveBeenCalledTimes( 1 );
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.ACTIVITY_LOG, {
+      level: 'debug',
+      message: 'activity detail',
+      metadata,
+      activityInfo: {
+        activityId: 'act-1',
+        activityType: 'myStep'
+      }
+    } );
+  } );
+} );

package/src/worker/index.js

@@ -17,7 +17,8 @@ import { messageBus } from '#bus';
 import { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
-import { runOnce } from '#utils';
+import { bindGlobalFunctions } from './global_functions.js';
+import { runOnce } from '#helpers/function';
 
 import './log_hooks.js';
 
@@ -33,7 +34,9 @@ const {
   maxConcurrentActivityTaskExecutions,
   maxCachedWorkflows,
   maxConcurrentActivityTaskPolls,
-  maxConcurrentWorkflowTaskPolls
+  maxConcurrentWorkflowTaskPolls,
+  shutdownForceTime,
+  shutdownGraceTime
 } = configs;
 
 const state = {
@@ -73,6 +76,9 @@ const execute = async () => {
   if ( proxy ) {
     log.info( 'Using gRPC proxy', { targetHost: grpcProxy } );
   }
+
+  bindGlobalFunctions();
+
   state.connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
   log.info( 'Creating connection monitor...' );
@@ -95,7 +101,9 @@ const execute = async () => {
     maxCachedWorkflows,
     maxConcurrentActivityTaskPolls,
     maxConcurrentWorkflowTaskPolls,
-    bundlerOptions: { webpackConfigHook }
+    bundlerOptions: { webpackConfigHook },
+    ...( shutdownForceTime !== undefined && { shutdownForceTime } ),
+    ...( shutdownGraceTime !== undefined && { shutdownGraceTime } )
   } );
 
   log.info( 'Setting up telemetry...' );