@outputai/core 0.8.2-next.4b5c049.0 → 0.8.2-next.57bc8d6.0

package/src/interface/step.js

@@ -1,6 +1,5 @@
 import { StepValidator } from './validations/index.js';
-import { setMetadata } from '#internal_utils/component';
-import { ComponentType } from '#consts';
+import { createStep } from '#helpers/component';
 
 /**
  * Create a new step (activity flavor) and return a wrapper function around its fn handler
@@ -9,13 +8,17 @@ export function step( { name, description, inputSchema, outputSchema, fn, option
   StepValidator.validateDefinition( { name, description, inputSchema, outputSchema, fn, options } );
   const validator = new StepValidator( { name, inputSchema, outputSchema } );
 
-  const wrapper = async input => {
-    validator.validateInput( input );
-    const output = await fn( input );
-    validator.validateOutput( output );
-    return output;
-  };
-
-  setMetadata( wrapper, { name, description, inputSchema, outputSchema, type: ComponentType.STEP, options } );
-  return wrapper;
-};
+  return createStep( {
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    options,
+    handler: async input => {
+      validator.validateInput( input );
+      const output = await fn( input );
+      validator.validateOutput( output );
+      return output;
+    }
+  } );
+}

package/src/interface/step.spec.js

@@ -1,11 +1,11 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ValidationError } from '#errors';
-import { ComponentType } from '#consts';
 
 const validateDefinitionMock = vi.hoisted( () => vi.fn() );
 const validateInputMock = vi.hoisted( () => vi.fn() );
 const validateOutputMock = vi.hoisted( () => vi.fn() );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+const createStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
 vi.mock( './validations/index.js', () => {
   class StepValidator {
@@ -23,12 +23,16 @@ vi.mock( './validations/index.js', () => {
   return { StepValidator };
 } );
 
+vi.mock( '#helpers/component', () => ( {
+  createStep: createStepMock
+} ) );
+
 describe( 'step()', () => {
   beforeEach( () => {
     vi.clearAllMocks();
   } );
 
-  it( 'validates the definition, creates a runtime validator, and attaches metadata', async () => {
+  it( 'validates the definition, creates a runtime validator, and creates a step component', async () => {
     const { step } = await import( './step.js' );
     const inputSchema = { safeParse: vi.fn() };
     const outputSchema = { safeParse: vi.fn() };
@@ -58,15 +62,15 @@ describe( 'step()', () => {
       outputSchema
     } );
 
-    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wrapper );
-    expect( wrapper[metadataSymbol] ).toEqual( {
+    expect( createStepMock ).toHaveBeenCalledWith( {
       name: 'test_step',
       description: 'Test step',
       inputSchema,
       outputSchema,
-      type: ComponentType.STEP,
-      options
+      options,
+      handler: expect.any( Function )
     } );
+    expect( wrapper ).toBe( createStepMock.mock.calls[0][0].handler );
   } );
 
   it( 'validates input and output around the step function', async () => {

package/src/interface/webhook.d.ts

@@ -1,10 +1,29 @@
-import type { SerializedFetchResponse } from '../utils/index.d.ts';
-
 /**
  * Allowed HTTP methods for request helpers.
  */
 export type HttpMethod = 'HEAD' | 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
 
+/** 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 an arrayBuffer converted to base64 */
+  body: object | string
+};
+
 /**
  * Send an POST HTTP request to a URL, optionally with a payload, then wait for a webhook response.
  *

package/src/interface/workflow.d.ts

@@ -133,7 +133,7 @@ export type WorkflowFunction<
 > = InputSchema extends AnyZodSchema ?
   ( input: z.infer<InputSchema>, context: WorkflowContext<InputSchema, OutputSchema> ) =>
   Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
-  ( input?: undefined | null, context: WorkflowContext<InputSchema, OutputSchema> ) =>
+  ( input: undefined | null, context: WorkflowContext<InputSchema, OutputSchema> ) =>
   Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
 
 /**
@@ -149,7 +149,7 @@ export type WorkflowFunction<
  * @param options - Additional options for the invocation.
  * @returns A value matching the schema defined by `outputSchema`.
  */
-export type WorkflowFunctionWrapper<WorkflowFunction> =
+export type WorkflowFunctionWrapper<WorkflowFunction extends ( ...args: any ) => any> = // eslint-disable-line @typescript-eslint/no-explicit-any
   [Parameters<WorkflowFunction>[0]] extends [undefined | null] ?
     ( input?: undefined | null, options?: WorkflowInvocationOptions ) =>
     ReturnType<WorkflowFunction> :

