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

package/src/worker/log_hooks.js

@@ -47,6 +47,13 @@ messageBus.on( BusEventType.ACTIVITY_ERROR, ( { activityInfo, outputActivityKind
   } )
 );
 
+messageBus.on( BusEventType.ACTIVITY_LOG, ( { level, message, metadata, activityInfo } ) =>
+  activityLog[level]( message, {
+    ...metadata ?? {},
+    ...serializedActivityFields( activityInfo )
+  } )
+);
+
 /*
 ╔═════════════════╗
 ║ Workflow events ║
@@ -82,3 +89,10 @@ messageBus.on( BusEventType.WORKFLOW_ERROR, ( { workflowDetails, error } ) =>
     error: error.message
   } )
 );
+
+messageBus.on( BusEventType.WORKFLOW_LOG, ( { level, message, metadata, workflowDetails } ) =>
+  workflowLog[level]( message, {
+    ...metadata ?? {},
+    ...serializeWorkflowFields( workflowDetails )
+  } )
+);

package/src/worker/log_hooks.spec.js

@@ -6,8 +6,17 @@ import {
   WORKFLOW_CATALOG
 } from '#consts';
 
-const activityLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
-const workflowLogMock = vi.hoisted( () => ( { info: vi.fn(), error: vi.fn() } ) );
+const createLoggerMock = vi.hoisted( () => () => ( {
+  error: vi.fn(),
+  warn: vi.fn(),
+  info: vi.fn(),
+  http: vi.fn(),
+  verbose: vi.fn(),
+  debug: vi.fn(),
+  silly: vi.fn()
+} ) );
+const activityLogMock = vi.hoisted( () => createLoggerMock() );
+const workflowLogMock = vi.hoisted( () => createLoggerMock() );
 const createChildLoggerMock = vi.hoisted( () =>
   vi.fn( name => ( name === 'Activity' ? activityLogMock : workflowLogMock ) )
 );
@@ -125,6 +134,44 @@ describe( 'log_hooks', () => {
 
       expect( activityLogMock.error ).not.toHaveBeenCalled();
     } );
+
+    it( 'ACTIVITY_LOG logs dynamic levels with metadata and serialized activity fields', () => {
+      onHandlers[BusEventType.ACTIVITY_LOG]( {
+        activityInfo,
+        level: 'debug',
+        message: 'activity detail',
+        metadata: {
+          custom: 'value',
+          workflowId: 'metadata-workflow-id'
+        }
+      } );
+
+      expect( activityLogMock.debug ).toHaveBeenCalledTimes( 1 );
+      expect( activityLogMock.debug ).toHaveBeenCalledWith( 'activity detail', {
+        custom: 'value',
+        activityId: 'act-1',
+        activityType: 'myWorkflow#myStep',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
+
+    it( 'ACTIVITY_LOG accepts omitted metadata', () => {
+      onHandlers[BusEventType.ACTIVITY_LOG]( {
+        activityInfo,
+        level: 'info',
+        message: 'activity detail'
+      } );
+
+      expect( activityLogMock.info ).toHaveBeenCalledWith( 'activity detail', {
+        activityId: 'act-1',
+        activityType: 'myWorkflow#myStep',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
   } );
 
   describe( 'workflow events', () => {
@@ -210,5 +257,39 @@ describe( 'log_hooks', () => {
 
       expect( workflowLogMock.error ).not.toHaveBeenCalled();
     } );
+
+    it( 'WORKFLOW_LOG logs dynamic levels with metadata and serialized workflow fields', () => {
+      onHandlers[BusEventType.WORKFLOW_LOG]( {
+        workflowDetails,
+        level: 'warn',
+        message: 'workflow detail',
+        metadata: {
+          custom: 'value',
+          runId: 'metadata-run-id'
+        }
+      } );
+
+      expect( workflowLogMock.warn ).toHaveBeenCalledTimes( 1 );
+      expect( workflowLogMock.warn ).toHaveBeenCalledWith( 'workflow detail', {
+        custom: 'value',
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
+
+    it( 'WORKFLOW_LOG accepts omitted metadata', () => {
+      onHandlers[BusEventType.WORKFLOW_LOG]( {
+        workflowDetails,
+        level: 'info',
+        message: 'workflow detail'
+      } );
+
+      expect( workflowLogMock.info ).toHaveBeenCalledWith( 'workflow detail', {
+        workflowId: 'wf-1',
+        workflowType: 'myWorkflow',
+        runId: 'run-1'
+      } );
+    } );
   } );
 } );

package/src/worker/sinks.js

@@ -1,7 +1,7 @@
 import { BusEventType, ComponentType } from '#consts';
 import * as Tracing from '#tracing';
 import { messageBus } from '#bus';
-import { createWorkflowDetails } from '#internal_utils/temporal_context';
+import { createWorkflowDetails } from '#helpers/temporal_context';
 
 // This sink allow for sandbox Temporal environment to send trace logs back to the main thread.
 export const sinks = {
@@ -10,6 +10,12 @@ export const sinks = {
    * Workflow lifecycle sinks
    */
   workflow: {
+    log: {
+      fn: ( workflowInfo, { level, message, metadata } ) => {
+        messageBus.emit( BusEventType.WORKFLOW_LOG, { level, message, metadata, workflowDetails: createWorkflowDetails( workflowInfo ) } );
+      },
+      callDuringReplay: false
+    },
     start: {
       fn: ( workflowInfo, input ) => {
         const { runId, workflowType, memo: { traceInfo }, parent } = workflowInfo;

package/src/worker/sinks.spec.js

@@ -0,0 +1,203 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { BusEventType, ComponentType } from '#consts';
+
+const messageBusMock = vi.hoisted( () => ( {
+  emit: vi.fn()
+} ) );
+
+const addEventStartMock = vi.hoisted( () => vi.fn() );
+const addEventEndMock = vi.hoisted( () => vi.fn() );
+const addEventErrorMock = vi.hoisted( () => vi.fn() );
+
+const createWorkflowDetailsMock = vi.hoisted( () => vi.fn( workflowInfo => ( {
+  workflowId: workflowInfo.workflowId,
+  workflowType: workflowInfo.workflowType,
+  runId: workflowInfo.runId
+} ) ) );
+
+vi.mock( '#bus', () => ( { messageBus: messageBusMock } ) );
+vi.mock( '#tracing', () => ( {
+  addEventStart: addEventStartMock,
+  addEventEnd: addEventEndMock,
+  addEventError: addEventErrorMock
+} ) );
+vi.mock( '#helpers/temporal_context', () => ( {
+  createWorkflowDetails: createWorkflowDetailsMock
+} ) );
+
+describe( 'worker/sinks', () => {
+  const workflowInfo = {
+    workflowId: 'wf-1',
+    workflowType: 'myWorkflow',
+    runId: 'run-1',
+    memo: {
+      traceInfo: { traceId: 'trace-1' }
+    },
+    parent: {
+      runId: 'parent-run-1'
+    }
+  };
+  const workflowDetails = {
+    workflowId: 'wf-1',
+    workflowType: 'myWorkflow',
+    runId: 'run-1'
+  };
+
+  beforeEach( () => {
+    vi.clearAllMocks();
+  } );
+
+  it( 'disables replay calls for side-effecting sinks', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    expect( sinks.workflow.start.callDuringReplay ).toBe( false );
+    expect( sinks.workflow.end.callDuringReplay ).toBe( false );
+    expect( sinks.workflow.error.callDuringReplay ).toBe( false );
+    expect( sinks.trace.start.callDuringReplay ).toBe( false );
+    expect( sinks.trace.end.callDuringReplay ).toBe( false );
+    expect( sinks.trace.error.callDuringReplay ).toBe( false );
+  } );
+
+  it( 'workflow.log emits workflow log events with metadata and workflow details', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const metadata = { requestId: 'req-1' };
+
+    sinks.workflow.log.fn( workflowInfo, {
+      level: 'info',
+      message: 'workflow detail',
+      metadata
+    } );
+
+    expect( createWorkflowDetailsMock ).toHaveBeenCalledWith( workflowInfo );
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_LOG, {
+      level: 'info',
+      message: 'workflow detail',
+      metadata,
+      workflowDetails
+    } );
+  } );
+
+  it( 'workflow.start emits workflow start events and trace start events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const input = { value: 'input' };
+
+    sinks.workflow.start.fn( workflowInfo, input );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( addEventStartMock ).toHaveBeenCalledWith( {
+      id: 'run-1',
+      kind: ComponentType.WORKFLOW,
+      name: 'myWorkflow',
+      details: input,
+      parentId: 'parent-run-1',
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'workflow.start skips tracing when trace info is absent', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.workflow.start.fn( { ...workflowInfo, memo: {} }, { value: 'input' } );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_START, { workflowDetails } );
+    expect( addEventStartMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'workflow.end emits workflow end events and trace end events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const output = { value: 'output' };
+
+    sinks.workflow.end.fn( workflowInfo, output );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( addEventEndMock ).toHaveBeenCalledWith( {
+      id: 'run-1',
+      details: output,
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'workflow.end skips tracing when trace info is absent', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.workflow.end.fn( { ...workflowInfo, memo: {} }, { value: 'output' } );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_END, { workflowDetails } );
+    expect( addEventEndMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'workflow.error emits workflow error events and trace error events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const error = new Error( 'workflow failed' );
+
+    sinks.workflow.error.fn( workflowInfo, error );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( addEventErrorMock ).toHaveBeenCalledWith( {
+      id: 'run-1',
+      details: error,
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'workflow.error skips tracing when trace info is absent', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const error = new Error( 'workflow failed' );
+
+    sinks.workflow.error.fn( { ...workflowInfo, memo: {} }, error );
+
+    expect( messageBusMock.emit ).toHaveBeenCalledWith( BusEventType.WORKFLOW_ERROR, { workflowDetails, error } );
+    expect( addEventErrorMock ).not.toHaveBeenCalled();
+  } );
+
+  it( 'trace.start records trace start events with workflow parent context', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.trace.start.fn( workflowInfo, {
+      id: 'step-1',
+      kind: ComponentType.STEP,
+      name: 'myStep',
+      details: { input: true }
+    } );
+
+    expect( addEventStartMock ).toHaveBeenCalledWith( {
+      id: 'step-1',
+      kind: ComponentType.STEP,
+      name: 'myStep',
+      details: { input: true },
+      parentId: 'parent-run-1',
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'trace.end records trace end events', async () => {
+    const { sinks } = await import( './sinks.js' );
+
+    sinks.trace.end.fn( workflowInfo, {
+      id: 'step-1',
+      details: { output: true }
+    } );
+
+    expect( addEventEndMock ).toHaveBeenCalledWith( {
+      id: 'step-1',
+      details: { output: true },
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+
+  it( 'trace.error records trace error events', async () => {
+    const { sinks } = await import( './sinks.js' );
+    const error = new Error( 'step failed' );
+
+    sinks.trace.error.fn( workflowInfo, {
+      id: 'step-1',
+      details: error
+    } );
+
+    expect( addEventErrorMock ).toHaveBeenCalledWith( {
+      id: 'step-1',
+      details: error,
+      traceInfo: { traceId: 'trace-1' }
+    } );
+  } );
+} );

package/src/internal_utils/component.js

@@ -1,9 +0,0 @@
-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/utils/index.d.ts

@@ -1,148 +0,0 @@
-/**
- * > [!WARNING]
- * > **Internal use only.** Not part of the public API; may change without notice.
- *
- * @packageDocumentation
- */
-
-/**
- * Node safe clone implementation that doesn't use global structuredClone().
- *
- * Returns a cloned version of the object.
- *
- * Only clones static properties. Getters become static properties.
- *
- * @param object
- */
-export function clone( object: object ): object;
-
-/** Represents a {Response} serialized to plain object  */
-export type SerializedFetchResponse = {
-  /** The response url */
-  url: string,
-
-  /** The response status code */
-  status: number,
-
-  /** The response status text */
-  statusText: string,
-
-  /** Flag indicating if the request succeeded */
-  ok: boolean,
-
-  /** Object with response headers */
-  headers: Record<string, string>,
-
-  /** Response body, either JSON, text or arrayBuffer converter to base64 */
-  body: object | string
-};
-
-/**
- * Consumes an HTTP `Response` and serializes it to a plain object.
- *
- * @param response - The response to serialize.
- * @returns SerializedFetchResponse
- */
-export function serializeFetchResponse( response: Response ): SerializedFetchResponse;
-
-export type SerializedBodyAndContentType = {
-  /** The body as a string when possible; otherwise the original value */
-  body: string | unknown,
-  /** The inferred `Content-Type` header value, if any */
-  contentType: string | undefined
-};
-
-/**
- * Serializes a payload for use as a fetch POST body and infers its `Content-Type`.
- *
- * @param body - The payload to serialize.
- * @returns The serialized body and inferred `Content-Type`.
- */
-export function serializeBodyAndInferContentType( body: unknown ): SerializedBodyAndContentType;
-
-/**
- * Returns true if the value is a plain object:
- * - `{}`
- * - `new Object()`
- * - `Object.create(null)`
- *
- * @param object - The value to check.
- * @returns Whether the value is a plain object.
- */
-export function isPlainObject( object: unknown ): boolean;
-
-/**
- * Returns a copy of an array with its content shuffled.
- *
- * @param arr - The array to shuffle
- * @returns A shuffled array copy
- */
-export function shuffleArray( arr: unknown[] ): unknown[];
-
-/**
- * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
- * - Fields in `b` overwrite fields in `a`.
- * - Fields in `b` that don't exist in `a` are created.
- * - Fields in `a` that don't exist in `b` are left unchanged.
- *
- * @param a - The base object.
- * @param b - The overriding object.
- * @throws {Error} If either `a` or `b` is not a plain object.
- * @returns A new merged object.
- */
-export function deepMerge( a: object, b: object | null | undefined ): object;
-
-/**
- * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
- * - Fields in `b` that don't exist in `a` are created.
- * - Fields in `a` that don't exist in `b` are left unchanged.
- * - Fields in `a` and `b` are passed as arguments to the resolve function (a,b) and its return assigns the new value.
- *
- * @param a - The base object.
- * @param b - The overriding object.
- * @param resolver - The resolver function.
- * @throws {Error} If either `a` or `b` is not a plain object.
- * @returns A new merged object.
- */
-export function deepMergeWithResolver( a: object, b: object | null | undefined, resolver: function ): object;
-
-/**
- * Shortens a UUID to a url-safe base64-like string (custom 64-char alphabet).
- * Temporal-friendly: no Buffer or crypto; safe to use inside workflows.
- *
- * @param uuid - Standard UUID (e.g. `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`).
- * @returns Short string using A–Z, a–z, 0–9, `_`, `-` (typically 21–22 chars).
- */
-export function toUrlSafeBase64( uuid: string ): string;
-
-/**
- * Similar to native Promise.allSettled, but rejects with `{ isTimeout: true }`
- * if the execution exceeds the given timeout.
- *
- * @param promises - Values or promises to wait for.
- * @param timeoutMs - Maximum wait time in milliseconds.
- * @returns Native Promise.allSettled-style results.
- */
-export function allSettledWithTimeout<T>(
-  promises: Array<T | PromiseLike<T>>,
-  timeoutMs: number
-): Promise<PromiseSettledResult<Awaited<T>>[]>;
-
-/**
- * Promise wrapper that can be resolved externally.
- */
-export class CancellablePromise {
-  /** The internal promise */
-  readonly promise: Promise<void>;
-  /** Whether the promise is already resolved or not */
-  readonly completed: boolean;
-  /** Resolves the promise */
-  complete(): void;
-}
-
-/**
- * Returns a function that invokes the wrapped function once.
- */
-export function runOnce<Args extends unknown[], Return>(
-  fn: ( ...args: Args ) => Return
-): ( ...args: Args ) => Return;

package/src/utils/index.js

@@ -1 +0,0 @@
-export * from './utils.js';