@output.ai/core 0.0.7 → 0.0.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@output.ai/core",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "description": "The core module of the output framework",
   "type": "module",
   "main": "src/index.js",
@@ -20,13 +20,17 @@
     "url": "git+https://github.com/growthxai/flow-sdk"
   },
   "dependencies": {
+    "@babel/generator": "7.26.5",
+    "@babel/parser": "7.26.7",
+    "@babel/traverse": "7.25.9",
+    "@babel/types": "7.26.7",
     "@temporalio/worker": "1.13.0",
-    "@temporalio/workflow": "1.13.0",
-    "undici": "7.15.0"
+    "@temporalio/workflow": "1.13.0"
   },
   "imports": {
     "#consts": "./src/consts.js",
     "#configs": "./src/configs.js",
+    "#errors": "./src/errors.js",
     "#internal_activities": "./src/internal_activities/index.js"
   }
 }

package/src/configs.js

@@ -5,7 +5,7 @@ export const worker = {
   maxActivities: 100,
   maxWorkflows: 100,
   namespace: process.env.TEMPORAL_NAMESPACE ?? 'default',
-  taskQueue: process.env.TEMPORAL_TASK_QUEUE ?? 'main'
+  taskQueue: process.env.TEMPORAL_TASK_QUEUE
 };
 
 export const api = {

package/src/consts.js

@@ -1,3 +1,3 @@
-export const nameSymbol = Symbol( '__name' );
-export const sendWebhookPostName = '__internal#sendWebhookPost';
-export const workflowsIndexFileName = '__workflows_entrypoint.js';
+export const SEND_WEBHOOK_ACTIVITY_NAME = '__internal#sendWebhookPost';
+export const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+export const WORKFLOWS_INDEX_FILENAME = '__workflows_entrypoint.js';

package/src/index.d.ts

@@ -1,38 +1,310 @@
-export interface StepDefinition<TInput = unknown, TOutput = unknown> {
+// JSON Schema → TypeScript type mapping (subset sufficient for IntelliSense)
+type Simplify<T> = { [K in keyof T]: T[K] };
+type EnumValues = readonly ( string | number | boolean | null )[];
+
+type JSONSchema = {
+  type?: 'string' | 'number' | 'integer' | 'boolean' | 'null' | 'object' | 'array';
+  enum?: EnumValues;
+  const?: string | number | boolean | null;
+  anyOf?: readonly JSONSchema[];
+  oneOf?: readonly JSONSchema[];
+  allOf?: readonly JSONSchema[];
+  // object
+  properties?: { [key: string]: JSONSchema };
+  required?: readonly string[];
+  additionalProperties?: boolean | JSONSchema;
+  // array
+  items?: JSONSchema | readonly JSONSchema[];
+  // ignore $ref & others for typing purposes
+  $ref?: string;
+} & Record<string, unknown>;
+
+type UnionToIntersection<U> = ( U extends unknown ? ( k: U ) => void : never ) extends ( k: infer I ) => void ? I : never;
+
+type FromEnum<S> = S extends { enum: infer E extends EnumValues } ? E[number] : never;
+type FromConst<S> = S extends { const: infer C } ? C : never;
+
+type FromPrimitive<S> =
+  S extends { type: 'string' } ? string :
+  S extends { type: 'number' | 'integer' } ? number :
+  S extends { type: 'boolean' } ? boolean :
+  S extends { type: 'null' } ? null :
+  never;
+
+type ObjectProps<S extends JSONSchema> = S extends { properties: infer P extends Record<string, JSONSchema> }
+  ? { [K in keyof P]: FromSchema<P[K]> }
+  : Record<never, never>;
+
+type ObjectRequiredKeys<S extends JSONSchema> = S extends { required: readonly ( infer R )[] }
+  ? Extract<R & string, keyof ObjectProps<S>>
+  : never;
+
+type ObjectFrom<S extends JSONSchema> = Simplify<
+  Pick<ObjectProps<S>, ObjectRequiredKeys<S>> &
+  Partial<Omit<ObjectProps<S>, ObjectRequiredKeys<S>>>
+>;
+
+type ArrayFrom<S extends JSONSchema> = S extends { items: infer I }
+  ? I extends readonly unknown[]
+    ? FromSchema<I[number]>[]
+    : FromSchema<I>[]
+  : unknown[];
+
+export type FromSchema<S extends JSONSchema> =
+  // combinators first
+  S extends { anyOf: infer A extends readonly JSONSchema[] } ? FromSchema<A[number]> :
+  S extends { oneOf: infer A extends readonly JSONSchema[] } ? FromSchema<A[number]> :
+  S extends { allOf: infer A extends readonly JSONSchema[] } ? UnionToIntersection<FromSchema<A[number]>> :
+  // enum/const
+  FromEnum<S> extends never ? ( FromConst<S> extends never ? (
+    // object (explicit or by presence of properties)
+    S extends { type: 'object' } | { properties: Record<string, JSONSchema> } ? ObjectFrom<S> :
+    // array
+    S extends { type: 'array' } ? ArrayFrom<S> :
+    // primitives
+    FromPrimitive<S> extends never ? unknown : FromPrimitive<S>
+  ) : FromConst<S> ) : FromEnum<S>;
+
+export type OutputFrom<O extends JSONSchema> = FromSchema<O>;
+
+// Utility to strip readonly from inferred types
+/** Recursively removes readonly modifiers from object and array types. */
+type DeepMutable<T> =
+  T extends readonly ( infer U )[] ? DeepMutable<U>[] :
+  T extends object ? { -readonly [K in keyof T]: DeepMutable<T[K]> } :
+  T;
+
+/*
+ * There is 4 overrides of the "step" function"
+ * - with fn receiving input and returning output;
+ * - with fn receiving input and returning void;
+ * - with fn receiving void and returning outout;
+ * - with fn receiving void and returning void;
+ */
+
+/**
+ * @callback StepFn
+ * @param {any} input - The input, defined by the inputSchema
+ * @returns {any} The output defined by the outputSchema
+ */
+
+/**
+ * Creates logical unit of work, called "step", which will be invoked from workflows.
+ *
+ * @param {object} options - Step options
+ * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
+ * @param {string} [options.description] - Description of the step
+ * @param {JSONSchema} options.inputSchema - JSON Schema for the fn input, will infer a TS type
+ * @param {JSONSchema} options.outputSchema - JSON Schema for the fn output, will infer a TS type
+ * @param {StepFn} options.fn - The function logic
+ * @returns {StepFn} The options.fn function
+ */
+export async function step<
+  const InputSchema extends JSONSchema,
+  const OutputSchema extends JSONSchema
+>( options: {
+  name: string;
+  description?: string;
+  inputSchema: InputSchema;
+  outputSchema: OutputSchema;
+  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+
+/**
+ * @callback InputOnlyStepFn
+ * @param {any} input - The input, defined by the inputSchema
+ */
+
+/**
+ * Creates logical unit of work, called "step", which will be invoked from workflows.
+ *
+ * @param {object} options - Step options
+ * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
+ * @param {string} [options.description] - Description of the step
+ * @param {JSONSchema} options.inputSchema - JSON Schema for the fn input, will infer a TS type
+ * @param {InputOnlyStepFn} options.fn - The function logic
+ * @returns {InputOnlyStepFn} The options.fn function
+ */
+export async function step<
+  const InputSchema extends JSONSchema
+>( options: {
+  name: string;
+  description?: string;
+  inputSchema: InputSchema;
+  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>;
+} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>;
+
+/**
+ * @callback OutputOnlyStepFn
+ * @returns {any} The output defined by the outputSchema
+ */
+
+/**
+ * Creates logical unit of work, called "step", which will be invoked from workflows.
+ *
+ * @param {object} options - Step options
+ * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
+ * @param {string} [options.description] - Description of the step
+ * @param {JSONSchema} options.outputSchema - JSON Schema for the fn output, will infer a TS type
+ * @param {OutputOnlyStepFn} options.fn - The function logic
+ * @returns {OutputOnlyStepFn} The options.fn function
+ */
+export async function step<
+  const OutputSchema extends JSONSchema
+>( options: {
   name: string;
   description?: string;
-  fn: ( input: TInput ) => Promise<TOutput>;
-}
-
-export interface WorkflowContext {
-  steps: {
-    [stepName: string]: ( input?: unknown ) => Promise<unknown>;
-  };
-  workflowId: string | null;
-  tools: {
-    webhook: ( options: {
-      name: string;
-      description?: string;
-      url: string;
-      payload: object;
-    } ) => Promise<unknown>;
-  };
-}
-
-export interface WorkflowDefinition<TInput = unknown, TOutput = unknown> {
+  outputSchema: OutputSchema;
+  fn: () => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+} ): () => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+
+/**
+ * @callback VoidStepFn
+ */
+
+/**
+ * Creates logical unit of work, called "step", which will be invoked from workflows.
+ *
+ * @param {object} options - Step options
+ * @param {string} options.name - Human-readable step name (only letters, numbers and "_")
+ * @param {string} [options.description] - Description of the step
+ * @param {VoidStepFn} options.fn - The function logic
+ * @returns {VoidStepFn} The options.fn function
+ */
+export async function step( options: {
   name: string;
   description?: string;
-  fn: ( input: TInput, context: WorkflowContext ) => Promise<TOutput>;
-}
+  fn: () => Promise<void>;
+} ): () => Promise<void>;
+
+/*
+ * There is 4 overrides of the "workflow" function"
+ * - with fn receiving input and returning output;
+ * - with fn receiving input and returning void;
+ * - with fn receiving void and returning outout;
+ * - with fn receiving void and returning void;
+ */
+
+/**
+ * @callback WorkflowFn
+ * @param {any} input - The input, defined by the inputSchema
+ * @returns {any} The output defined by the outputSchema
+ */
+
+/**
+ * Creates a workflow orchestrator which can invoke steps.
+ *
+ * @param {object} options - Workflow options
+ * @param {string} options.name - Unique workflow name
+ * @param {string} [options.description] - Description of the workflow
+ * @param {JSONSchema} [options.inputSchema] - JSON Schema for workflow input
+ * @param {JSONSchema} [options.outputSchema] - JSON Schema for workflow output
+ * @param {WorkflowFn} options.fn - Workflow logic
+ * @returns {WorkflowFn} Callable workflow function
+ */
+export function workflow<
+  const InputSchema extends JSONSchema,
+  const OutputSchema extends JSONSchema
+>( options : {
+  name: string,
+  description?: string,
+  inputSchema: InputSchema,
+  outputSchema: OutputSchema,
+  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>
+} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+
+/**
+ * @callback InputOnlyWorkflowFn
+ * @param {any} input - The input, defined by the inputSchema
+ */
+
+/**
+ * Creates a workflow orchestrator which can invoke steps.
+ *
+ * @param {object} options - Workflow options
+ * @param {string} options.name - Unique workflow name
+ * @param {string} [options.description] - Description of the workflow
+ * @param {JSONSchema} [options.inputSchema] - JSON Schema for workflow input
+ * @param {InputOnlyWorkflowFn} options.fn - Workflow logic
+ * @returns {InputOnlyWorkflowFn} Callable workflow function
+ */
+export function workflow<
+  const InputSchema extends JSONSchema
+>( options : {
+  name: string,
+  description?: string,
+  inputSchema: InputSchema,
+  fn: ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>
+} ): ( input: DeepMutable<FromSchema<InputSchema>> ) => Promise<void>;
+
+/**
+ * @callback OutputOnlyWorkflowFn
+ * @returns {any} The output defined by the outputSchema
+ */
+
+/**
+ * Creates a workflow orchestrator which can invoke steps.
+ *
+ * @param {object} options - Workflow options
+ * @param {string} options.name - Unique workflow name
+ * @param {string} [options.description] - Description of the workflow
+ * @param {JSONSchema} [options.outputSchema] - JSON Schema for workflow output
+ * @param {OutputOnlyWorkflowFn} options.fn - Workflow logic
+ * @returns {OutputOnlyWorkflowFn} Callable workflow function
+ */
+export function workflow<
+  const OutputSchema extends JSONSchema
+>( options : {
+  name: string,
+  description?: string,
+  outputSchema: OutputSchema,
+  fn: () => Promise<DeepMutable<FromSchema<OutputSchema>>>
+} ): () => Promise<DeepMutable<FromSchema<OutputSchema>>>;
+
+/**
+ * @callback VoidWorkflowFn
+ * @param {any} input - The input, defined by the inputSchema
+ * @returns {any} The output defined by the outputSchema
+ */
 
-export function step<TInput = unknown, TOutput = unknown>(
-  definition: StepDefinition<TInput, TOutput>
-): ( input: TInput ) => Promise<TOutput>;
+/**
+ * Creates a workflow orchestrator which can invoke steps.
+ *
+ * @param {object} options - Workflow options
+ * @param {string} options.name - Unique workflow name
+ * @param {string} [options.description] - Description of the workflow
+ * @param {VoidWorkflowFn} options.fn - Workflow logic
+ * @returns {VoidWorkflowFn} Callable workflow function
+ */
+export function workflow( options : {
+  name: string,
+  description?: string,
+  fn: () => Promise<void>
+} ): () => Promise<void>;
 
-export function workflow<TInput = unknown, TOutput = unknown>(
-  definition: WorkflowDefinition<TInput, TOutput>
-): ( input: TInput ) => Promise<TOutput>;
+/**
+ * Create a webhook call that pauses the workflow until resumed via signal.
+ *
+ * Sends a request via an activity; the workflow will await a corresponding
+ * resume signal to continue and return the response payload.
+ *
+ * @param {object} options - Webhook request options
+ * @param {string} options.url - Webhook request url (POST)
+ * @param {object} [options.payload] - Webhook request payload
+ * @returns {Promise<object>} Resolves with the response payload when resumed
+ */
+export function createWebhook( options: { url: string; payload?: object } ): Promise<object>;
 
-export function startWorkflow<TOutput = unknown>( name: string, options?: { input?: TInput } ): Promise<TOutput>;
+/**
+ * Error indicating a non-recoverable failure.
+ *
+ * Use for failures that should not be retried by the workflow runtime.
+ */
+export class FatalError extends Error {}
 
-export { FatalError, ValidationError } from './errors.js';
+/**
+ * Error indicating invalid input or schema validation issues.
+ *
+ * Use for problems detected during input validation or contract checks.
+ */
+export class ValidationError extends Error {}

package/src/index.js

@@ -1,5 +1,6 @@
 import { step } from './interface/step.js';
-import { startWorkflow, workflow } from './interface/workflow.js';
+import { workflow } from './interface/workflow.js';
+import { createWebhook } from './interface/webhook.js';
 import { FatalError, ValidationError } from './errors.js';
 
-export { step, startWorkflow, workflow, FatalError, ValidationError };
+export { step, workflow, createWebhook, FatalError, ValidationError };

package/src/interface/metadata.js

@@ -1,4 +1,4 @@
-import { nameSymbol } from '#consts';
+import { METADATA_ACCESS_SYMBOL } from '#consts';
 
-export const setName = ( target, name ) =>
-  Object.defineProperty( target, nameSymbol, { value: name, writable: false, enumerable: false, configurable: false } );
+export const setMetadata = ( target, values ) =>
+  Object.defineProperty( target, METADATA_ACCESS_SYMBOL, { value: values, writable: false, enumerable: false, configurable: false } );

package/src/interface/step.js

@@ -1,6 +1,6 @@
-import { setName } from './metadata.js';
+import { setMetadata } from './metadata.js';
 
-export function step( { name, description: _description, fn } ) {
-  setName( fn, name );
+export function step( { name, description, inputSchema, outputSchema, fn } ) {
+  setMetadata( fn, { name, description, inputSchema, outputSchema } );
   return fn;
 };

package/src/interface/webhook.js

@@ -1,18 +1,17 @@
-import { defineSignal, setHandler } from '@temporalio/workflow';
+// THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
+import { defineSignal, setHandler, proxyActivities, workflowInfo } from '@temporalio/workflow';
+import { SEND_WEBHOOK_ACTIVITY_NAME } from '#consts';
 
-export function createWebhook( workflowId, requestDispatcher ) {
-  return async function webhook( { name: _name, description: _description, url, payload } ) {
-    const { error } = await requestDispatcher( { url, workflowId, payload } );
-    if ( error ) {
-      throw new Error( 'Webhook call failed' );
-    }
+export async function createWebhook( { url, payload } ) {
+  const workflowId = workflowInfo();
 
-    const resumeSignal = defineSignal( 'resume' );
+  await proxyActivities( temporalActivityConfigs )[SEND_WEBHOOK_ACTIVITY_NAME]( { url, workflowId, payload } );
 
-    return new Promise( resolve => {
-      setHandler( resumeSignal, responsePayload => {
-        resolve( responsePayload );
-      } );
-    } );
-  };
+  const resumeSignal = defineSignal( 'resume' );
+
+  return new Promise( resolve =>
+    setHandler( resumeSignal, responsePayload => {
+      resolve( responsePayload );
+    } )
+  );
 };

package/src/interface/workflow.js

@@ -1,9 +1,7 @@
 // THIS RUNS IN THE TEMPORAL'S SANDBOX ENVIRONMENT
-import { proxyActivities, IllegalStateError, executeChild, workflowInfo } from '@temporalio/workflow';
+import { proxyActivities, inWorkflowContext, executeChild, workflowInfo } from '@temporalio/workflow';
 import { getInvocationDir } from './utils.js';
-import { createWebhook } from './webhook.js';
-import { setName } from './metadata.js';
-import { sendWebhookPostName } from '#consts';
+import { setMetadata } from './metadata.js';
 import { FatalError, ValidationError } from '../errors.js';
 
 const temporalActivityConfigs = {
@@ -17,53 +15,35 @@ const temporalActivityConfigs = {
   }
 };
 
-export function workflow( { name, description: _description, fn } ) {
+export function workflow( { name, description, inputSchema, outputSchema, fn } ) {
   const workflowPath = getInvocationDir();
 
-  // This wraps the actually function call so before being invoked it creates the activity proxies and export the context
+  const steps = proxyActivities( temporalActivityConfigs );
+
   const wrapper = async input => {
-    try {
-      const { workflowId } = workflowInfo();
+    // this returns a plain function, for example, in unit tests
+    if ( !inWorkflowContext() ) { return fn( input ); }
 
-      // enrich context information needed for tracking
-      Object.assign( workflowInfo().memo, { workflowPath } );
+    Object.assign( workflowInfo().memo, { workflowPath } );
 
-      const proxies = proxyActivities( temporalActivityConfigs );
-      const context = {
-        steps: new Proxy( {}, {
-          get( _target, name ) {
-            return proxies[`${workflowPath}#${name}`];
-          }
-        } ),
-        tools: {
-          webhook: createWebhook( workflowId, proxies[sendWebhookPostName] )
-        }
-      };
+    // call the function with custom context
+    return fn.call( {
+      invokeStep: async ( stepName, input ) => steps[`${workflowPath}#${stepName}`]( input ),
 
-      return fn( input, context );
+      startWorkflow: async ( name, input ) => {
+        const { memo, workflowId, workflowType } = workflowInfo();
 
-    } catch ( error ) {
-      // IllegalStateError is thrown when temporal is not running and one try to access workflowInfo()
-      if ( error instanceof IllegalStateError ) {
-        return fn( input, { steps: null, workflowId: null } );
-      }
+        // Checks if current memo has rootWorkflowId, which means current execution is already a child
+        // Then it sets the memory for the child execution passing along who's the original workflow is and its type
+        const workflowMemory = memo.rootWorkflowId ?
+          { parentWorkflowId: workflowId, rootWorkflowType: memo.rootWorkflowType, rootWorkflowId: memo.rootWorkflowId } :
+          { parentWorkflowId: workflowId, rootWorkflowId: workflowId, rootWorkflowType: workflowType };
 
-      throw error;
-    }
+        return executeChild( name, { args: input ? [ input ] : [], memo: workflowMemory } );
+      }
+    }, input );
   };
 
-  setName( wrapper, name );
+  setMetadata( wrapper, { name, description, inputSchema, outputSchema } );
   return wrapper;
 };
-
-export async function startWorkflow( name, { input } = {} ) {
-  const { memo, workflowId, workflowType } = workflowInfo();
-
-  // Checks if current memo has rootWorkflowId, which means current execution is already a child
-  // Then it sets the memory for the child execution passing along who's the original workflow is and its type
-  const workflowMemory = memo.rootWorkflowId ?
-    { parentWorkflowId: workflowId, rootWorkflowType: memo.rootWorkflowType, rootWorkflowId: memo.rootWorkflowId } :
-    { parentWorkflowId: workflowId, rootWorkflowId: workflowId, rootWorkflowType: workflowType };
-
-  return executeChild( name, { args: input ? [ input ] : [], memo: workflowMemory } );
-}

package/src/internal_activities/index.js

@@ -1,17 +1,28 @@
-import { fetch } from 'undici';
 import { api as apiConfig } from '#configs';
+import { FatalError } from '#errors';
 
-export async function sendWebhookPost( { url, workflowId, payload } ) {
-  const res = await fetch( url, {
+export const sendWebhookPost = async ( { url, workflowId, payload } ) => {
+  const request = fetch( url, {
     method: 'POST',
     headers: {
       'Content-Type': 'application/json',
       Authentication: `Basic ${apiConfig.authKey}`
     },
-    body: JSON.stringify( { workflowId, payload } )
+    body: JSON.stringify( { workflowId, payload } ),
+    signal: AbortSignal.timeout( 5000 )
   } );
 
+  const res = await ( async () => {
+    try {
+      return await request;
+    } catch {
+      throw new FatalError( 'Webhook fail: timeout' );
+    }
+  } )();
+
   console.log( '[Core.SendWebhookPost]', res.status, res.statusText );
 
-  return { error: !res.ok };
+  if ( !res.ok ) {
+    throw new FatalError( `Webhook fail: ${res.status}` );
+  }
 };

package/src/worker/catalog_workflow/catalog.js

@@ -0,0 +1,105 @@
+/**
+ * Represents the collection of metadata from workflows and activities that a worker has.
+ */
+export class Catalog {
+  /**
+   * All workflows in the catalog
+   * @type {Array<CatalogWorkflow>}
+   */
+  workflows;
+
+  constructor() {
+    this.workflows = [];
+  };
+
+  /**
+   * Add a workflow entry to the catalog.
+   *
+   * @param {CatalogWorkflow} workflow - Workflow to add.
+   * @returns {Catalog} This catalog instance (for chaining).
+   */
+  addWorkflow( workflow ) {
+    this.workflows.push( workflow );
+    return this;
+  }
+}
+
+/**
+ * Base type for catalog entries (workflows, activities).
+ *
+ * Encapsulates common descriptive fields and JSON schemas.
+ */
+class CatalogEntry {
+  /**
+   * Name of the entry. Only letters, numbers and _ allowed.
+   * @type {string}
+   */
+  name;
+  /**
+   * Optional description.
+   * @type {string|undefined}
+   */
+  description;
+  /**
+   * JSON schema describing the expected input.
+   * @type {object}
+   */
+  inputSchema;
+  /**
+   * JSON schema describing the produced output.
+   * @type {object}
+   */
+  outputSchema;
+  /**
+   * Absolute path of the entity in the file system.
+   * @type {string}
+   */
+  path;
+
+  /**
+   * @param {Object} params - Entry parameters.
+   * @param {string} params.name - Name of the entry.
+   * @param {string} [params.description] - Optional description.
+   * @param {object} [params.inputSchema] - JSON schema describing the expected input.
+   * @param {object} [params.outputSchema] - JSON schema describing the produced output.
+   * @param {string} params.path - Absolute path of the entity in the file system.
+   */
+  constructor( { name, description, inputSchema, outputSchema, path } ) {
+    this.name = name;
+    this.description = description;
+    this.inputSchema = inputSchema;
+    this.outputSchema = outputSchema;
+    this.path = path;
+  };
+}
+
+/**
+ * Describes a single workflow within the catalog.
+ *
+ * @class
+ * @extends CatalogEntry
+ */
+export class CatalogWorkflow extends CatalogEntry {
+  /**
+   * Each activity of this workflow.
+   * @type {Array<CatalogActivity>}
+   */
+  activities;
+
+  /**
+   * @inheritdoc
+   * @param {Array<CatalogActivity>} params.activities - Activities referenced by this workflow.
+   */
+  constructor( { activities, ...args } ) {
+    super( args );
+    this.activities = activities;
+  };
+};
+
+/**
+ * Describes a single activity within a workflow.
+ *
+ * @class
+ * @extends CatalogEntry
+ */
+export class CatalogActivity extends CatalogEntry {}