@outputai/core 0.5.3-next.bdf47aa.0 → 0.6.1-next.1f47248.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@outputai/core",
-  "version": "0.5.3-next.bdf47aa.0",
+  "version": "0.6.1-next.1f47248.0",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {
@@ -65,7 +65,7 @@
     "#bus": "./src/bus.js",
     "#consts": "./src/consts.js",
     "#errors": "./src/errors.js",
-    "#logger": "./src/logger.js",
+    "#logger": "./src/logger/index.js",
     "#utils": "./src/utils/index.js",
     "#internal_utils/*": "./src/internal_utils/*.js",
     "#tracing": "./src/tracing/internal_interface.js",

package/src/activity_integration/context.d.ts

@@ -1,16 +1,12 @@
+import type { Info } from '@temporalio/activity';
 /**
  * Context returned by {@link getContext} when running inside a Temporal Activity (step or evaluator).
  */
 export type Context = {
-  /** Information about the current workflow execution */
-  workflow: {
-    /** Temporal's workflow execution id */
-    id: string;
-    /** Workflow name (Temporal's workflow "type" value) */
-    name: string;
-    /** Path of the workflow file */
-    filename: string;
-  }
+  /** Temporal info about the current activity */
+  activityInfo: Info,
+  /** Path of the workflow file */
+  workflowFilename: string
 };
 
 /**

package/src/activity_integration/context.js

@@ -7,11 +7,12 @@ import { Storage } from '#async_storage';
  */
 export const getExecutionContext = () => {
   const ctx = Storage.load();
-
-  if ( !ctx?.executionContext || !ctx?.workflowFilename ) {
+  if ( !ctx ) {
     return null;
   }
 
-  const { workflowId: id, workflowName: name } = ctx.executionContext;
-  return { workflow: { id, name, filename: ctx.workflowFilename } };
+  return {
+    workflowFilename: ctx.workflowFilename,
+    activityInfo: ctx.activityInfo
+  };
 };

package/src/activity_integration/context.spec.js

@@ -17,26 +17,21 @@ describe( 'getExecutionContext', () => {
     expect( getExecutionContext() ).toBeNull();
   } );
 
-  it( 'returns null when executionContext is missing', async () => {
-    loadMock.mockReturnValue( { workflowFilename: '/workflows/foo.js' } );
-    const { getExecutionContext } = await import( './index.js' );
-    expect( getExecutionContext() ).toBeNull();
-  } );
-
-  it( 'returns null when workflowFilename is missing', async () => {
-    loadMock.mockReturnValue( { executionContext: { workflowId: 'wf-1', workflowName: 'myWorkflow' } } );
-    const { getExecutionContext } = await import( './index.js' );
-    expect( getExecutionContext() ).toBeNull();
-  } );
-
-  it( 'returns workflow context when storage has full context', async () => {
+  it( 'returns activity execution context from storage', async () => {
+    const activityInfo = {
+      activityId: 'activity-1',
+      activityType: 'myActivity',
+      workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
+      workflowType: 'myWorkflow'
+    };
     loadMock.mockReturnValue( {
-      executionContext: { workflowId: 'wf-1', workflowName: 'myWorkflow' },
+      activityInfo,
       workflowFilename: '/workflows/myWorkflow.js'
     } );
     const { getExecutionContext } = await import( './index.js' );
     expect( getExecutionContext() ).toEqual( {
-      workflow: { id: 'wf-1', name: 'myWorkflow', filename: '/workflows/myWorkflow.js' }
+      activityInfo,
+      workflowFilename: '/workflows/myWorkflow.js'
     } );
   } );
 } );

package/src/activity_integration/events.d.ts

@@ -1,10 +1,8 @@
 /**
  * Emits a custom event on the in-process message bus.
  *
- * The framework automatically attaches `workflowId`, `runId`, and `activityId`
- * (pulled from `executionContext`) onto every emitted payload, so consumer
- * subscribers registered via `on(...)` always receive those identifiers
- * alongside whatever custom fields the emitter supplies.
+ * 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

package/src/activity_integration/events.js

@@ -4,7 +4,12 @@ import { Storage } from '#async_storage';
 export const emitEvent = ( eventName, payload ) => {
   const ctx = Storage.load();
 
-  const { executionContext, parentId: activityId } = ctx ?? {};
-  const { workflowId, runId } = executionContext ?? {};
-  messageBus.emit( `external:${eventName}`, { ...payload ?? {}, workflowId, runId, activityId } );
+  messageBus.emit( `external:${eventName}`, {
+    ...payload ?? {},
+    ...( ctx && {
+      activityInfo: ctx.activityInfo,
+      workflowDetails: ctx.workflowDetails,
+      outputActivityKind: ctx.outputActivityKind
+    } )
+  } );
 };

package/src/activity_integration/events.spec.js

@@ -21,69 +21,98 @@ describe( 'emitEvent', () => {
     vi.clearAllMocks();
   } );
 
-  it( 'forwards workflowId, runId, and activityId from executionContext', () => {
+  it( 'forwards activityInfo, workflowDetails, and outputActivityKind from storage', () => {
+    const activityInfo = {
+      activityId: 'act-1',
+      activityType: 'step',
+      workflowExecution: { workflowId: 'wf-1', runId: 'run-1' },
+      workflowType: 'workflow'
+    };
+    const workflowDetails = {
+      workflowId: 'wf-1',
+      runId: 'run-1',
+      workflowType: 'workflow'
+    };
     loadMock.mockReturnValue( {
-      executionContext: { workflowId: 'wf-1', runId: 'run-1' },
-      parentId: 'act-1'
+      activityInfo,
+      workflowDetails,
+      outputActivityKind: 'step'
     } );
 
     emitEvent( 'cost:llm:request', { modelId: 'gpt-4o' } );
 
     expect( emitMock ).toHaveBeenCalledWith( 'external:cost:llm:request', expect.objectContaining( {
-      workflowId: 'wf-1',
-      runId: 'run-1',
-      activityId: 'act-1',
+      activityInfo,
+      workflowDetails,
+      outputActivityKind: 'step',
       modelId: 'gpt-4o'
     } ) );
   } );
 
-  it( 'handles missing executionContext gracefully', () => {
+  it( 'emits payload without context when storage is missing', () => {
     loadMock.mockReturnValue( undefined );
 
     emitEvent( 'foo:bar', { x: 1 } );
 
-    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', expect.objectContaining( {
-      workflowId: undefined,
-      runId: undefined,
-      activityId: undefined,
-      x: 1
-    } ) );
+    expect( emitMock ).toHaveBeenCalledWith( 'external:foo:bar', { x: 1 } );
   } );
 
   it( 'handles missing payload', () => {
+    const activityInfo = {
+      activityId: 'act-2',
+      activityType: 'step',
+      workflowExecution: { workflowId: 'wf-2', runId: 'run-2' },
+      workflowType: 'workflow'
+    };
+    const workflowDetails = {
+      workflowId: 'wf-2',
+      runId: 'run-2',
+      workflowType: 'workflow'
+    };
     loadMock.mockReturnValue( {
-      executionContext: { workflowId: 'wf-2', runId: 'run-2' },
-      parentId: 'act-2'
+      activityInfo,
+      workflowDetails,
+      outputActivityKind: 'step'
     } );
 
     emitEvent( 'lifecycle:start' );
 
     expect( emitMock ).toHaveBeenCalledWith( 'external:lifecycle:start', expect.objectContaining( {
-      workflowId: 'wf-2',
-      runId: 'run-2',
-      activityId: 'act-2'
+      activityInfo,
+      workflowDetails,
+      outputActivityKind: 'step'
     } ) );
   } );
 
-  it( 'does not let payload override workflowId / runId / activityId', () => {
+  it( 'does not let payload override activityInfo, workflowDetails, or outputActivityKind', () => {
+    const activityInfo = {
+      activityId: 'act-3',
+      activityType: 'step',
+      workflowExecution: { workflowId: 'wf-3', runId: 'run-3' },
+      workflowType: 'workflow'
+    };
+    const workflowDetails = {
+      workflowId: 'wf-3',
+      runId: 'run-3',
+      workflowType: 'workflow'
+    };
     loadMock.mockReturnValue( {
-      executionContext: { workflowId: 'wf-3', runId: 'run-3' },
-      parentId: 'act-3'
+      activityInfo,
+      workflowDetails,
+      outputActivityKind: 'step'
     } );
 
     emitEvent( 'cost:http:request', {
-      workflowId: 'should-be-overridden',
-      runId: 'should-be-overridden',
-      activityId: 'should-be-overridden',
+      activityInfo: { activityId: 'should-be-overridden' },
+      workflowDetails: { workflowId: 'should-be-overridden' },
+      outputActivityKind: 'should-be-overridden',
       url: 'https://example.com'
     } );
 
-    // Context fields are spread after the payload, so caller-supplied
-    // workflowId / runId / activityId cannot escape the executionContext.
     expect( emitMock ).toHaveBeenCalledWith( 'external:cost:http:request', expect.objectContaining( {
-      workflowId: 'wf-3',
-      runId: 'run-3',
-      activityId: 'act-3',
+      activityInfo,
+      workflowDetails,
+      outputActivityKind: 'step',
       url: 'https://example.com'
     } ) );
   } );

package/src/bus.js

@@ -3,19 +3,28 @@ import { randomUUID } from 'node:crypto';
 import { isPlainObject } from '#utils';
 
 const emitter = new EventEmitter();
-const originalEmit = emitter.emit.bind( emitter );
-
-const attachEventId = payload => ( { ...payload, eventId: payload.eventId ?? randomUUID() } );
 
 /**
  * Every object payload emitted through `messageBus` is stamped with a UUID v4 `eventId`.
  */
-emitter.emit = ( event, ...args ) => {
-  const [ payload, ...rest ] = args;
-  if ( !isPlainObject( payload ) ) {
-    return originalEmit( event, ...args );
+emitter.emit = new Proxy( emitter.emit, {
+  apply( target, thisArg, args ) {
+    const [ eventName, payload, ...extras ] = args;
+    const newArguments = [];
+
+    // do now push arguments that dont exist. if payload is undefined with len=1, means it was never defined
+    // if payload is undefined with len>1, means user passed 'undefined' as argument
+    if ( args.length > 1 ) {
+      newArguments.push( isPlainObject( payload ) ? {
+        eventId: randomUUID(),
+        eventDate: Date.now(),
+        ...payload
+      } : payload );
+      newArguments.push( ...extras );
+    }
+
+    return Reflect.apply( target, thisArg, [ eventName, ...newArguments ] );
   }
-  return originalEmit( event, attachEventId( payload ), ...rest );
-};
+} );
 
 export const messageBus = emitter;

package/src/bus.spec.js

@@ -47,6 +47,35 @@ describe( 'messageBus', () => {
       } ) );
     } );
 
