@outputai/core 0.8.1-next.e92f632.0 → 0.8.2-next.013689b.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.8.1-next.e92f632.0",
+  "version": "0.8.2-next.013689b.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -12,9 +12,13 @@
       "types": "./src/hooks/index.d.ts",
       "import": "./src/hooks/index.js"
     },
-    "./sdk_activity_integration": {
-      "types": "./src/activity_integration/index.d.ts",
-      "import": "./src/activity_integration/index.js"
+    "./sdk/helpers": {
+      "types": "./src/sdk/helpers/index.d.ts",
+      "import": "./src/sdk/helpers/index.js"
+    },
+    "./sdk/runtime": {
+      "types": "./src/sdk/runtime/index.d.ts",
+      "import": "./src/sdk/runtime/index.js"
     },
     "./sdk_utils": {
       "types": "./src/utils/index.d.ts",

package/src/interface/evaluator.js

@@ -1,5 +1,5 @@
 import { EvaluatorValidator } from './validations/index.js';
-import { setMetadata } from '#utils';
+import { setMetadata } from '#internal_utils/component';
 import { ComponentType } from '#consts';
 
 /**

package/src/interface/step.js

@@ -1,5 +1,5 @@
 import { StepValidator } from './validations/index.js';
-import { setMetadata } from '#utils';
+import { setMetadata } from '#internal_utils/component';
 import { ComponentType } from '#consts';
 
 /**

package/src/interface/workflow.js

@@ -1,8 +1,9 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
 import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy } from '@temporalio/workflow';
 import { WorkflowValidator } from './validations/index.js';
-import { deepMerge, setMetadata, toUrlSafeBase64 } from '#utils';
+import { deepMerge, toUrlSafeBase64 } from '#utils';
 import { WorkflowContext } from '#internal_utils/workflow_context';
+import { setMetadata } from '#internal_utils/component';
 import { TraceInfo } from '#internal_utils/trace_info';
 import { defaultOptions } from './workflow_activity_options.js';
 import {

package/src/internal_activities/index.js

@@ -1,6 +1,7 @@
 import { FatalError } from '#errors';
 import { fetch } from 'undici';
-import { setMetadata, serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
+import { serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
+import { setMetadata } from '#internal_utils/component';
 import { ComponentType } from '#consts';
 import { createChildLogger } from '#logger';
 import { getDestinations } from '#tracing';

package/src/internal_utils/component.js

@@ -0,0 +1,9 @@
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+
+/**
+ * Add metadata "values" property to a given object
+ * @param {object} target
+ * @param {object} values
+ */
+export const setMetadata = ( target, values ) =>
+  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );

package/src/sdk/README.md

@@ -0,0 +1,47 @@
+## SDK integration API for Output packages
+
+**THESE MODULES ARE NOT PUBLIC. DO NOT IMPORT THEM ON YOUR PROJECT.**
+
+This folder contains integration helpers used by other Output SDK packages.
+
+The two subfolders represent a hard Temporal boundary. Code imported by
+workflow-bundled modules must only depend on `helpers`. Code that needs worker
+or activity runtime state belongs in `runtime`.
+
+Do not change these without reviewing call-sites.
+
+### `helpers`
+
+Helpers must be safe to import while Temporal workflows are bundled and executed
+in the workflow sandbox.
+
+Allowed:
+
+- Stateless functions and namespace objects.
+- Deterministic code with no runtime side effects at import time.
+- Imports from other sandbox-safe helper modules.
+- Small, dependency-free helpers for any deterministic computation that can run
+  without worker or activity state.
+
+Not allowed:
+
+- Access to activity context, async storage, sinks, tracing state, workers, or
+  clients.
+- Imports from `@temporalio/activity`, `@temporalio/worker`, or Node-only APIs
+  that cannot be bundled into workflow code.
+- Process, filesystem, network, clock, randomness, or environment access unless
+  the behavior is known to be safe and deterministic in the workflow sandbox.
+- Any import chain that reaches `runtime`.
+
+If a helper cannot satisfy these rules, put it in `runtime` instead.
+
+### `runtime`
+
+Runtime modules are for helpers that need Output or Temporal runtime state.
+
+Use `runtime` for activity-only integrations such as context lookup, event
+emission, tracing, async storage, worker state, sinks, and other behavior that is
+not safe inside workflow-bundled code.
+
+Runtime modules may depend on activity runtime APIs and internal state, but they
+must not be imported by workflow-safe code.

package/src/sdk/helpers/component_metadata.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Tools to extract data from Outputai Core Components metadata storage
+ */
+export declare const ComponentMetadata: {
+  /**
+   * Extract the name from a workflow(), step() or evaluator() return
+   * @param fn
+   * @returns
+   */
+  getName( fn: Function ): string | undefined;
+
+  /**
+   * Check if a function has metadata from workflow(), step() or evaluator()
+   * @param fn
+   */
+  has( fn: Function ): boolean;
+};

package/src/sdk/helpers/component_metadata.js

@@ -0,0 +1,6 @@
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+
+export const ComponentMetadata = {
+  getName: fn => fn[METADATA_ACCESS_SYMBOL]?.name,
+  has: fn => !!fn[METADATA_ACCESS_SYMBOL]
+};

package/src/sdk/helpers/component_metadata.spec.js

@@ -0,0 +1,30 @@
+import { describe, expect, it } from 'vitest';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { ComponentMetadata } from './component_metadata.js';
+
+describe( 'ComponentMetadata', () => {
+  it( 'detects functions tagged with component metadata', () => {
+    const component = () => {};
+    Object.defineProperty( component, METADATA_ACCESS_SYMBOL, {
+      value: { name: 'my_component' }
+    } );
+
+    expect( ComponentMetadata.has( component ) ).toBe( true );
+  } );
+
+  it( 'returns the component metadata name', () => {
+    const component = () => {};
+    Object.defineProperty( component, METADATA_ACCESS_SYMBOL, {
+      value: { name: 'my_component' }
+    } );
+
+    expect( ComponentMetadata.getName( component ) ).toBe( 'my_component' );
+  } );
+
+  it( 'returns false and undefined for untagged functions', () => {
+    const fn = () => {};
+
+    expect( ComponentMetadata.has( fn ) ).toBe( false );
+    expect( ComponentMetadata.getName( fn ) ).toBeUndefined();
+  } );
+} );

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

@@ -0,0 +1,11 @@
+/**
+ * > [!WARNING]
+ * > **Internal use only.** Not part of the public API; may change without notice.
+ *
+ * These are stateless helpers for other SDK modules integration.
+ * They can be used while Temporal workflows are bundled.
+ *
+ * @packageDocumentation
+ */
+export * from './component_metadata.js';
+export * from './path.js';

package/src/sdk/helpers/index.js

@@ -0,0 +1,2 @@
+export * from './component_metadata.js';
+export * from './path.js';

package/src/sdk/helpers/path.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Tools to interact with filesystem paths
+ */
+export declare const Path: {
+  /**
+   * Return the first immediate directory of the file invoking the code that called this function.
+   *
+   * Excludes `@outputai/core`, node, other internal paths, and any additional ignore paths.
+   */
+  resolveInvocationDir( additionalIgnorePaths?: string[] ): string
+};

package/src/sdk/helpers/path.js

@@ -0,0 +1,32 @@
+import * as stackTraceParser from 'stacktrace-parser';
+
+// OS separator, but in a deterministic way, allowing this to work in Temporal's sandbox
+// This avoids importing from node:path
+const SEP = new Error().stack.includes( '/' ) ? '/' : '\\';
+const transformSeparators = path => path.replaceAll( '/', SEP );
+
+const defaultIgnorePaths = [
+  '/@outputai/core/',
+  '/@outputai/llm/',
+  '/@outputai/evals/',
+  '/sdk/core/',
+  '/sdk/llm/',
+  '/sdk/evals/',
+  'node:internal/',
+  'evalmachine.',
+  'webpack/bootstrap'
+];
+
+export const Path = {
+  resolveInvocationDir: ( additionalIgnorePaths = [] ) => {
+    const stack = new Error().stack;
+    const lines = stackTraceParser.parse( stack );
+    const ignorePaths = [ ...additionalIgnorePaths, ...defaultIgnorePaths ].map( transformSeparators );
+
+    const frame = lines.find( l => !ignorePaths.some( p => l.file.includes( p ) ) );
+    if ( !frame ) {
+      throw new Error( `Invocation dir resolution via stack trace failed. Stack: ${stack}` );
+    }
+    return frame.file.replace( 'file://', '' ).split( SEP ).slice( 0, -1 ).join( SEP );
+  }
+};

package/src/{utils/resolve_invocation_dir.spec.js → sdk/helpers/path.spec.js}

@@ -1,5 +1,5 @@
 import { afterEach, describe, expect, it } from 'vitest';
-import resolveInvocationDir from './resolve_invocation_dir';
+import { Path } from './path.js';
 
 const OriginalError = Error;
 
@@ -10,7 +10,7 @@ describe( 'Resolve Invocation Dir', () => {
 
   it( 'Should detect the invocation dir from the tests workflow', () => {
     const stack = `Error
-    at resolveInvocationDir (file:///app/sdk/core/src/utils/resolve_invocation_dir.js)
+    at resolveInvocationDir (file:///app/sdk/core/src/sdk/helpers/path.js)
     at fn (file:///app/test_workflows/dist/simple/steps.js:8:21)
     at wrapper (file:///app/sdk/core/src/interface/step.js:12:26)
     at executeNextHandler (/app/node_modules/@temporalio/worker/lib/activity.js:99:54)
@@ -29,12 +29,12 @@ describe( 'Resolve Invocation Dir', () => {
       }
     };
 
-    expect( resolveInvocationDir() ).toBe( '/app/test_workflows/dist/simple' );
+    expect( Path.resolveInvocationDir() ).toBe( '/app/test_workflows/dist/simple' );
   } );
 
   it( 'Should detect the invocation dir from the sandbox environment at sdk/core', () => {
     const stack = `Error
-    at resolveInvocationDir (file:///app/sdk/core/src/utils/resolve_invocation_dir.js)
+    at resolveInvocationDir (file:///app/sdk/core/src/sdk/helpers/path.js)
     at workflow (file:///app/sdk/core/src/interface/workflow.js:25:16)
     at file:///app/test_workflows/dist/nested/workflow.js:4:16
     at ModuleJob.run (node:internal/modules/esm/module_job:365:25)
@@ -50,12 +50,12 @@ describe( 'Resolve Invocation Dir', () => {
       }
     };
 
-    expect( resolveInvocationDir() ).toBe( '/app/test_workflows/dist/nested' );
+    expect( Path.resolveInvocationDir() ).toBe( '/app/test_workflows/dist/nested' );
   } );
 
   it( 'Should detect the invocation dir from workflow loading at core', () => {
     const stack = `Error
-    at __WEBPACK_DEFAULT_EXPORT__ (/app/sdk/core/src/utils/resolve_invocation_dir.js:13:0)
+    at resolveInvocationDir (/app/sdk/core/src/sdk/helpers/path.js:21:0)
     at workflow (/app/sdk/core/src/interface/workflow.js:22:43)
     at ../../test_workflows/dist/nested/workflow.js (/app/test_workflows/dist/nested/workflow.js:4:24)
     at __webpack_require__ (webpack/bootstrap:19:0)
@@ -73,12 +73,12 @@ describe( 'Resolve Invocation Dir', () => {
       }
     };
 
-    expect( resolveInvocationDir() ).toBe( '/app/test_workflows/dist/nested' );
+    expect( Path.resolveInvocationDir() ).toBe( '/app/test_workflows/dist/nested' );
   } );
 
   it( 'Should detect the invocation dir from a workflow using core installed via NPM', () => {
     const stack = `Error
-    at resolveInvocationDir (file:///app/node_modules/@outputai/core/src/utils/resolve_invocation_dir.js)
+    at resolveInvocationDir (file:///app/node_modules/@outputai/core/src/sdk/helpers/path.js)
     at fn (file:///app/dist/simple/steps.js:8:21)
     at wrapper (file:///app/node_modules/@outputai/core/src/interface/step.js:12:26)
     at executeNextHandler (/app/node_modules/@temporalio/worker/lib/activity.js:99:54)
@@ -97,6 +97,6 @@ describe( 'Resolve Invocation Dir', () => {
       }
     };
 
-    expect( resolveInvocationDir() ).toBe( '/app/dist/simple' );
+    expect( Path.resolveInvocationDir() ).toBe( '/app/dist/simple' );
   } );
 } );

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

@@ -0,0 +1,30 @@
+import type { Info } from '@temporalio/activity';
+
+/**
+ * Context object
+ */
+export type Context = {
+  /** Temporal info about the current activity */
+  activityInfo: Info,
+  /** Path of the workflow file */
+  workflowFilename: string
+};
+
+/**
+ * Tools to interact with Runtime context
+ */
+export declare const Context: {
+
+  /**
+   * Returns information about the current Temporal execution.
+   *
+   * Only available when called from within a step or evaluator (Temporal Activities) running in the Temporal runtime.
+   *
+   * @remarks
+   * - Returns `null` when not called inside a Temporal Activity (steps/evaluators);
+   * - Returns `null` when not called from within a running Temporal worker, like in unit tests environment;
+   *
+   * @returns The workflow context, or `null` if unavailable or incomplete.
+   */
+  getActivityContext(): Context | null;
+};

package/src/sdk/runtime/context.js

@@ -0,0 +1,15 @@
+import { Storage } from '#async_storage';
+
+export const Context = {
+  getActivityContext: () => {
+    const ctx = Storage.load();
+    if ( !ctx ) {
+      return null;
+    }
+
+    return {
+      workflowFilename: ctx.workflowFilename,
+      activityInfo: ctx.activityInfo
+    };
+  }
+};

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/utils/index.d.ts

@@ -5,13 +5,6 @@
  * @packageDocumentation
  */
 
-/**
- * Return the first immediate directory of the file invoking the code that called this function.
- *
- * Excludes `@outputai/core`, node, and other internal paths.
- */
-export function resolveInvocationDir(): string;
-
 /**
  * Node safe clone implementation that doesn't use global structuredClone().
  *
@@ -23,31 +16,6 @@ export function resolveInvocationDir(): string;
  */
 export function clone( object: object ): object;
 
-/**
- * Receives an error as argument and throws it.
- *
- * @param error
- * @throws {Error}
- */
-export function throws( error: Error ): void;
-
-/**
- * Attach given value to an object with the METADATA_ACCESS_SYMBOL symbol as key.
- *
- * @param target
- * @param value
- * @returns
- */
-export function setMetadata( target: object, value: object ): void;
-
-/**
- * Read metadata previously attached via setMetadata.
- *
- * @param target - The function or object to read metadata from.
- * @returns The metadata object, or null if none is attached.
- */
-export function getMetadata( target: Function ): { name: string; description?: string; type?: string } | null;
-
 /** Represents a {Response} serialized to plain object  */
 export type SerializedFetchResponse = {
   /** The response url */

package/src/utils/index.js

@@ -1,2 +1 @@
-export { default as resolveInvocationDir } from './resolve_invocation_dir.js';
 export * from './utils.js';

package/src/utils/utils.js

@@ -1,5 +1,3 @@
-import { METADATA_ACCESS_SYMBOL } from '#consts';
-
 /**
  * Node safe clone implementation that doesn't use global structuredClone()
  * @param {object} v
@@ -25,31 +23,6 @@ export const isPlainObject = v =>
     v !== null &&
     [ Object.prototype, null ].includes( Object.getPrototypeOf( v ) );
 
-/**
- * Throw given error
- * @param {Error} e
- * @throws {e}
- */
-export const throws = e => {
-  throw e;
-};
-
-/**
- * Add metadata "values" property to a given object
- * @param {object} target
- * @param {object} values
- * @returns
- */
-export const setMetadata = ( target, values ) =>
-  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );
-
-/**
- * Read metadata previously attached via setMetadata
- * @param {Function} target
- * @returns {object|null}
- */
-export const getMetadata = target => target[METADATA_ACCESS_SYMBOL] ?? null;
-
 /**
  * Returns true if string value is stringbool and true
  * @param {string} v

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();
 

package/src/worker/loader/tools.js

@@ -252,7 +252,7 @@ export const hashSourceCode = async rootDir => {
   try {
     const { hash } = await hashElement( rootDir, {
       folders: {
-        exclude: [ '.*', 'node_modules', 'test_coverage', 'vendor', 'test', 'logs', 'dist' ],
+        exclude: [ '.*', 'node_modules', 'test_coverage', 'vendor', 'test', 'logs', 'temp' ],
         ignoreRootName: true
       },
       files: {

package/src/worker/loader/tools.spec.js

@@ -574,7 +574,7 @@ describe( 'hashSourceCode', () => {
 
     // The cruft tree is identical source plus large excluded artifacts that
     // boot must not walk: local trace dumps under logs/ and build output under dist/.
-    for ( const excluded of [ 'logs', 'logs/runs', 'dist', 'node_modules' ] ) {
+    for ( const excluded of [ 'logs', 'logs/runs', 'node_modules' ] ) {
       const dir = join( withCruft, excluded );
       mkdirSync( dir, { recursive: true } );
       writeFileSync( join( dir, 'dump.json' ), JSON.stringify( { blob: 'x'.repeat( 50_000 ) } ) );

package/src/activity_integration/context.d.ts

@@ -1,23 +0,0 @@
-import type { Info } from '@temporalio/activity';
-/**
- * Context returned by {@link getContext} when running inside a Temporal Activity (step or evaluator).
- */
-export type Context = {
-  /** Temporal info about the current activity */
-  activityInfo: Info,
-  /** Path of the workflow file */
-  workflowFilename: string
-};
-
-/**
- * Returns information about the current Temporal execution.
- *
- * Only available when called from within a step or evaluator (Temporal Activities) running in the Temporal runtime.
- *
- * @remarks
- * - Returns `null` when not called inside a Temporal Activity (steps/evaluators);
- * - Returns `null` when not called from within a running Temporal worker, like in unit tests environment;
- *
- * @returns The workflow context, or `null` if unavailable or incomplete.
- */
-export declare function getExecutionContext(): Context | null;

package/src/activity_integration/context.js

@@ -1,18 +0,0 @@
-import { Storage } from '#async_storage';
-
-/**
- * Returns information trapped on AsyncStorage about the workflow invoking an activity
- *
- * @returns {object}
- */
-export const getExecutionContext = () => {
-  const ctx = Storage.load();
-  if ( !ctx ) {
-    return null;
-  }
-
-  return {
-    workflowFilename: ctx.workflowFilename,
-    activityInfo: ctx.activityInfo
-  };
-};

package/src/activity_integration/event_id_integration.spec.js

@@ -1,52 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { messageBus } from '#bus';
-import { emitEvent } from './events.js';
-
-const UUID_V4_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-
-describe( 'eventId integration', () => {
-  beforeEach( () => {
-    messageBus.removeAllListeners();
-  } );
-
-  it( 'stamps a UUID v4 eventId on every emit (end-to-end via messageBus)', () => {
-    const handler = vi.fn();
-    messageBus.on( 'external:cost:llm:request', handler );
-
-    emitEvent( 'cost:llm:request', { modelId: 'gpt-4o' } );
-
-    expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-      eventId: expect.stringMatching( UUID_V4_REGEX ),
-      modelId: 'gpt-4o'
-    } ) );
-  } );
-
-  it( 'cost:http:request and http:request for the same fetch get distinct eventIds', () => {
-    const costHandler = vi.fn();
-    const reqHandler = vi.fn();
-    messageBus.on( 'external:cost:http:request', costHandler );
-    messageBus.on( 'external:http:request', reqHandler );
-
-    const sharedRequestId = 'req-xyz';
-    emitEvent( 'cost:http:request', { requestId: sharedRequestId, url: 'https://x.test', cost: 1 } );
-    emitEvent( 'http:request', { requestId: sharedRequestId, url: 'https://x.test', status: 200 } );
-
-    const costEventId = costHandler.mock.calls[0][0].eventId;
-    const reqEventId = reqHandler.mock.calls[0][0].eventId;
-    expect( costEventId ).toMatch( UUID_V4_REGEX );
-    expect( reqEventId ).toMatch( UUID_V4_REGEX );
-    expect( costEventId ).not.toBe( reqEventId );
-  } );
-
-  it( 'honors a caller-supplied eventId end-to-end', () => {
-    const handler = vi.fn();
-    messageBus.on( 'external:custom:event', handler );
-
-    emitEvent( 'custom:event', { eventId: 'fixed-id-123', payload: 'hi' } );
-
-    expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
-      eventId: 'fixed-id-123',
-      payload: 'hi'
-    } ) );
-  } );
-} );

package/src/activity_integration/events.d.ts

@@ -1,10 +0,0 @@
-/**
- * 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
- */
-export declare function emitEvent( eventName: string, payload?: unknown ): void;

package/src/activity_integration/events.js

@@ -1,15 +0,0 @@
-import { messageBus } from '#bus';
-import { Storage } from '#async_storage';
-
-export const emitEvent = ( 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/index.d.ts

@@ -1,9 +0,0 @@
-/**
- * > [!WARNING]
- * > **Internal use only.** Not part of the public API; may change without notice.
- *
- * @packageDocumentation
- */
-export { getExecutionContext } from './context';
-export { emitEvent } from './events';
-export * as Tracing from './tracing';

package/src/activity_integration/index.js

@@ -1,3 +0,0 @@
-export { getExecutionContext } from './context.js';
-export { emitEvent } from './events.js';
-export * as Tracing from './tracing.js';

package/src/activity_integration/tracing.d.ts

@@ -1,40 +0,0 @@
-import type { Attribute } from '#trace_attribute';
-
-export { Attribute } from '#trace_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.
- */
-export declare function 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.
- */
-export declare function 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.
- */
-export declare function 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.
- */
-export declare function addEventAttribute( args: { eventId: string; attribute: Attribute.Instance } ): void;

package/src/activity_integration/tracing.js

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

package/src/utils/resolve_invocation_dir.js

@@ -1,34 +0,0 @@
-import * as stackTraceParser from 'stacktrace-parser';
-
-// OS separator, but in a deterministic way, allowing this to work in Temporal's sandbox
-// This avoids importing from node:path
-const SEP = new Error().stack.includes( '/' ) ? '/' : '\\';
-
-const transformSeparators = path => path.replaceAll( '/', SEP );
-const defaultIgnorePaths = [
-  '/@outputai/core/',
-  '/@outputai/llm/',
-  '/@outputai/evals/',
-  '/sdk/core/',
-  '/sdk/llm/',
-  '/sdk/evals/',
-  'node:internal/',
-  'evalmachine.',
-  'webpack/bootstrap'
-];
-
-/**
- * Return the directory of the file invoking the code that called this function
- * Excludes some internal paths and the sdk itself
- */
-export default ( additionalIgnorePaths = [] ) => {
-  const stack = new Error().stack;
-  const lines = stackTraceParser.parse( stack );
-  const ignorePaths = [ ...additionalIgnorePaths, ...defaultIgnorePaths ].map( transformSeparators );
-
-  const frame = lines.find( l => !ignorePaths.some( p => l.file.includes( p ) ) );
-  if ( !frame ) {
-    throw new Error( `Invocation dir resolution via stack trace failed. Stack: ${stack}` );
-  }
-  return frame.file.replace( 'file://', '' ).split( SEP ).slice( 0, -1 ).join( SEP );
-};