@outputai/core 0.8.2-next.2da7213.0 → 0.8.2-next.ad732b1.0

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/global_functions.js

@@ -0,0 +1,20 @@
+import { messageBus } from '#bus';
+import { ACTIVITY_LOGGER_SYMBOL, BusEventType } from '#consts';
+import { activityInfo as activityInfoFn } from '@temporalio/activity';
+
+const setFunction = ( key, fn ) => Object.defineProperty( globalThis, key, {
+  value: fn,
+  enumerable: false,
+  configurable: false,
+  writable: false
+} );
+
+/**
+ * Sets global functions on globalThis
+ */
+export const bindGlobalFunctions = () => {
+  /** Defines the activity logger function, accessible in activity context via logger interface */
+  setFunction( 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,6 +17,7 @@ import { messageBus } from '#bus';
 import { BusEventType } from '#consts';
 import { setupTelemetry } from './telemetry.js';
 import { TemporalConnectionMonitor } from './connection_monitor.js';
+import { bindGlobalFunctions } from './global_functions.js';
 import { runOnce } from '#utils';
 
 import './log_hooks.js';
@@ -76,6 +77,8 @@ const execute = async () => {
     log.info( 'Using gRPC proxy', { targetHost: grpcProxy } );
   }
 
+  bindGlobalFunctions();
+
   state.connection = await NativeConnection.connect( { address, tls: Boolean( apiKey ), apiKey, proxy } );
 
   log.info( 'Creating connection monitor...' );

package/src/worker/index.spec.js

@@ -2,6 +2,7 @@ import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
 const {
   catalogJobInstance,
+  bindGlobalFunctionsMock,
   configValues,
   connectionMonitorInstance,
   createCatalogMock,
@@ -98,6 +99,7 @@ const {
 
   return {
     catalogJobInstance,
+    bindGlobalFunctionsMock: vi.fn(),
     configValues,
     connectionMonitorInstance,
     createCatalogMock: vi.fn().mockReturnValue( { workflows: [], activities: {} } ),
@@ -145,6 +147,7 @@ vi.mock( './interceptors/index.js', () => ( { initInterceptors: initInterceptors
 vi.mock( './proxy.js', () => ( { bootstrapFetchProxy: vi.fn() } ) );
 vi.mock( './telemetry.js', () => ( { setupTelemetry: setupTelemetryMock } ) );
 vi.mock( './interruption.js', () => ( { setupInterruptionHandler: setupInterruptionHandlerMock } ) );
+vi.mock( './global_functions.js', () => ( { bindGlobalFunctions: bindGlobalFunctionsMock } ) );
 vi.mock( './connection_monitor.js', () => ( {
   TemporalConnectionMonitor: vi.fn( function () {
     return connectionMonitorInstance;
@@ -222,6 +225,10 @@ describe( 'worker/index', () => {
       apiKey: undefined,
       proxy: undefined
     } );
+    expect( bindGlobalFunctionsMock ).toHaveBeenCalledTimes( 1 );
+    expect( bindGlobalFunctionsMock.mock.invocationCallOrder[0] ).toBeLessThan(
+      NativeConnection.connect.mock.invocationCallOrder[0]
+    );
     expect( TemporalConnectionMonitor ).toHaveBeenCalledWith( mockConnection );
     expect( CatalogJob ).toHaveBeenCalledWith( {
       connection: mockConnection,

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/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 )
+  } )
+);