+    it( 'stamps eventDate on every object payload', () => {
+      const handler = vi.fn();
+      const now = new Date( '2026-06-02T12:00:00.000Z' );
+      vi.useFakeTimers();
+      vi.setSystemTime( now );
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', { foo: 'bar' } );
+
+      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
+        eventDate: now.getTime(),
+        foo: 'bar'
+      } ) );
+
+      vi.useRealTimers();
+    } );
+
+    it( 'preserves a caller-supplied eventDate', () => {
+      const handler = vi.fn();
+      messageBus.on( 'test:event', handler );
+
+      messageBus.emit( 'test:event', { eventDate: 1234, foo: 'bar' } );
+
+      expect( handler ).toHaveBeenCalledWith( expect.objectContaining( {
+        eventDate: 1234,
+        foo: 'bar'
+      } ) );
+    } );
+
     it( 'does not mutate the caller-supplied payload object', () => {
       const handler = vi.fn();
       messageBus.on( 'test:event', handler );
@@ -55,6 +84,7 @@ describe( 'messageBus', () => {
       messageBus.emit( 'test:event', payload );
 
       expect( payload ).not.toHaveProperty( 'eventId' );
+      expect( payload ).not.toHaveProperty( 'eventDate' );
     } );
   } );
 

package/src/hooks/index.d.ts