package/src/interface/workflow.js

@@ -1,11 +1,12 @@
 // 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, toUrlSafeBase64 } from '#utils';
-import { WorkflowContext } from '#internal_utils/workflow_context';
-import { setMetadata } from '#internal_utils/component';
-import { TraceInfo } from '#internal_utils/trace_info';
+import { toUrlSafeBase64 } from '#helpers/string';
+import { WorkflowContext } from '#helpers/workflow_context';
+import { TraceInfo } from '#helpers/trace_info';
+import { deepMerge } from '#helpers/object';
 import { defaultOptions } from './workflow_activity_options.js';
+import { createWorkflow } from '#helpers/component';
 import {
   ACTIVITY_WRAPPER_VERSION_FIELD,
   ACTIVITY_GET_TRACE_DESTINATIONS,
@@ -35,84 +36,89 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
   const { disableTrace, activityOptions } = deepMerge( defaultOptions, options );
   const validator = new WorkflowValidator( { name, inputSchema, outputSchema } );
 
-  const wrapper = async ( input, extra = {} ) => {
-    validator.validateInvocationOptions( extra );
-
-    // this returns a plain function, for example, in unit tests
-    if ( !inWorkflowContext() ) {
-      validator.validateInput( input );
-      const output = await fn( input, deepMerge( WorkflowContext.build(), extra?.context ) );
-      validator.validateOutput( output );
-      return output;
-    }
+  return createWorkflow( {
+    name,
+    description,
+    inputSchema,
+    outputSchema,
+    options,
+    aliases,
+    handler: async ( input, extra = {} ) => {
+      validator.validateInvocationOptions( extra );
+
+      // this returns a plain function, for example, in unit tests
+      if ( !inWorkflowContext() ) {
+        validator.validateInput( input );
+        const output = await fn( input, deepMerge( WorkflowContext.build(), extra?.context ) );
+        validator.validateOutput( output );
+        return output;
+      }
 
-    const { workflowId, workflowType, memo, root } = workflowInfo();
-
-    // if the stack already includes this workflowId, means the workflow() function was called
-    // from within a running workflow, meaning it is suppose to start a child workflow
-    const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) :
-      checkChildFallback( { workflowType, aliases, name } );
-
-    if ( isChild ) {
-      const result = await executeChild( name, {
-        args: undefined === input ? [] : [ input ],
-        workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
-        parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
-        memo: {
-          ...memo, // Preserve memo and mix activityOptions, if provided
-          ...( extra?.activityOptions && {
-            activityOptions: deepMerge( memo?.activityOptions ?? {}, extra?.activityOptions )
-          } )
-        }
-      } );
-      return result.output;
-    }
+      const { workflowId, workflowType, memo, root } = workflowInfo();
+
+      // if the stack already includes this workflowId, means the workflow() function was called
+      // from within a running workflow, meaning it is suppose to start a child workflow
+      const isChild = Array.isArray( memo.stack ) ? memo.stack.includes( workflowId ) :
+        checkChildFallback( { workflowType, aliases, name } );
+
+      if ( isChild ) {
+        const result = await executeChild( name, {
+          args: undefined === input ? [] : [ input ],
+          workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
+          parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
+          memo: {
+            ...memo, // Preserve memo and mix activityOptions, if provided
+            ...( extra?.activityOptions && {
+              activityOptions: deepMerge( memo?.activityOptions ?? {}, extra?.activityOptions )
+            } )
+          }
+        } );
+        return result.output;
+      }
 
-    const isRoot = !root;
+      const isRoot = !root;
 
-    memo.stack = [ ...memo.stack ?? [], workflowId ];
-    // Parent options have prevalence on nested calls, child will be overwritten
-    memo.activityOptions = deepMerge( activityOptions, memo.activityOptions );
-    // Trace info is only added in the root workflow
-    if ( isRoot ) {
-      memo.traceInfo = TraceInfo.build( { disableTrace } );
-    }
+      memo.stack = [ ...memo.stack ?? [], workflowId ];
+      // Parent options have prevalence on nested calls, child will be overwritten
+      memo.activityOptions = deepMerge( activityOptions, memo.activityOptions );
+      // Trace info is only added in the root workflow
+      if ( isRoot ) {
+        memo.traceInfo = TraceInfo.build( { disableTrace } );
+      }
 
-    const steps = proxyActivities( memo.activityOptions );
-    const traceDest = isRoot && parseActivityOutput( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) );
-
-    try {
-      validator.validateInput( input );
-
-      // Creates an activity caller based on a prefix
-      const createCaller = prefix => async ( t, ...args ) => parseActivityOutput( await steps[`${prefix}#${t}`]( ...args ) );
-
-      // This are functions used by the AST to replace direct activity (step/evaluator) calls
-      const dispatchers = {
-        invokeStep: createCaller( name ),
-        invokeSharedStep: createCaller( SHARED_STEP_PREFIX ),
-        invokeEvaluator: createCaller( name ),
-        invokeSharedEvaluator: createCaller( SHARED_STEP_PREFIX )
-      };
-
-      // The workflow function execution with "this" set with the dispatchers
-      const output = await fn.call( dispatchers, input, WorkflowContext.build() );
-      validator.validateOutput( output );
-
-      return {
-        [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-        output,
-        ...( traceDest && { trace: { destinations: traceDest } } )
-      };
-    } catch ( error ) {
-      if ( isRoot && traceDest ) {
-        // Append the trace destinations so it is carried to interceptor
-        error[METADATA_ACCESS_SYMBOL] = { trace: { destinations: traceDest } };
+      const steps = proxyActivities( memo.activityOptions );
+      const traceDest = isRoot && parseActivityOutput( await steps[ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ) );
+
+      try {
+        validator.validateInput( input );
+
+        // Creates an activity caller based on a prefix
+        const createCaller = prefix => async ( t, ...args ) => parseActivityOutput( await steps[`${prefix}#${t}`]( ...args ) );
+
+        // This are functions used by the AST to replace direct activity (step/evaluator) calls
+        const dispatchers = {
+          invokeStep: createCaller( name ),
+          invokeSharedStep: createCaller( SHARED_STEP_PREFIX ),
+          invokeEvaluator: createCaller( name ),
+          invokeSharedEvaluator: createCaller( SHARED_STEP_PREFIX )
+        };
+
+        // The workflow function execution with "this" set with the dispatchers
+        const output = await fn.call( dispatchers, input, WorkflowContext.build() );
+        validator.validateOutput( output );
+
+        return {
+          [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
+          output,
+          ...( traceDest && { trace: { destinations: traceDest } } )
+        };
+      } catch ( error ) {
+        if ( isRoot && traceDest ) {
+          // Append the trace destinations so it is carried to interceptor
+          error[METADATA_ACCESS_SYMBOL] = { trace: { destinations: traceDest } };
+        }
+        throw error;
       }
-      throw error;
     }
-  };
-
-  setMetadata( wrapper, { name, description, inputSchema, outputSchema, aliases } );
-  return wrapper;
-};
+  } );
+}

package/src/interface/workflow.spec.js

@@ -19,6 +19,7 @@ const validateInputMock = vi.hoisted( () => vi.fn() );
 const validateOutputMock = vi.hoisted( () => vi.fn() );
 const validateInvocationOptionsMock = vi.hoisted( () => vi.fn() );
 const validatorConstructorMock = vi.hoisted( () => vi.fn() );
+const createWorkflowMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
 vi.mock( './validations/index.js', () => {
   class WorkflowValidator {
@@ -37,6 +38,10 @@ vi.mock( './validations/index.js', () => {
   return { WorkflowValidator };
 } );
 
+vi.mock( '#helpers/component', () => ( {
+  createWorkflow: createWorkflowMock
+} ) );
+
 vi.mock( '@temporalio/workflow', async importOriginal => {
   const actual = await importOriginal();
   return {
@@ -151,7 +156,7 @@ describe( 'workflow()', () => {
     expect( () => workflow( workflowDefinition( { name: 'invalid_name' } ) ) ).toThrow( error );
   } );
 
-  it( 'attaches workflow metadata to the wrapper', async () => {
+  it( 'creates a workflow component with definition metadata', async () => {
     const { workflow } = await import( './workflow.js' );
     const inputSchema = z.object( { value: z.string() } );
     const outputSchema = z.object( { ok: z.boolean() } );
@@ -165,14 +170,16 @@ describe( 'workflow()', () => {
       fn: async () => ( { ok: true } )
     } ) );
 
-    const [ metadataSymbol ] = Object.getOwnPropertySymbols( wf );
-    expect( wf[metadataSymbol] ).toEqual( {
+    expect( createWorkflowMock ).toHaveBeenCalledWith( {
       name: 'metadata_wf',
       description: 'Metadata workflow',
       inputSchema,
       outputSchema,
-      aliases: [ 'metadata_alias' ]
+      options: {},
+      aliases: [ 'metadata_alias' ],
+      handler: expect.any( Function )
     } );
+    expect( wf ).toBe( createWorkflowMock.mock.calls[0][0].handler );
   } );
 
   describe( 'outside Temporal workflow context', () => {

package/src/internal_activities/index.js

@@ -1,10 +1,10 @@
 import { FatalError } from '#errors';
 import { fetch } from 'undici';
-import { serializeFetchResponse, serializeBodyAndInferContentType } from '#utils';
-import { setMetadata } from '#internal_utils/component';
-import { ComponentType } from '#consts';
+import { serializeFetchResponse, serializeBodyAndInferContentType } from '#helpers/fetch';
 import { createChildLogger } from '#logger';
 import { getDestinations } from '#tracing';
+import { createInternalStep } from '#helpers/component';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 
 const log = createChildLogger( 'HttpClient' );
 
@@ -20,41 +20,42 @@ const log = createChildLogger( 'HttpClient' );
  * @returns {object} The serialized HTTP response
  * @throws {FatalError}
  */
-export const sendHttpRequest = async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
-  const args = {
-    method,
-    headers: new Headers( headers ?? {} ),
-    signal: AbortSignal.timeout( timeout )
-  };
+export const sendHttpRequest = createInternalStep( {
+  name: ACTIVITY_SEND_HTTP_REQUEST,
+  handler: async ( { url, method, payload = undefined, headers = undefined, timeout = 30_000 } ) => {
+    const args = {
+      method,
+      headers: new Headers( headers ?? {} ),
+      signal: AbortSignal.timeout( timeout )
+    };
 
-  const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
-  const hasBodyPayload = ![ undefined, null ].includes( payload );
-  if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
-    const { body, contentType } = serializeBodyAndInferContentType( payload );
-    if ( contentType && !args.headers.has( 'content-type' ) ) {
-      args.headers.set( 'Content-Type', contentType );
-    }
-    Object.assign( args, { body } );
-  };
-
-  const response = await ( async () => {
-    try {
-      return await fetch( url, args );
-    } catch ( e ) {
-      throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
-    }
-  } )();
+    const methodsWithBody = [ 'DELETE', 'PATCH', 'POST', 'PUT', 'OPTIONS' ];
+    const hasBodyPayload = ![ undefined, null ].includes( payload );
+    if ( methodsWithBody.includes( method ) && hasBodyPayload ) {
+      const { body, contentType } = serializeBodyAndInferContentType( payload );
+      if ( contentType && !args.headers.has( 'content-type' ) ) {
+        args.headers.set( 'Content-Type', contentType );
+      }
+      Object.assign( args, { body } );
+    };
 
-  log.info( 'HTTP request completed', { url, method, status: response.status, statusText: response.statusText } );
+    const response = await ( async () => {
+      try {
+        return await fetch( url, args );
+      } catch ( e ) {
+        throw new FatalError( `${method} ${url} ${e.cause ?? e.message}` );
+      }
+    } )();
 
-  if ( !response.ok ) {
-    throw new FatalError( `${method} ${url} ${response.status}` );
-  }
+    log.info( 'HTTP request completed', { url, method, status: response.status, statusText: response.statusText } );
 
-  return serializeFetchResponse( response );
-};
+    if ( !response.ok ) {
+      throw new FatalError( `${method} ${url} ${response.status}` );
+    }
 
-setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
+    return serializeFetchResponse( response );
+  }
+} );
 
 /**
  * Invokes a trace method that resolves all trace output paths based on the traceInfo
@@ -62,6 +63,7 @@ setMetadata( sendHttpRequest, { type: ComponentType.INTERNAL_STEP } );
  * @param {object} traceInfo
  * @returns {object} Information about enabled destinations
  */
-export const getTraceDestinations = traceInfo => getDestinations( traceInfo );
-
-setMetadata( getTraceDestinations, { type: ComponentType.INTERNAL_STEP } );
+export const getTraceDestinations = createInternalStep( {
+  name: ACTIVITY_GET_TRACE_DESTINATIONS,
+  handler: traceInfo => getDestinations( traceInfo )
+} );

package/src/internal_activities/index.spec.js

@@ -1,10 +1,12 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MockAgent, setGlobalDispatcher } from 'undici';
 import { FatalError } from '#errors';
-import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
+import { ACTIVITY_GET_TRACE_DESTINATIONS, ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
+import { serializeBodyAndInferContentType, serializeFetchResponse } from '#helpers/fetch';
 import { getTraceDestinations, sendHttpRequest } from './index.js';
 
 const getDestinationsMock = vi.hoisted( () => vi.fn() );
+const createInternalStepMock = vi.hoisted( () => vi.fn( ( { handler } ) => handler ) );
 
 vi.mock( '#tracing', () => ( {
   getDestinations: getDestinationsMock
@@ -15,9 +17,15 @@ vi.mock( '#logger', () => {
   return { createChildLogger: vi.fn( () => log ) };
 } );
 
-vi.mock( '#utils', () => ( {
-  setMetadata: vi.fn(),
-  isStringboolTrue: vi.fn( () => false ),
+vi.mock( '#helpers/component', () => ( {
+  createInternalStep: createInternalStepMock
+} ) );
+
+vi.mock( '#helpers/string', () => ( {
+  isStringboolTrue: vi.fn( () => false )
+} ) );
+
+vi.mock( '#helpers/fetch', () => ( {
   serializeBodyAndInferContentType: vi.fn(),
   serializeFetchResponse: vi.fn()
 } ) );
@@ -30,6 +38,21 @@ setGlobalDispatcher( mockAgent );
 const url = 'https://growthx.ai';
 const method = 'GET';
 
+describe( 'internal_activities component registration', () => {
+  it( 'creates internal step components for exported activities', () => {
+    expect( createInternalStepMock ).toHaveBeenNthCalledWith( 1, {
+      name: ACTIVITY_SEND_HTTP_REQUEST,
+      handler: expect.any( Function )
+    } );
+    expect( createInternalStepMock ).toHaveBeenNthCalledWith( 2, {
+      name: ACTIVITY_GET_TRACE_DESTINATIONS,
+      handler: expect.any( Function )
+    } );
+    expect( sendHttpRequest ).toBe( createInternalStepMock.mock.calls[0][0].handler );
+    expect( getTraceDestinations ).toBe( createInternalStepMock.mock.calls[1][0].handler );
+  } );
+} );
+
 describe( 'internal_activities/sendHttpRequest', () => {
   beforeEach( async () => {
     vi.restoreAllMocks();

package/src/logger/development.js

@@ -1,5 +1,5 @@
 import { format, transports } from 'winston';
-import { isPlainObject, shuffleArray } from '#utils';
+import { shuffleArray, isPlainObject } from '#helpers/object';
 
 /** Available colors enum */
 const Color = {

package/src/logger/development.spec.js

@@ -3,7 +3,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
 const LEVEL = Symbol.for( 'level' );
 const MESSAGE = Symbol.for( 'message' );
 
-vi.mock( '#utils', () => ( {
+vi.mock( '#helpers/object', () => ( {
   isPlainObject: v => Object.prototype.toString.call( v ) === '[object Object]',
   shuffleArray: v => v
 } ) );

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

@@ -9,3 +9,4 @@
  */
 export * from './component_metadata.js';
 export * from './path.js';
+export * from './objects.js';

package/src/sdk/helpers/index.js

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

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

@@ -0,0 +1,51 @@
+/** Tools to manipulate JS Objects */
+export declare const Objects: {
+  /**
+   * 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
+   */
+  clone( object: object ): object,
+
+  /**
+   * 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.
+   */
+  isPlainObject( object: unknown ): boolean,
+
+  /**
+   * 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.
+   */
+  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.
+   */
+  deepMergeWithResolver( a: object, b: object | null | undefined, resolver: ( a: unknown, b: unknown ) => unknown ): object
+};

package/src/sdk/helpers/objects.js

@@ -0,0 +1,8 @@
+import { clone, deepMerge, deepMergeWithResolver, isPlainObject } from '#helpers/object';
+
+export const Objects = {
+  clone,
+  deepMerge,
+  deepMergeWithResolver,
+  isPlainObject
+};

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

@@ -0,0 +1,16 @@
+import { describe, expect, it } from 'vitest';
+import { Objects } from './objects.js';
+import { Objects as ObjectsFromIndex } from './index.js';
+import { clone, deepMerge, deepMergeWithResolver, isPlainObject } from '#helpers/object';
+
+describe( 'Objects', () => {
+  it( 'exports the same functions from the object helper module', () => {
+    expect( Objects ).toBe( ObjectsFromIndex );
+    expect( Objects ).toEqual( {
+      clone,
+      deepMerge,
+      deepMergeWithResolver,
+      isPlainObject
+    } );
+  } );
+} );

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

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

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

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