@outputai/core 0.7.1-next.bd6bd49.0 → 0.7.1-next.c005dac.0

package/src/interface/validations/static.spec.js

@@ -1,397 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { z } from 'zod';
-import {
-  validateStep,
-  validateWorkflow,
-  validateRequestPayload,
-  validateEvaluator,
-  validateExecuteInParallel,
-  StaticValidationError
-} from './static.js';
-
-const validArgs = Object.freeze( {
-  name: 'valid_name',
-  description: 'desc',
-  inputSchema: z.object( {} ),
-  outputSchema: z.object( {} ),
-  fn: () => {}
-} );
-
-describe( 'interface/validator', () => {
-  describe( 'validateStep', () => {
-    it( 'passes for valid args', () => {
-      expect( () => validateStep( { ...validArgs } ) ).not.toThrow();
-    } );
-
-    it( 'rejects missing name', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected string, received undefined\n  → at name' );
-      expect( () => validateStep( { ...validArgs, name: undefined } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-string name', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected string, received number\n  → at name' );
-      expect( () => validateStep( { ...validArgs, name: 123 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects invalid name pattern', () => {
-      const error = new StaticValidationError( '✖ Invalid string: must match pattern /^[a-z_][a-z0-9_]*$/i\n  → at name' );
-      expect( () => validateStep( { ...validArgs, name: '-bad' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-string description', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected string, received number\n  → at description' );
-      expect( () => validateStep( { ...validArgs, description: 10 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-Zod inputSchema', () => {
-      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at inputSchema' );
-      expect( () => validateStep( { ...validArgs, inputSchema: 'not-a-zod-schema' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects JSON Schema inputSchema', () => {
-      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at inputSchema' );
-      expect( () => validateStep( { ...validArgs, inputSchema: { type: 'object' } } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-Zod outputSchema', () => {
-      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at outputSchema' );
-      expect( () => validateStep( { ...validArgs, outputSchema: 10 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects JSON Schema outputSchema', () => {
-      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at outputSchema' );
-      expect( () => validateStep( { ...validArgs, outputSchema: { type: 'string' } } ) ).toThrow( error );
-    } );
-
-    it( 'rejects missing fn', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected function, received undefined\n  → at fn' );
-      expect( () => validateStep( { ...validArgs, fn: undefined } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-function fn', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected function, received string\n  → at fn' );
-      expect( () => validateStep( { ...validArgs, fn: 'not-fn' } ) ).toThrow( error );
-    } );
-
-    it( 'passes with options.activityOptions.retry (second-level options)', () => {
-      const args = {
-        ...validArgs,
-        options: {
-          activityOptions: {
-            retry: {
-              initialInterval: '1s',
-              backoffCoefficient: 2,
-              maximumInterval: '10s',
-              maximumAttempts: 3,
-              nonRetryableErrorTypes: [ 'SomeError' ]
-            }
-          }
-        }
-      };
-      expect( () => validateStep( args ) ).not.toThrow();
-    } );
-
-    it( 'passes with options.activityOptions.activityId as string', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityOptions: { activityId: 'act-123' } } } ) ).not.toThrow();
-    } );
-
-    it( 'rejects non-string options.activityOptions.activityId', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityOptions: { activityId: 123 } } } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'passes with valid options.activityOptions.cancellationType values', () => {
-      for ( const v of [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ) {
-        expect( () => validateStep( { ...validArgs, options: { activityOptions: { cancellationType: v } } } ) ).not.toThrow();
-      }
-    } );
-
-    it( 'rejects invalid options.activityOptions.cancellationType', () => {
-      const args = { ...validArgs, options: { activityOptions: { cancellationType: 'INVALID' } } };
-      expect( () => validateStep( args ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'accepts duration fields in options.activityOptions', () => {
-      const options = {
-        activityOptions: {
-          heartbeatTimeout: '1s',
-          scheduleToCloseTimeout: '2m',
-          scheduleToStartTimeout: '3m',
-          startToCloseTimeout: '4m'
-        }
-      };
-      expect( () => validateStep( { ...validArgs, options } ) ).not.toThrow();
-    } );
-
-    it( 'rejects invalid duration string in options.activityOptions.heartbeatTimeout', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityOptions: { heartbeatTimeout: '5x' } } } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'passes with options.activityOptions.summary string', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityOptions: { summary: 'brief' } } } ) ).not.toThrow();
-    } );
-
-    it( 'rejects non-string options.activityOptions.summary', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityOptions: { summary: 42 } } } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'passes with options.activityOptions.priority valid payload', () => {
-      const options = {
-        activityOptions: {
-          priority: {
-            fairnessKey: 'user-1',
-            fairnessWeight: 1.5,
-            priorityKey: 10
-          }
-        }
-      };
-      expect( () => validateStep( { ...validArgs, options } ) ).not.toThrow();
-    } );
-
-    it( 'rejects invalid options.activityOptions.priority values', () => {
-      const options = { activityOptions: { priority: { fairnessWeight: 0, priorityKey: 0 } } };
-      expect( () => validateStep( { ...validArgs, options } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'rejects invalid options.activityOptions.retry values', () => {
-      const options = { activityOptions: { retry: { backoffCoefficient: 0.5, maximumAttempts: 0, nonRetryableErrorTypes: [ 1 ] } } };
-      expect( () => validateStep( { ...validArgs, options } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'rejects unknown keys inside options.activityOptions due to strictObject', () => {
-      expect( () => validateStep( { ...validArgs, options: { activityOptions: { unknownKey: true } } } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'rejects unknown top-level keys due to strictObject', () => {
-      expect( () => validateStep( { ...validArgs, extra: 123 } ) ).toThrow( StaticValidationError );
-    } );
-  } );
-
-  describe( 'validateWorkflow', () => {
-    it( 'passes for valid args', () => {
-      expect( () => validateWorkflow( { ...validArgs } ) ).not.toThrow();
-    } );
-
-    it( 'passes with options.disableTrace true', () => {
-      expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: true } } ) ).not.toThrow();
-    } );
-
-    it( 'passes with options.disableTrace false', () => {
-      expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: false } } ) ).not.toThrow();
-    } );
-
-    it( 'passes with options.activityOptions and options.disableTrace', () => {
-      expect( () => validateWorkflow( {
-        ...validArgs,
-        options: { activityOptions: { activityId: 'wf-1' }, disableTrace: true }
-      } ) ).not.toThrow();
-    } );
-
-    it( 'rejects non-boolean options.disableTrace', () => {
-      expect( () => validateWorkflow( { ...validArgs, options: { disableTrace: 'yes' } } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'passes with valid aliases array', () => {
-      expect( () => validateWorkflow( { ...validArgs, aliases: [ 'old_name', 'legacy_v1' ] } ) ).not.toThrow();
-    } );
-
-    it( 'passes with empty aliases array', () => {
-      expect( () => validateWorkflow( { ...validArgs, aliases: [] } ) ).not.toThrow();
-    } );
-
-    it( 'passes without aliases (optional)', () => {
-      expect( () => validateWorkflow( { ...validArgs } ) ).not.toThrow();
-    } );
-
-    it( 'rejects aliases with invalid name pattern', () => {
-      expect( () => validateWorkflow( { ...validArgs, aliases: [ '-bad' ] } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'rejects non-array aliases', () => {
-      expect( () => validateWorkflow( { ...validArgs, aliases: 'not_array' } ) ).toThrow( StaticValidationError );
-    } );
-  } );
-
-  describe( 'aliases rejected on steps and evaluators', () => {
-    it( 'validateStep rejects aliases due to strictObject', () => {
-      expect( () => validateStep( { ...validArgs, aliases: [ 'alias' ] } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'validateEvaluator rejects aliases due to strictObject', () => {
-      const { outputSchema, ...evalArgs } = validArgs;
-      expect( () => validateEvaluator( { ...evalArgs, aliases: [ 'alias' ] } ) ).toThrow( StaticValidationError );
-    } );
-  } );
-
-  describe( 'validateEvaluator', () => {
-    const base = Object.freeze( {
-      name: 'valid_name',
-      description: 'desc',
-      inputSchema: z.object( {} ),
-      fn: () => {}
-    } );
-
-    it( 'passes for valid args (no outputSchema)', () => {
-      expect( () => validateEvaluator( { ...base } ) ).not.toThrow();
-    } );
-
-    it( 'rejects invalid name pattern', () => {
-      const error = new StaticValidationError( '✖ Invalid string: must match pattern /^[a-z_][a-z0-9_]*$/i\n  → at name' );
-      expect( () => validateEvaluator( { ...base, name: '-bad' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-Zod inputSchema', () => {
-      const error = new StaticValidationError( '✖ Schema must be a Zod schema\n  → at inputSchema' );
-      expect( () => validateEvaluator( { ...base, inputSchema: 'not-a-zod-schema' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects missing fn', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected function, received undefined\n  → at fn' );
-      expect( () => validateEvaluator( { ...base, fn: undefined } ) ).toThrow( error );
-    } );
-  } );
-
-  describe( 'validate request', () => {
-    it( 'passes with valid http url', () => {
-      expect( () => validateRequestPayload( { url: 'http://example.com', method: 'GET' } ) ).not.toThrow();
-    } );
-
-    it( 'passes with valid https url', () => {
-      expect( () => validateRequestPayload( { url: 'https://example.com/path?q=1', method: 'GET' } ) ).not.toThrow();
-    } );
-
-    it( 'rejects missing url', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected string, received undefined\n  → at url' );
-      expect( () => validateRequestPayload( { method: 'GET' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects invalid scheme', () => {
-      const error = new StaticValidationError( '✖ Invalid URL\n  → at url' );
-      expect( () => validateRequestPayload( { url: 'ftp://example.com', method: 'GET' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects malformed url', () => {
-      const error = new StaticValidationError( '✖ Invalid URL\n  → at url' );
-      expect( () => validateRequestPayload( { url: 'http:////', method: 'GET' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects missing method', () => {
-      expect( () => validateRequestPayload( { url: 'https://example.com' } ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'passes with headers as string map', () => {
-      const request = {
-        url: 'https://example.com',
-        method: 'GET',
-        headers: { 'x-api-key': 'abc', accept: 'application/json' }
-      };
-      expect( () => validateRequestPayload( request ) ).not.toThrow();
-    } );
-
-    it( 'rejects non-object headers', () => {
-      const request = {
-        url: 'https://example.com',
-        method: 'GET',
-        headers: 5
-      };
-      expect( () => validateRequestPayload( request ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'rejects headers with non-string values', () => {
-      const request = {
-        url: 'https://example.com',
-        method: 'GET',
-        headers: { 'x-num': 123 }
-      };
-      expect( () => validateRequestPayload( request ) ).toThrow( StaticValidationError );
-    } );
-
-    it( 'passes with payload object', () => {
-      const request = {
-        url: 'https://example.com/api',
-        method: 'POST',
-        payload: { a: 1, b: 'two' }
-      };
-      expect( () => validateRequestPayload( request ) ).not.toThrow();
-    } );
-
-    it( 'passes with payload string', () => {
-      const request = {
-        url: 'https://example.com/upload',
-        method: 'POST',
-        payload: 'raw-body'
-      };
-      expect( () => validateRequestPayload( request ) ).not.toThrow();
-    } );
-  } );
-
-  describe( 'validateExecuteInParallel', () => {
-    const validArgs = Object.freeze( {
-      jobs: [ () => {}, () => {} ],
-      concurrency: 5
-    } );
-
-    it( 'passes for valid args', () => {
-      expect( () => validateExecuteInParallel( { ...validArgs } ) ).not.toThrow();
-    } );
-
-    it( 'rejects missing concurrency', () => {
-      const error = new StaticValidationError( '✖ Invalid input\n  → at concurrency' );
-      expect( () => validateExecuteInParallel( { jobs: validArgs.jobs } ) ).toThrow( error );
-    } );
-
-    it( 'passes with onJobCompleted callback', () => {
-      const args = {
-        ...validArgs,
-        onJobCompleted: () => {}
-      };
-      expect( () => validateExecuteInParallel( args ) ).not.toThrow();
-    } );
-
-    it( 'passes with concurrency 1', () => {
-      expect( () => validateExecuteInParallel( { ...validArgs, concurrency: 1 } ) ).not.toThrow();
-    } );
-
-    it( 'passes with concurrency Infinity', () => {
-      expect( () => validateExecuteInParallel( { ...validArgs, concurrency: Infinity } ) ).not.toThrow();
-    } );
-
-    it( 'rejects missing jobs', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected array, received undefined\n  → at jobs' );
-      expect( () => validateExecuteInParallel( { concurrency: 5 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-array jobs', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected array, received string\n  → at jobs' );
-      expect( () => validateExecuteInParallel( { jobs: 'not-array', concurrency: 5 } ) ).toThrow( error );
-    } );
-
-    it( 'passes with empty jobs array', () => {
-      expect( () => validateExecuteInParallel( { jobs: [], concurrency: 5 } ) ).not.toThrow();
-    } );
-
-    it( 'rejects jobs array with non-function', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected function, received string\n  → at jobs[1]' );
-      expect( () => validateExecuteInParallel( { jobs: [ () => {}, 'not-function' ], concurrency: 5 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-number concurrency', () => {
-      const error = new StaticValidationError( '✖ Invalid input\n  → at concurrency' );
-      expect( () => validateExecuteInParallel( { jobs: validArgs.jobs, concurrency: '5' } ) ).toThrow( error );
-    } );
-
-    it( 'rejects zero concurrency', () => {
-      const error = new StaticValidationError( '✖ Too small: expected number to be >=1\n  → at concurrency' );
-      expect( () => validateExecuteInParallel( { jobs: validArgs.jobs, concurrency: 0 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects negative concurrency', () => {
-      const error = new StaticValidationError( '✖ Too small: expected number to be >=1\n  → at concurrency' );
-      expect( () => validateExecuteInParallel( { ...validArgs, concurrency: -1 } ) ).toThrow( error );
-    } );
-
-    it( 'rejects non-function onJobCompleted', () => {
-      const error = new StaticValidationError( '✖ Invalid input: expected function, received string\n  → at onJobCompleted' );
-      expect( () => validateExecuteInParallel( { ...validArgs, onJobCompleted: 'not-function' } ) ).toThrow( error );
-    } );
-  } );
-} );

package/src/interface/workflow.replay_compatibility.spec.js

@@ -1,254 +0,0 @@
-import { ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL, WORKFLOW_WRAPPER_VERSION_FIELD } from '#consts';
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { z } from 'zod';
-
-const inWorkflowContextMock = vi.hoisted( () => vi.fn( () => true ) );
-const defineSignalMock = vi.hoisted( () => vi.fn( name => name ) );
-const setHandlerMock = vi.hoisted( () => vi.fn() );
-const traceDestinationsStepMock = vi.fn().mockResolvedValue( { local: '/tmp/trace' } );
-const executeChildMock = vi.fn().mockResolvedValue( undefined );
-const continueAsNewMock = vi.fn().mockResolvedValue( undefined );
-
-const createStepsProxy = ( stepSpy = vi.fn() ) =>
-  new Proxy( {}, {
-    get: ( _, prop ) => {
-      if ( prop === ACTIVITY_GET_TRACE_DESTINATIONS ) {
-        return traceDestinationsStepMock;
-      }
-      if ( typeof prop === 'string' && prop.includes( '#' ) ) {
-        return stepSpy;
-      }
-      return vi.fn();
-    }
-  } );
-
-const proxyActivitiesMock = vi.fn( () => createStepsProxy() );
-
-const workflowInfoReturn = {
-  workflowId: 'wf-test-123',
-  workflowType: 'test_wf',
-  memo: {},
-  startTime: new Date( '2025-01-01T00:00:00Z' ),
-  continueAsNewSuggested: false
-};
-const workflowInfoMock = vi.fn( () => ( { ...workflowInfoReturn } ) );
-
-vi.mock( '@temporalio/workflow', () => ( {
-  proxyActivities: ( ...args ) => proxyActivitiesMock( ...args ),
-  inWorkflowContext: inWorkflowContextMock,
-  executeChild: ( ...args ) => executeChildMock( ...args ),
-  workflowInfo: workflowInfoMock,
-  uuid4: () => '550e8400e29b41d4a716446655440000',
-  ParentClosePolicy: { TERMINATE: 'TERMINATE', ABANDON: 'ABANDON' },
-  ChildWorkflowFailure: class ChildWorkflowFailure extends Error {
-    constructor( message, cause ) {
-      super( message );
-      this.name = 'ChildWorkflowFailure';
-      this.cause = cause;
-    }
-  },
-  continueAsNew: continueAsNewMock,
-  defineSignal: ( ...args ) => defineSignalMock( ...args ),
-  setHandler: ( ...args ) => setHandlerMock( ...args )
-} ) );
-
-vi.mock( '#consts', async importOriginal => {
-  const actual = await importOriginal();
-  return {
-    ...actual,
-    SHARED_STEP_PREFIX: '__shared',
-    ACTIVITY_GET_TRACE_DESTINATIONS: '__internal#getTraceDestinations'
-  };
-} );
-
-describe( 'workflow() replay compatibility', () => {
-  beforeEach( () => {
-    vi.clearAllMocks();
-    inWorkflowContextMock.mockReturnValue( true );
-    defineSignalMock.mockImplementation( name => name );
-    workflowInfoReturn.memo = {};
-    workflowInfoMock.mockReturnValue( { ...workflowInfoReturn } );
-    proxyActivitiesMock.mockImplementation( () => createStepsProxy() );
-    traceDestinationsStepMock.mockResolvedValue( { local: '/tmp/trace' } );
-  } );
-
-  it( 'preserves old plain trace destination activity results', async () => {
-    const { workflow } = await import( './workflow.js' );
-
-    const wf = workflow( {
-      name: 'root_wf',
-      description: 'Root',
-      inputSchema: z.object( {} ),
-      outputSchema: z.object( { v: z.number() } ),
-      fn: async () => ( { v: 42 } )
-    } );
-
-    const result = await wf( {} );
-    expect( result ).toEqual( {
-      [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-      output: { v: 42 },
-      trace: { destinations: { local: '/tmp/trace' } },
-      aggregations: null
-    } );
-  } );
-
-  it( 'converts old add_attribute signals into aggregations', async () => {
-    const { workflow } = await import( './workflow.js' );
-    const { Attribute } = await import( '#trace_attribute' );
-    const handlers = { addAttribute: () => {} };
-    setHandlerMock.mockImplementation( ( signalName, handler ) => {
-      if ( signalName === 'add_attribute' ) {
-        handlers.addAttribute = handler;
-      }
-    } );
-
-    const httpRequest = {
-      type: Attribute.HTTPRequestCount.TYPE,
-      url: 'https://api.example.test/items',
-      requestId: 'req-1'
-    };
-    const httpCost = {
-      type: Attribute.HTTPRequestCost.TYPE,
-      url: 'https://api.example.test/items',
-      requestId: 'req-1',
-      total: 2.5
-    };
-    const llmUsage = {
-      type: Attribute.LLMUsage.TYPE,
-      modelId: 'gpt-4o',
-      total: 0.25,
-      usage: [
-        { type: 'input', ppm: 5, amount: 20_000, total: 0.1 },
-        { type: 'output', ppm: 30, amount: 5_000, total: 0.15 }
-      ],
-      tokensUsed: 25_000
-    };
-
-    const wf = workflow( {
-      name: 'attr_wf',
-      description: 'Attributes',
-      inputSchema: z.object( {} ),
-      outputSchema: z.object( { ok: z.boolean() } ),
-      fn: async () => {
-        handlers.addAttribute( httpRequest );
-        handlers.addAttribute( httpCost );
-        handlers.addAttribute( llmUsage );
-        return { ok: true };
-      }
-    } );
-
-    const result = await wf( {} );
-    expect( result ).not.toHaveProperty( 'attributes' );
-    expect( result.aggregations ).toEqual( {
-      cost: { total: 2.75 },
-      tokens: {
-        total: 25_000,
-        input: 20_000,
-        output: 5_000
-      },
-      httpRequests: { total: 1 }
-    } );
-  } );
-
-  it( 'preserves old plain activity results from steps', async () => {
-    const stepSpy = vi.fn().mockResolvedValue( { legacy: true } );
-    proxyActivitiesMock.mockImplementation( () => createStepsProxy( stepSpy ) );
-    const { workflow } = await import( './workflow.js' );
-
-    const wf = workflow( {
-      name: 'legacy_step_wf',
-      description: 'Legacy step result',
-      inputSchema: z.object( {} ),
-      outputSchema: z.object( { legacy: z.boolean() } ),
-      async fn() {
-        return this.invokeStep( 'myStep', { foo: 1 } );
-      }
-    } );
-
-    const result = await wf( {} );
-    expect( result.output ).toEqual( { legacy: true } );
-    expect( result.aggregations ).toEqual( null );
-  } );
-
-  it( 'converts old child workflow attributes into parent aggregations', async () => {
-    const { workflow } = await import( './workflow.js' );
-    const { Attribute } = await import( '#trace_attribute' );
-    const childAttribute = {
-      type: Attribute.LLMUsage.TYPE,
-      modelId: 'gpt-4o',
-      total: 0.4,
-      tokensUsed: 20,
-      usage: [
-        { type: 'input', ppm: 10, amount: 20, total: 0.4 }
-      ]
-    };
-    executeChildMock.mockResolvedValueOnce( {
-      output: { child: 'ok' },
-      attributes: [ childAttribute ]
-    } );
-
-    const wf = workflow( {
-      name: 'merge_child_wf',
-      description: 'Merge child attributes',
-      inputSchema: z.object( {} ),
-      outputSchema: z.object( { child: z.string() } ),
-      async fn() {
-        return this.startWorkflow( 'child_wf', { id: 1 } );
-      }
-    } );
-
-    const result = await wf( {} );
-    expect( result ).toEqual( {
-      [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-      output: { child: 'ok' },
-      trace: { destinations: { local: '/tmp/trace' } },
-      aggregations: {
-        cost: { total: 0.4 },
-        tokens: {
-          total: 20,
-          input: 20
-        },
-        httpRequests: { total: 0 }
-      }
-    } );
-  } );
-
-  it( 'converts old child workflow error attributes into parent error metadata aggregations', async () => {
-    const { workflow } = await import( './workflow.js' );
-    const { ChildWorkflowFailure } = await import( '@temporalio/workflow' );
-    const { Attribute } = await import( '#trace_attribute' );
-    const childAttribute = {
-      type: Attribute.HTTPRequestCost.TYPE,
-      url: 'https://api.example.test',
-      requestId: 'req-child',
-      total: 2
-    };
-    const childError = new ChildWorkflowFailure( 'child failed', {
-      message: 'Child workflow execution failed',
-      details: [ { attributes: [ childAttribute ] } ]
-    } );
-    executeChildMock.mockRejectedValueOnce( childError );
-
-    const wf = workflow( {
-      name: 'child_error_wf',
-      description: 'Child error attributes',
-      inputSchema: z.object( {} ),
-      outputSchema: z.object( {} ),
-      async fn() {
-        await this.startWorkflow( 'child_wf', { id: 1 } );
-        return {};
-      }
-    } );
-
-    await expect( wf( {} ) ).rejects.toThrow( 'child failed' );
-    expect( childError[METADATA_ACCESS_SYMBOL] ).toEqual( {
-      [WORKFLOW_WRAPPER_VERSION_FIELD]: 1,
-      trace: { destinations: { local: '/tmp/trace' } },
-      aggregations: {
-        cost: { total: 2 },
-        tokens: { total: 0 },
-        httpRequests: { total: 0 }
-      }
-    } );
-  } );
-} );