@@ -1,63 +1,130 @@
+import type { Info } from '@temporalio/activity';
+
+export interface WorkflowDetails {
+  /**
+   * ID of the Workflow, this can be set by the client during Workflow creation.
+   * A single Workflow may run multiple times e.g. when scheduled with cron.
+   */
+  workflowId: string;
+  /**
+   * ID of a single Workflow run
+   */
+  runId: string;
+  /**
+   * Workflow function's name
+   */
+  workflowType: string;
+  /**
+   * Parent Workflow info (present if this is a Child Workflow)
+   */
+  parent?: {
+    /**
+     * ID of the Workflow, this can be set by the client during Workflow creation.
+     * A single Workflow may run multiple times e.g. when scheduled with cron.
+     */
+    workflowId: string;
+    /**
+     * ID of a single Workflow run
+     */
+    runId: string;
+    /**
+     * Namespace this Workflow is executing in
+     */
+    namespace: string;
+  };
+  /**
+   * The root workflow execution, defined as follows:
+   * 1. A workflow without a parent workflow is its own root workflow.
+   * 2. A workflow with a parent workflow has the same root workflow as
+   * its parent.
+   *
+   * When there is no parent workflow, i.e., the workflow is its own root workflow,
+   * this field is `undefined`.
+   *
+   * Note that Continue-as-New (or reset) propagates the workflow parentage relationship,
+   * and therefore, whether the new workflow has the same root workflow as the original one
+   * depends on whether it had a parent.
+   *
+   */
+  root?: {
+    /**
+     * ID of the Workflow, this can be set by the client during Workflow creation.
+     * A single Workflow may run multiple times e.g. when scheduled with cron.
+     */
+    workflowId: string;
+    /**
+     * ID of a single Workflow run
+     */
+    runId: string;
+  };
+  /**
+   * Run Id of the first Run in this Execution Chain
+   */
+  firstExecutionRunId: string;
+  /**
+   * The last Run Id in this Execution Chain
+   */
+  continuedFromExecutionRunId?: string;
+  /**
+   * Time at which this [Workflow Execution Chain](https://docs.temporal.io/workflows#workflow-execution-chain) was started
+   */
+  startTime: number;
+  /**
+   * Time at which the current Workflow Run started
+   */
+  runStartTime: number;
+  /**
+   * Starts at 1 and increments for every retry if there is a `retryPolicy`
+   */
+  attempt: number;
+}
+
 /**
- * Payload passed to the onError handler when a workflow, activity or runtime error occurs.
+ * Payload passed to the onError() handler when a workflow, activity or runtime error occurs.
  */
 export interface ErrorHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
   /** Origin of the error: workflow execution, activity execution, or runtime. */
   source: 'workflow' | 'activity' | 'runtime';
