@output.ai/core 0.1.10 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.1.10",
+  "version": "0.1.12",
   "description": "The core module of the output framework",
   "type": "module",
   "exports": {

package/src/index.d.ts

@@ -21,15 +21,17 @@ export { z } from 'zod';
 type AnyZodSchema = z.ZodType<any, any, any>;
 
 /**
- * Activity retry options accepted by step/evaluator/workflow definitions.
- * Uses Temporal's ActivityOptions['retry'] type.
- */
-export type Options = { retry?: ActivityOptions['retry'] };
-
-/**
+ * Activity options accepted by step/evaluator/workflow definitions.
+ * Exposes supported Temporal ActivityOptions.
+ *
  * @typedef {object} Options
- * @property {import('@temporalio/workflow').ActivityOptions['retry']} [retry]
+ * @description Exposes supported Temporal ActivityOptions
  */
+export type Options = Omit<ActivityOptions, 'versioningIntent' | 'taskQueue' | 'allowEagerDispatch'>;
+
+export type WorkflowCallConfig = {
+  options?: Options
+};
 
 /*
 ╭─────────╮
@@ -165,7 +167,7 @@ export function workflow<
   outputSchema: OutputSchema,
   fn: ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>,
   options?: Options
-} ): ( input: z.infer<InputSchema> ) => Promise<z.infer<OutputSchema>>;
+} ): ( input: z.infer<InputSchema>, extra?: WorkflowCallConfig ) => Promise<z.infer<OutputSchema>>;
 
 /**
  * Creates a workflow orchestrator with defined schema for input only.
@@ -186,7 +188,7 @@ export function workflow<
   inputSchema: InputSchema,
   fn: ( input: z.infer<InputSchema> ) => Promise<void>,
   options?: Options
-} ): ( input: z.infer<InputSchema> ) => Promise<void>;
+} ): ( input: z.infer<InputSchema>, extra?: WorkflowCallConfig ) => Promise<void>;
 
 /**
  * Creates a workflow orchestrator with defined schema for output only.
@@ -207,7 +209,7 @@ export function workflow<
   outputSchema: OutputSchema,
   fn: () => Promise<z.infer<OutputSchema>>,
   options?: Options
-} ): () => Promise<z.infer<OutputSchema>>;
+} ): ( input?: undefined | null, extra?: WorkflowCallConfig ) => Promise<z.infer<OutputSchema>>;
 
 /**
  * Creates a workflow orchestrator without defined schemas.
@@ -224,7 +226,7 @@ export function workflow( options : {
   description?: string,
   fn: () => Promise<void>,
   options?: Options
-} ): () => Promise<void>;
+} ): ( input?: undefined | null, extra?: WorkflowCallConfig ) => Promise<void>;
 
 /*
 ╭───────────────────╮

package/src/interface/validations/static.js

@@ -17,10 +17,16 @@ const refineSchema = ( value, ctx ) => {
   } );
 };
 
-export const durationStringSchema = z.string().regex(
+export const durationSchema = z.union( [ z.string().regex(
   /^(\d+)(ms|s|m|h|d)$/,
   'Expected duration like "500ms", "10s", "5m", "2h", or "1d"'
-);
+), z.number() ] );
+
+export const prioritySchema = z.object( {
+  fairnessKey: z.string().optional(),
+  fairnessWeight: z.number().min( 0.0001 ).max( 1000 ).optional(),
+  priorityKey: z.number().min( 1 ).optional()
+} );
 
 const stepAndWorkflowSchema = z.strictObject( {
   name: z.string().regex( /^[a-z_][a-z0-9_]*$/i ),
@@ -29,13 +35,21 @@ const stepAndWorkflowSchema = z.strictObject( {
   outputSchema: z.any().optional().superRefine( refineSchema ),
   fn: z.function(),
   options: z.strictObject( {
+    activityId: z.string().optional(),
+    cancellationType: z.enum( [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ).optional(),
+    heartbeatTimeout: durationSchema.optional(),
+    priority: prioritySchema.optional(),
     retry: z.strictObject( {
-      initialInterval: durationStringSchema.optional(),
+      initialInterval: durationSchema.optional(),
       backoffCoefficient: z.number().gte( 1 ).optional(),
-      maximumInterval: durationStringSchema.optional(),
+      maximumInterval: durationSchema.optional(),
       maximumAttempts: z.number().gte( 1 ).int().optional(),
       nonRetryableErrorTypes: z.array( z.string() ).optional()
-    } ).optional()
+    } ).optional(),
+    scheduleToCloseTimeout: durationSchema.optional(),
+    scheduleToStartTimeout: durationSchema.optional(),
+    startToCloseTimeout: durationSchema.optional(),
+    summary: z.string().optional()
   } ).optional()
 } );
 

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

@@ -82,6 +82,71 @@ describe( 'interface/validator', () => {
       expect( () => validateStep( args ) ).not.toThrow();
     } );
 
+    it( 'passes with options.activityId as string', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityId: 'act-123' } } ) ).not.toThrow();
+    } );
+
+    it( 'rejects non-string options.activityId', () => {
+      expect( () => validateStep( { ...validArgs, options: { activityId: 123 } } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'passes with valid options.cancellationType values', () => {
+      for ( const v of [ 'TRY_CANCEL', 'WAIT_CANCELLATION_COMPLETED', 'ABANDON' ] ) {
+        expect( () => validateStep( { ...validArgs, options: { cancellationType: v } } ) ).not.toThrow();
+      }
+    } );
+
+    it( 'rejects invalid options.cancellationType', () => {
+      expect( () => validateStep( { ...validArgs, options: { cancellationType: 'INVALID' } } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'accepts duration fields in options', () => {
+      const options = {
+        heartbeatTimeout: '1s',
+        scheduleToCloseTimeout: '2m',
+        scheduleToStartTimeout: '3m',
+        startToCloseTimeout: '4m'
+      };
+      expect( () => validateStep( { ...validArgs, options } ) ).not.toThrow();
+    } );
+
+    it( 'rejects invalid duration string in heartbeatTimeout', () => {
+      expect( () => validateStep( { ...validArgs, options: { heartbeatTimeout: '5x' } } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'passes with options.summary string', () => {
+      expect( () => validateStep( { ...validArgs, options: { summary: 'brief' } } ) ).not.toThrow();
+    } );
+
+    it( 'rejects non-string options.summary', () => {
+      expect( () => validateStep( { ...validArgs, options: { summary: 42 } } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'passes with options.priority valid payload', () => {
+      const options = {
+        priority: {
+          fairnessKey: 'user-1',
+          fairnessWeight: 1.5,
+          priorityKey: 10
+        }
+      };
+      expect( () => validateStep( { ...validArgs, options } ) ).not.toThrow();
+    } );
+
+    it( 'rejects invalid options.priority values', () => {
+      const options = { priority: { fairnessWeight: 0, priorityKey: 0 } };
+      expect( () => validateStep( { ...validArgs, options } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'rejects invalid options.retry values', () => {
+      const options = { retry: { backoffCoefficient: 0.5, maximumAttempts: 0, nonRetryableErrorTypes: [ 1 ] } };
+      expect( () => validateStep( { ...validArgs, options } ) ).toThrow( StaticValidationError );
+    } );
+
+    it( 'rejects unknown keys inside options due to strictObject', () => {
+      expect( () => validateStep( { ...validArgs, options: { unknownKey: true } } ) ).toThrow( StaticValidationError );
+    } );
+
     it( 'rejects unknown top-level keys due to strictObject', () => {
       expect( () => validateStep( { ...validArgs, extra: 123 } ) ).toThrow( StaticValidationError );
     } );

package/src/interface/workflow.js

@@ -59,11 +59,16 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
       invokeSharedStep: async ( stepName, input, options ) => steps[`${SHARED_STEP_PREFIX}#${stepName}`]( input, options ),
       invokeEvaluator: async ( evaluatorName, input, options ) => steps[`${workflowPath}#${evaluatorName}`]( input, options ),
 
-      startWorkflow: async ( childName, input ) => {
+      startWorkflow: async ( childName, input, extra = {} ) => {
         return executeChild( childName, {
           args: input ? [ input ] : [],
           workflowId: `${workflowId}-${childName}-${Date.now()}`,
-          memo: { executionContext, parentId: workflowId }
+          memo: {
+            executionContext,
+            parentId: workflowId,
+            // new configuration for activities of the child workflow, this will be omitted so it will use what that workflow have defined
+            ...( extra?.options && { activityOptions: mergeActivityOptions( activityOptions, extra.options ) } )
+          }
         } );
       }
     }, input );