@outputai/core 0.10.1-next.fc0a41f.0 → 0.11.0

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

@@ -53,10 +53,12 @@ describe( 'interface validators', () => {
     it( 'validates workflow definitions, input, output, and invocation options', () => {
       expect( () => WorkflowValidator.validateDefinition( workflowArgs ) ).not.toThrow();
       const validator = new WorkflowValidator( workflowArgs );
+      const input = { value: 'ok' };
+      const output = { result: 'ok' };
 
-      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateOutput( { result: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateInvocationOptions( {
+      expect( validator.parseInput( input ) ).toEqual( input );
+      expect( validator.parseOutput( output ) ).toEqual( output );
+      expect( () => validator.parseInvocationOptions( {
         detached: true,
         activityOptions: { retry: { maximumAttempts: 1 } },
         context: { info: { workflowId: 'test-workflow' } }
@@ -71,10 +73,10 @@ describe( 'interface validators', () => {
 
       const validator = new WorkflowValidator( workflowArgs );
 
-      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( ValidationError );
-      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( /Workflow "valid_workflow" input validation failed/ );
-      expect( () => validator.validateOutput( { result: 1 } ) ).toThrow( /Workflow "valid_workflow" output validation failed/ );
-      expect( () => validator.validateInvocationOptions( {
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( ValidationError );
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Workflow "valid_workflow" input validation failed/ );
+      expect( () => validator.parseOutput( { result: 1 } ) ).toThrow( /Workflow "valid_workflow" output validation failed/ );
+      expect( () => validator.parseInvocationOptions( {
         options: { activityOptions: { retry: { maximumAttempts: 1 } } }
       } ) ).toThrow( /Workflow "valid_workflow" invocation options validation failed/ );
     } );
@@ -84,9 +86,11 @@ describe( 'interface validators', () => {
         name: 'schema_less_workflow',
         fn
       } );
+      const input = { anything: true };
+      const output = { anything: true };
 
-      expect( () => validator.validateInput( { anything: true } ) ).not.toThrow();
-      expect( () => validator.validateOutput( { anything: true } ) ).not.toThrow();
+      expect( validator.parseInput( input ) ).toBe( input );
+      expect( validator.parseOutput( output ) ).toBe( output );
     } );
   } );
 
@@ -94,9 +98,11 @@ describe( 'interface validators', () => {
     it( 'validates step definitions, input, and output', () => {
       expect( () => StepValidator.validateDefinition( stepArgs ) ).not.toThrow();
       const validator = new StepValidator( stepArgs );
+      const input = { value: 'ok' };
+      const output = { result: 'ok' };
 
-      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateOutput( { result: 'ok' } ) ).not.toThrow();
+      expect( validator.parseInput( input ) ).toEqual( input );
+      expect( validator.parseOutput( output ) ).toEqual( output );
     } );
 
     it( 'throws ValidationError with useful prefixes for invalid step data', () => {
@@ -106,8 +112,8 @@ describe( 'interface validators', () => {
 
       const validator = new StepValidator( stepArgs );
 
-      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( /Step "valid_step" input validation failed/ );
-      expect( () => validator.validateOutput( { result: 1 } ) ).toThrow( /Step "valid_step" output validation failed/ );
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Step "valid_step" input validation failed/ );
+      expect( () => validator.parseOutput( { result: 1 } ) ).toThrow( /Step "valid_step" output validation failed/ );
     } );
   } );
 
@@ -115,9 +121,11 @@ describe( 'interface validators', () => {
     it( 'validates evaluator definitions, input, and EvaluationResult output', () => {
       expect( () => EvaluatorValidator.validateDefinition( evaluatorArgs ) ).not.toThrow();
       const validator = new EvaluatorValidator( evaluatorArgs );
+      const input = { value: 'ok' };
+      const output = new EvaluationResult( { value: 'pass', confidence: 1 } );
 
-      expect( () => validator.validateInput( { value: 'ok' } ) ).not.toThrow();
-      expect( () => validator.validateOutput( new EvaluationResult( { value: 'pass', confidence: 1 } ) ) ).not.toThrow();
+      expect( validator.parseInput( input ) ).toEqual( input );
+      expect( validator.parseOutput( output ) ).toEqual( output );
     } );
 
     it( 'throws ValidationError for output schemas and invalid evaluator output', () => {
@@ -128,8 +136,8 @@ describe( 'interface validators', () => {
 
       const validator = new EvaluatorValidator( evaluatorArgs );
 
-      expect( () => validator.validateInput( { value: 1 } ) ).toThrow( /Evaluator "valid_evaluator" input validation failed/ );
-      expect( () => validator.validateOutput( { value: 'pass', confidence: 1 } ) ).toThrow(
+      expect( () => validator.parseInput( { value: 1 } ) ).toThrow( /Evaluator "valid_evaluator" input validation failed/ );
+      expect( () => validator.parseOutput( { value: 'pass', confidence: 1 } ) ).toThrow(
         /Evaluator "valid_evaluator" output validation failed/
       );
     } );

package/src/interface/webhook.js

@@ -19,7 +19,7 @@ import { validateRequestPayload } from './validations/index.js';
  */
 export async function sendHttpRequest( { url, method = 'GET', payload = undefined, headers = undefined, responseOptions = {} } ) {
   validateRequestPayload( { method, url, payload, headers, responseOptions } );
-  const res = await proxyActivities( {
+  return proxyActivities( {
     startToCloseTimeout: '3m',
     retry: {
       initialInterval: '15s',
@@ -27,7 +27,6 @@ export async function sendHttpRequest( { url, method = 'GET', payload = undefine
       nonRetryableErrorTypes: [ FatalError.name ]
     }
   } )[ACTIVITY_SEND_HTTP_REQUEST]( { method, url, payload, headers, responseOptions } );
-  return res.output;
 };
 
 /**

package/src/interface/webhook.spec.js

@@ -1,24 +1,14 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-// Mocks for module aliases used by webhook.js
-vi.mock( '#consts', () => ( {
-  ACTIVITY_SEND_HTTP_REQUEST: '__internal#sendHttpRequest'
-} ) );
+import { ACTIVITY_SEND_HTTP_REQUEST } from '#consts';
 
 const validateRequestPayloadMock = vi.fn();
 vi.mock( './validations/index.js', () => ( {
   validateRequestPayload: validateRequestPayloadMock
 } ) );
 
-const activityEnvelope = output => ( {
-  __output_activity_wrapper_version: 1,
-  output,
-  aggregations: null
-} );
-
 // Minimal, legible mock of @temporalio/workflow APIs used by webhook.js
 const activityFnMock = vi.fn();
-const proxyActivitiesMock = vi.fn( () => ( { ['__internal#sendHttpRequest']: activityFnMock } ) );
+const proxyActivitiesMock = vi.fn( () => ( { [ACTIVITY_SEND_HTTP_REQUEST]: activityFnMock } ) );
 
 const storedHandlers = new Map();
 const defineSignalMock = name => name;
@@ -76,7 +66,7 @@ describe( 'interface/webhook', () => {
       headers: { 'content-type': 'application/json' },
       body: { ok: true }
     };
-    activityFnMock.mockResolvedValueOnce( activityEnvelope( fakeSerializedResponse ) );
+    activityFnMock.mockResolvedValueOnce( fakeSerializedResponse );
 
     const args = { url: 'https://example.com/api', method: 'GET' };
     const res = await sendHttpRequest( args );
@@ -112,7 +102,7 @@ describe( 'interface/webhook', () => {
   it( 'sendHttpRequest forwards response options', async () => {
     const { sendHttpRequest } = await import( './webhook.js' );
 
-    activityFnMock.mockResolvedValueOnce( activityEnvelope( { ok: true } ) );
+    activityFnMock.mockResolvedValueOnce( { ok: true } );
 
     const args = {
       url: 'https://example.com/api',
@@ -137,15 +127,14 @@ describe( 'interface/webhook', () => {
   it( 'sendPostRequestAndAwaitWebhook posts wrapped payload and resolves on resume signal', async () => {
     const { sendPostRequestAndAwaitWebhook } = await import( './webhook.js' );
 
-    // Make the inner activity resolve (through sendHttpRequest)
-    activityFnMock.mockResolvedValueOnce( activityEnvelope( {
+    activityFnMock.mockResolvedValueOnce( {
       url: 'https://webhook.site',
       status: 200,
       statusText: 'OK',
       ok: true,
       headers: {},
       body: null
-    } ) );
+    } );
 
     const url = 'https://webhook.site/ingest';
     const promise = sendPostRequestAndAwaitWebhook( { url, payload: { x: 1 }, headers: { a: 'b' } } );
@@ -158,7 +147,24 @@ describe( 'interface/webhook', () => {
     expect( callArgs.headers ).toEqual( { a: 'b' } );
     expect( callArgs.responseOptions ).toEqual( {} );
 
-    // Returns a promise (async function) for the eventual webhook result
-    expect( typeof promise.then ).toBe( 'function' );
+    await vi.waitFor( () => expect( storedHandlers.has( 'resume' ) ).toBe( true ) );
+
+    expect( sinks.trace.start ).toHaveBeenCalledWith( {
+      id: 'wf-123-https://webhook.site/ingest-uuid-mock',
+      name: 'resume',
+      kind: 'webhook'
+    } );
+
+    const webhookPayload = { status: 'completed' };
+    storedHandlers.get( 'resume' )( webhookPayload );
+
+    await expect( promise ).resolves.toEqual( webhookPayload );
+    expect( sinks.trace.end ).toHaveBeenCalledWith( {
+      id: 'wf-123-https://webhook.site/ingest-uuid-mock',
+      details: webhookPayload
+    } );
+
+    storedHandlers.get( 'resume' )( { status: 'duplicate' } );
+    expect( sinks.trace.end ).toHaveBeenCalledTimes( 1 );
   } );
 } );

package/src/interface/workflow.d.ts

@@ -21,6 +21,8 @@ export type WorkflowContext<
      * It acts as a checkpoint when the workflow gets too long or approaches certain scaling limits.
      *
      * It accepts input with the same schema as the parent workflow function (`inputSchema`).
+     * The next run parses that input like any other workflow start; pass wire-format values if
+     * `inputSchema` transforms are not safe to apply twice.
      *
      * Calling this function must be the last statement in the workflow, accompanied by a `return`:
      *
@@ -38,7 +40,7 @@ export type WorkflowContext<
      * @returns The workflow output type for type-checking; never returns at runtime.
      */
     continueAsNew: InputSchema extends AnyZodSchema ?
-      ( input: z.infer<InputSchema> ) => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ) :
+      ( input: z.input<InputSchema> ) => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ) :
       () => ( OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void ),
 
     /**
@@ -122,39 +124,44 @@ export type WorkflowOptions = {
 /**
  * The handler function of a workflow.
  *
- * @param input - The workflow input; it matches the schema defined by `inputSchema`.
+ * @param input - Parsed workflow input (`z.infer<inputSchema>`).
  * @param context - A context object with tools and information.
  *
- * @returns A value matching the schema defined by `outputSchema`.
+ * @returns A value accepted by `outputSchema` before parse (`z.input<outputSchema>`).
  */
 export type WorkflowFunction<
   InputSchema extends AnyZodSchema | undefined = undefined,
   OutputSchema extends AnyZodSchema | undefined = undefined
 > = InputSchema extends AnyZodSchema ?
   ( input: z.infer<InputSchema>, context: WorkflowContext<InputSchema, OutputSchema> ) =>
-  Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
+  Promise<OutputSchema extends AnyZodSchema ? z.input<OutputSchema> : void> :
   ( input: undefined | null, context: WorkflowContext<InputSchema, OutputSchema> ) =>
-  Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
+  Promise<OutputSchema extends AnyZodSchema ? z.input<OutputSchema> : void>;
 
 /**
  * A wrapper around the user defined `fn` handler function.
  *
- * It accepts the same input and returns the same value, calling the user function inside.
+ * Callers pass values accepted by `inputSchema` (`z.input`). The wrapper parses input,
+ * invokes `fn`, parses output, and returns `z.infer<outputSchema>`.
  *
  * The second argument is a WorkflowInvocationOptions object, allowing workflows configuration overwrite.
  *
- * It adds input and output validation based on the `inputSchema`, `outputSchema`.
- *
- * @param input - The workflow input; it matches the schema defined by `inputSchema`.
+ * @param input - The workflow input before `inputSchema` parse.
  * @param options - Additional options for the invocation.
- * @returns A value matching the schema defined by `outputSchema`.
+ * @returns The workflow output after `outputSchema` parse.
  */
-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> :
-    ( input: Parameters<WorkflowFunction>[0], options?: WorkflowInvocationOptions ) =>
-    ReturnType<WorkflowFunction>;
+export type WorkflowFunctionWrapper<
+  InputSchema extends AnyZodSchema | undefined = undefined,
+  OutputSchema extends AnyZodSchema | undefined = undefined
+> = InputSchema extends AnyZodSchema ?
+  (
+    input: z.input<InputSchema>,
+    options?: WorkflowInvocationOptions
+  ) => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void> :
+  (
+    input?: undefined | null,
+    options?: WorkflowInvocationOptions
+  ) => Promise<OutputSchema extends AnyZodSchema ? z.infer<OutputSchema> : void>;
 
 /**
  * Creates a workflow.
@@ -270,7 +277,7 @@ export type WorkflowFunctionWrapper<WorkflowFunction extends ( ...args: any ) =>
  * @param params.outputSchema - Zod schema for workflow output
  * @param params.fn - A function containing the workflow code
  * @param params.options - Optional workflow options.
- * @returns The same handler function set at `fn` with a different signature
+ * @returns A wrapper that parses input/output around `fn`
  */
 export declare function workflow<
   InputSchema extends AnyZodSchema | undefined = undefined,
@@ -288,4 +295,4 @@ export declare function workflow<
    * while maintaining backward compatibility with existing callers.
    */
   aliases?: string[];
-} ): WorkflowFunctionWrapper<WorkflowFunction<InputSchema, OutputSchema>>;
+} ): WorkflowFunctionWrapper<InputSchema, OutputSchema>;

package/src/interface/workflow.js

@@ -1,26 +1,15 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy } from '@temporalio/workflow';
+import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4, ParentClosePolicy, upsertMemo } from '@temporalio/workflow';
 import { WorkflowValidator } from './validations/index.js';
 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 { enforceActivityOptions } from '#helpers/activity_options';
 import { FatalError } from '#errors';
 import * as C from '#consts';
 
-/**
- * Execute the workflow without temporal, using the fn handler function.
- * This is important to allow for workflows to have unit tests
- */
-const executeWithoutTemporal = async ( { input, validator, handler, contextOverrides = {} } ) => {
-  validator.validateInput( input );
-  const output = await handler( input, deepMerge( WorkflowContext.build(), contextOverrides ) );
-  validator.validateOutput( output );
-  return output;
-};
-
 /**
  * Add a global dispatcher function to be used to invoke activities.
  * This will replace direct activity invocation in the user code by the webpack loader.
@@ -29,7 +18,7 @@ const executeWithoutTemporal = async ( { input, validator, handler, contextOverr
  * so Temporal's reusable VM can delete it when switching workflow scopes.
  */
 const createGlobalDispatcher = ( { runId, workflowType, activities } ) => {
-  const dispatcher = async ( activityType, ...args ) => activities[`${workflowType}#${activityType}`]( ...args ).then( r => r.output );
+  const dispatcher = async ( activityType, ...args ) => activities[`${workflowType}#${activityType}`]( ...args );
   dispatcher.runId = runId;
   globalThis[C.INVOKE_ACTIVITY_SYMBOL] = dispatcher;
 };
@@ -47,19 +36,20 @@ const checkGlobalContextContamination = runId => {
 export function workflow( { name, description, inputSchema, outputSchema, fn, options = {}, aliases = [] } ) {
   WorkflowValidator.validateDefinition( { name, description, inputSchema, outputSchema, fn, options, aliases } );
 
-  // Disable trace can only be defined at the definition level
-  const disableTrace = options.disableTrace ?? defaultOptions.disableTrace;
   const validator = new WorkflowValidator( { name, inputSchema, outputSchema } );
 
-  const handler = async ( input, invocationOptions = {} ) => {
-    validator.validateInvocationOptions( invocationOptions );
+  const handler = async ( input, rawInvocationOptions = {} ) => {
+    const invocationOptions = validator.parseInvocationOptions( rawInvocationOptions );
 
     // If called outside Temporal workflow context, just execute the handler function
     if ( !inWorkflowContext() ) {
-      return executeWithoutTemporal( { input, validator, handler: fn, contextOverrides: invocationOptions?.context } );
+      return validator.parseOutput(
+        await fn( validator.parseInput( input ), deepMerge( WorkflowContext.build(), invocationOptions?.context ) )
+      );
     }
 
     const { workflowId, runId, memo, root } = workflowInfo();
+    const isRoot = !root;
 
     checkGlobalContextContamination( runId );
 
@@ -69,48 +59,30 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       const parentClosePolicy = ParentClosePolicy[invocationOptions?.detached ? 'ABANDON' : 'TERMINATE'];
       const childWorkflowId = `${workflowId}-${toUrlSafeBase64( uuid4() )}`;
       const args = [ input, { activityOptions: invocationOptions?.activityOptions } ];
-      return executeChild( name, { args, workflowId: childWorkflowId, parentClosePolicy, memo } ).then( r => r.output );
-    }
-
-    const isRoot = !root; // Check if this is the root most workflow
-
-    // Trace info is only added in the root and only when trace is not disabled
-    if ( isRoot && !disableTrace ) {
-      memo.traceInfo = TraceInfo.build();
+      return executeChild( name, { args, workflowId: childWorkflowId, parentClosePolicy, memo } );
     }
 
-    // Resolve the activity options: invocation options > definition options > parent options > default options
-    const activityOptions = deepMerge(
+    // Resolve the activity options: invocation options > definition options > parent options > default options, then enforce final SDK options
+    const activityOptions = enforceActivityOptions( deepMerge(
       defaultOptions.activityOptions, // default
-      memo?.parentActivityOptions, // parent options
+      memo?.activityOptions, // parent options
       options?.activityOptions, // definition options
       invocationOptions.activityOptions // invocation options
-    );
-    // Resolved activity options are added to memo so child workflow executions can continue the policy chain.
-    memo.parentActivityOptions = activityOptions;
-    const activities = proxyActivities( activityOptions );
+    ) );
 
+    const activities = proxyActivities( activityOptions );
     createGlobalDispatcher( { runId, workflowType: name, activities } );
 
-    const traceDestinations = isRoot && {
-      trace: {
-        destinations: disableTrace ? {} : await activities[C.ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo ).then( r => r.output ) ?? {}
-      }
-    };
+    upsertMemo( {
+      activityOptions, // Resolved activity options are added to memo so child workflow executions can continue the policy chain
+      ...( isRoot && memo.traceInfo && {
+        trace: await activities[C.ACTIVITY_GET_TRACE_DESTINATIONS]( memo.traceInfo )
+      } )
+    } );
 
-    try {
-      validator.validateInput( input );
-      const output = await fn( input, WorkflowContext.build() );
-      validator.validateOutput( output );
-
-      return { [C.WORKFLOW_WRAPPER_VERSION_FIELD]: 1, output, ...traceDestinations };
-    } catch ( error ) {
-      if ( traceDestinations ) {
-        // Append the trace destinations so it is carried to interceptor
-        error[C.METADATA_ACCESS_SYMBOL] = traceDestinations;
-      }
-      throw error;
-    }
+    return validator.parseOutput(
+      await fn( validator.parseInput( input ), WorkflowContext.build() )
+    );
   };
 
   return createWorkflow( { name, description, inputSchema, outputSchema, options, aliases, handler } );