-  /** Name of the workflow, when the error is scoped to a workflow or activity. */
-  workflowName?: string;
-  /** Name of the activity, when the error is from an activity. */
-  activityName?: string;
+  /** Information about the current workflow execution */
+  workflowDetails?: WorkflowDetails;
+  /** Temporal's activityInfo(). If source is activity */
+  activityInfo?: Info;
+  /** Output component kind for the activity, e.g. step, evaluator, or internal_step. */
+  outputActivityKind?: string;
   /** The error thrown. */
   error: Error;
 }
 
 /**
- * Payload passed to the onWorkflowStart handler when a workflow run begins.
+ * Payload passed to the onWorkflowStart() handler when a workflow run begins.
  */
 export interface WorkflowStartHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
-  /** Workflow id (stable across retries / continue-as-new). */
-  id: string;
-  /** Temporal run id for the current execution attempt. */
-  runId: string;
-  /** Name of the workflow. */
-  name: string;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
 }
 
 /**
- * Payload passed to the onWorkflowEnd handler when a workflow run completes successfully.
+ * Payload passed to the onWorkflowEnd() handler when a workflow run completes successfully.
  */
 export interface WorkflowEndHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
-  /** Workflow id (stable across retries / continue-as-new). */
-  id: string;
-  /** Temporal run id for the current execution attempt. */
-  runId: string;
-  /** Name of the workflow. */
-  name: string;
-  /** Duration of the workflow run in milliseconds. */
-  duration: number;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
 }
 
 /**
- * Payload passed to the onWorkflowError handler when a workflow run fails.
+ * Payload passed to the onWorkflowError() handler when a workflow run fails.
  */
 export interface WorkflowErrorHookPayload {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
-  /** Workflow id (stable across retries / continue-as-new). */
-  id: string;
-  /** Temporal run id for the current execution attempt. */
-  runId: string;
-  /** Name of the workflow. */
-  name: string;
-  /** Elapsed time before failure in milliseconds. */
-  duration: number;
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
   /** The error thrown. */
   error: Error;
 }
@@ -105,42 +172,29 @@ export declare function onWorkflowEnd( handler: ( payload: WorkflowEndHookPayloa
 export declare function onWorkflowError( handler: ( payload: WorkflowErrorHookPayload ) => void ): void;
 
 /**
- * Payload broadcast on the `http:request` event for every HTTP call issued
- * through `@outputai/http`'s `fetch`. Fires for success, non-2xx, and network
- * failure paths — `cost:http:request` continues to fire only when the consumer
- * has attached a cost via `addRequestCost`.
- *
- * The framework auto-attaches `workflowId`, `runId`, and `activityId` onto the
- * payload before broadcast, so consumers receive those identifiers in addition
- * to the fields listed here.
+ * Framework-managed envelope added to payloads passed to on() handlers.
  */
-export interface HttpRequestHookPayload {
+export interface OnHookEnvelope {
   /** UUID v4 stamped per emit. Stable per-emit idempotency key. */
   eventId: string;
-  /** Workflow id (stable across retries / continue-as-new). */
-  workflowId: string;
-  /** Temporal run id for the current execution attempt. */
-  runId: string;
-  /** Activity / step id, when emitted from inside a step. */
-  activityId?: string;
-  /** UUID generated per request inside `@outputai/http`. */
-  requestId: string;
-  /** HTTP method (uppercase). */
-  method: string;
-  /** Absolute request URL. */
-  url: string;
-  /** HTTP status code; undefined on network failure. */
-  status?: number;
-  /** Elapsed time from request issuance to response (or failure), in milliseconds. */
-  durationMs: number;
-  /** Outcome bucket: `success` (2xx-3xx), `error` (status >= 400), `failure` (DNS / timeout / abort). */
-  outcome: 'success' | 'error' | 'failure';
+  /** Information about the current workflow execution */
+  workflowDetails: WorkflowDetails;
+  /** Temporal's activityInfo(). */
+  activityInfo: Info;
+  /** Output component kind for the activity, e.g. step, evaluator, or internal_step. */
+  outputActivityKind?: string;
 }
 
+export type OnHookPayload<TAttributes extends Record<string, unknown> = Record<string, unknown>> =
+  OnHookEnvelope & TAttributes;
+
 /**
  * Register a handler to be invoked when a given event happens
  *
  * @param eventName - The name of the event to subscribe
  * @param handler - Function called with the event payload
  */
-export declare function on( eventName: string, handler: ( payload?: object ) => void ): void;
+export declare function on<TAttributes extends Record<string, unknown> = Record<string, unknown>>(
+  eventName: string,
+  handler: ( payload: OnHookPayload<TAttributes> ) => void
+): void;

package/src/hooks/index.js

@@ -21,29 +21,32 @@ const safeInvoke = async ( fn, args, hookName ) => {
 
 /** Triggers on any errors: workflow, activity and runtime */
 export const onError = handler => {
-  messageBus.on( BusEventType.ACTIVITY_ERROR, async ( { eventId, id, name, workflowId, workflowName, error } ) =>
-    safeInvoke( handler, { eventId, source: 'activity', activityId: id, activityName: name, workflowId, workflowName, error }, 'onError' ) );
-  messageBus.on( BusEventType.WORKFLOW_ERROR, async ( { eventId, id, name, error } ) =>
-    safeInvoke( handler, { eventId, source: 'workflow', workflowId: id, workflowName: name, error }, 'onError' ) );
-  messageBus.on( BusEventType.RUNTIME_ERROR, async ( { eventId, error } ) =>
-    safeInvoke( handler, { eventId, source: 'runtime', error }, 'onError' ) );
+  messageBus.on( BusEventType.ACTIVITY_ERROR, async payload =>
+    safeInvoke( handler, { source: 'activity', ...payload }, 'onError' ) );
+  messageBus.on( BusEventType.WORKFLOW_ERROR, async payload =>
+    safeInvoke( handler, { source: 'workflow', ...payload }, 'onError' ) );
+  messageBus.on( BusEventType.RUNTIME_ERROR, async payload =>
+    safeInvoke( handler, { source: 'runtime', ...payload }, 'onError' ) );
 };
 
 /** Listen to worker before start events */
 export const onBeforeWorkerStart = handler => messageBus.on( BusEventType.WORKER_BEFORE_START, () =>
   safeInvoke( handler, undefined, 'onBeforeWorkerStart' ) );
 
+/** Catalog workflow events should not be emitted */
+const shouldEmitWorkflowEvent = workflowDetails => WORKFLOW_CATALOG !== workflowDetails.workflowType;
+
 /** Listen to workflow start events, excludes catalog workflow */
-export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { eventId, id, runId, name } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { eventId, id, runId, name }, 'onWorkflowStart' ) : null );
+export const onWorkflowStart = handler => messageBus.on( BusEventType.WORKFLOW_START, ( { workflowDetails, ...eventFields } ) =>
+  shouldEmitWorkflowEvent( workflowDetails ) ? safeInvoke( handler, { workflowDetails, ...eventFields }, 'onWorkflowStart' ) : null );
 
 /** Listen to workflow end events, excludes catalog workflow */
-export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { eventId, id, runId, name, duration } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { eventId, id, runId, name, duration }, 'onWorkflowEnd' ) : null );
+export const onWorkflowEnd = handler => messageBus.on( BusEventType.WORKFLOW_END, ( { workflowDetails, ...eventFields } ) =>
+  shouldEmitWorkflowEvent( workflowDetails ) ? safeInvoke( handler, { workflowDetails, ...eventFields }, 'onWorkflowEnd' ) : null );
 
 /** Listen to workflow error events, excludes catalog workflow */
-export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { eventId, id, runId, name, duration, error } ) =>
-  WORKFLOW_CATALOG !== name ? safeInvoke( handler, { eventId, id, runId, name, duration, error }, 'onWorkflowError' ) : null );
+export const onWorkflowError = handler => messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, ...eventFields } ) =>
+  shouldEmitWorkflowEvent( workflowDetails ) ? safeInvoke( handler, { workflowDetails, ...eventFields }, 'onWorkflowError' ) : null );
 
 /** Generic listener for events emitted elsewhere (outside core) */
 export const on = ( eventName, handler ) => messageBus.on( `external:${eventName}`, payload =>