@output.ai/core 0.4.6 → 0.4.8

package/package.json

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

package/src/consts.js

@@ -10,3 +10,13 @@ export const ComponentType = {
   INTERNAL_STEP: 'internal_step',
   STEP: 'step'
 };
+export const LifecycleEvent = {
+  START: 'start',
+  END: 'end',
+  ERROR: 'error'
+};
+export const LifecycleEventLogMessage = {
+  [LifecycleEvent.START]: 'Start',
+  [LifecycleEvent.END]: 'End',
+  [LifecycleEvent.ERROR]: 'Error'
+};

package/src/index.js

@@ -17,7 +17,7 @@ export {
   EvaluationStringResult,
   EvaluationBooleanResult,
   EvaluationFeedback,
-  // webhook tools
+  // tools
   executeInParallel,
   sendHttpRequest,
   sendPostRequestAndAwaitWebhook,

package/src/interface/workflow.js

@@ -3,7 +3,7 @@ import { proxyActivities, inWorkflowContext, executeChild, workflowInfo, uuid4,
 import { validateWorkflow } from './validations/static.js';
 import { validateWithSchema } from './validations/runtime.js';
 import { SHARED_STEP_PREFIX, ACTIVITY_GET_TRACE_DESTINATIONS, METADATA_ACCESS_SYMBOL } from '#consts';
-import { deepMerge, mergeActivityOptions, setMetadata } from '#utils';
+import { deepMerge, mergeActivityOptions, setMetadata, toUrlSafeBase64 } from '#utils';
 import { FatalError, ValidationError } from '#errors';
 
 /**
@@ -121,7 +121,7 @@ export function workflow( { name, description, inputSchema, outputSchema, fn, op
         startWorkflow: async ( childName, input, extra = {} ) =>
           executeChild( childName, {
             args: input ? [ input ] : [],
-            workflowId: `${workflowId}-${childName}-${uuid4()}`,
+            workflowId: `${workflowId}-${toUrlSafeBase64( uuid4() )}`,
             parentClosePolicy: ParentClosePolicy[extra?.detached ? 'ABANDON' : 'TERMINATE'],
             memo: {
               executionContext,

package/src/internal_activities/index.spec.js

@@ -4,15 +4,18 @@ import { FatalError } from '#errors';
 import { serializeBodyAndInferContentType, serializeFetchResponse } from '#utils';
 import { sendHttpRequest } from './index.js';
 
-vi.mock( '#utils', () => {
-  return {
-    setMetadata: vi.fn(),
-    isStringboolTrue: vi.fn( () => false ),
-    serializeBodyAndInferContentType: vi.fn(),
-    serializeFetchResponse: vi.fn()
-  };
+vi.mock( '#logger', () => {
+  const log = { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() };
+  return { createChildLogger: vi.fn( () => log ) };
 } );
 
+vi.mock( '#utils', () => ( {
+  setMetadata: vi.fn(),
+  isStringboolTrue: vi.fn( () => false ),
+  serializeBodyAndInferContentType: vi.fn(),
+  serializeFetchResponse: vi.fn()
+} ) );
+
 const mockAgent = new MockAgent();
 mockAgent.disableNetConnect();
 

package/src/logger.js

@@ -1,4 +1,5 @@
 import winston from 'winston';
+import { shuffleArray } from '#utils';
 
 const isProduction = process.env.NODE_ENV === 'production';
 
@@ -10,6 +11,16 @@ const levels = {
   debug: 4
 };
 
+const colors = shuffleArray( [
+  '033', // blue
+  '030', // green
+  '208', // orange
+  '045', // turquoise
+  '129', // purple
+  '184' // yellow
+] );
+const assignedColors = new Map();
+
 // Format metadata as friendly JSON: "{ name: "foo", count: 5 }"
 const formatMeta = obj => {
   const entries = Object.entries( obj );
@@ -18,14 +29,20 @@ const formatMeta = obj => {
   }
   return ' { ' + entries.map( ( [ k, v ] ) => `${k}: ${JSON.stringify( v )}` ).join( ', ' ) + ' }';
 };
+// Distribute the namespace in a map and assign it the next available color
+const getColor = v =>
+  assignedColors.has( v ) ? assignedColors.get( v ) : assignedColors.set( v, colors[assignedColors.size % colors.length] ).get( v );
+
+// Colorize a text using the namespace string
+const colorizeByNamespace = ( namespace, text ) => `\x1b[38;5;${getColor( namespace )}m${text}\x1b[0m`;
 
 // Development format: colorized with namespace prefix
 const devFormat = winston.format.combine(
   winston.format.colorize(),
   winston.format.printf( ( { level, message, namespace, service: _, environment: __, ...rest } ) => {
-    const ns = namespace ? `{Core.${namespace}}` : '{Core}';
+    const ns = 'Core' + ( namespace ? `.${namespace}` : '' );
     const meta = formatMeta( rest );
-    return `[${level}] ${ns} ${message}${meta}`;
+    return `[${level}] ${colorizeByNamespace( ns, `${namespace}: ${message}` )}${meta}`;
   } )
 );
 

package/src/utils/index.d.ts

@@ -96,6 +96,14 @@ export function serializeBodyAndInferContentType( body: unknown ): SerializedBod
  */
 export function isPlainObject( object: unknown ): boolean;
 
+/**
+ * Returns a copy of an array with its content shuffled.
+ *
+ * @param arr - The array to shuffle
+ * @returns A shuffled array copy
+ */
+export function shuffleArray( arr: array ): array;
+
 /**
  * Creates a new object by merging object `b` onto object `a`, biased toward `b`:
  * - Fields in `b` overwrite fields in `a`.
@@ -108,3 +116,12 @@ export function isPlainObject( object: unknown ): boolean;
  * @returns A new merged object.
  */
 export function deepMerge( a: object, b: object ): object;
+
+/**
+ * Shortens a UUID to a url-safe base64-like string (custom 64-char alphabet).
+ * Temporal-friendly: no Buffer or crypto; safe to use inside workflows.
+ *
+ * @param uuid - Standard UUID (e.g. `xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx`).
+ * @returns Short string using A–Z, a–z, 0–9, `_`, `-` (typically 21–22 chars).
+ */
+export function toUrlSafeBase64( uuid: string ): string;

package/src/utils/utils.js

@@ -162,6 +162,17 @@ export const serializeBodyAndInferContentType = payload => {
   return { body: String( payload ), contentType: 'text/plain; charset=UTF-8' };
 };
 
+/**
+ * Receives an array and returns a copy of it with the elements shuffled
+ *
+ * @param {array} arr
+ * @returns {array}
+ */
+export const shuffleArray = arr => arr
+  .map( v => ( { v, sort: Math.random() } ) )
+  .sort( ( a, b ) => a.sort - b.sort )
+  .map( ( { v } ) => v );
+
 /**
  * Creates a new object merging object "b" onto object "a" biased to "b":
  * - Object "b" will overwrite fields on object "a";
@@ -184,3 +195,20 @@ export const deepMerge = ( a, b ) => {
     Object.assign( obj, { [k]: isPlainObject( v ) && isPlainObject( a[k] ) ? deepMerge( a[k], v ) : v } )
   , clone( a ) );
 };
+
+/**
+ * Shortens a UUID by re-encoding it to base62.
+ *
+ * This is a Temporal friendly, without crypto or Buffer.
+ * @param {string} uuid
+ * @returns {string}
+ */
+export const toUrlSafeBase64 = uuid => {
+  const alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-';
+  const alphabetLen = alphabet.length;
+  const base = BigInt( alphabetLen );
+  const hex = uuid.replace( /-/g, '' );
+
+  const toDigits = n => n <= 0n ? [] : toDigits( n / base ).concat( alphabet[Number( n % base )] );
+  return toDigits( BigInt( '0x' + hex ) ).join( '' );
+};

package/src/utils/utils.spec.js

@@ -1,6 +1,14 @@
 import { describe, it, expect } from 'vitest';
 import { Readable } from 'node:stream';
-import { clone, mergeActivityOptions, serializeBodyAndInferContentType, serializeFetchResponse, deepMerge, isPlainObject } from './utils.js';
+import {
+  clone,
+  mergeActivityOptions,
+  serializeBodyAndInferContentType,
+  serializeFetchResponse,
+  deepMerge,
+  isPlainObject,
+  toUrlSafeBase64
+} from './utils.js';
 
 describe( 'clone', () => {
   it( 'produces a deep copy without shared references', () => {
@@ -411,3 +419,43 @@ describe( 'isPlainObject', () => {
     expect( isPlainObject( zum ) ).toBe( false );
   } );
 } );
+
+describe( 'toUrlSafeBase64', () => {
+  const urlSafeAlphabet = /^[A-Za-z0-9_-]+$/;
+
+  it( 'returns a string for a valid UUID', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000';
+    expect( typeof toUrlSafeBase64( uuid ) ).toBe( 'string' );
+    expect( toUrlSafeBase64( uuid ).length ).toBeGreaterThan( 0 );
+  } );
+
+  it( 'output length is 21 or 22 for a standard UUID', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000';
+    const out = toUrlSafeBase64( uuid );
+    expect( out.length ).toBeGreaterThanOrEqual( 21 );
+    expect( out.length ).toBeLessThanOrEqual( 22 );
+  } );
+
+  it( 'output contains only url-safe alphabet characters', () => {
+    const uuid = '550e8400-e29b-41d4-a716-446655440000';
+    const out = toUrlSafeBase64( uuid );
+    expect( out ).toMatch( urlSafeAlphabet );
+  } );
+
+  it( 'is deterministic for the same UUID', () => {
+    const uuid = '6ba7b810-9dad-11d1-80b4-00c04fd430c8';
+    expect( toUrlSafeBase64( uuid ) ).toBe( toUrlSafeBase64( uuid ) );
+  } );
+
+  it( 'different UUIDs produce different strings', () => {
+    const a = toUrlSafeBase64( '550e8400-e29b-41d4-a716-446655440000' );
+    const b = toUrlSafeBase64( '6ba7b810-9dad-11d1-80b4-00c04fd430c8' );
+    expect( a ).not.toBe( b );
+  } );
+
+  it( 'strips hyphens and encodes hex (same as 32-char hex)', () => {
+    const withHyphens = '550e8400-e29b-41d4-a716-446655440000';
+    const hexOnly = '550e8400e29b41d4a716446655440000';
+    expect( toUrlSafeBase64( withHyphens ) ).toBe( toUrlSafeBase64( hexOnly ) );
+  } );
+} );

package/src/worker/interceptors/activity.js

@@ -2,9 +2,11 @@ import { Context } from '@temporalio/activity';
 import { Storage } from '#async_storage';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { headersToObject } from '../sandboxed_utils.js';
-import { METADATA_ACCESS_SYMBOL } from '#consts';
+import { LifecycleEventLogMessage, LifecycleEvent, METADATA_ACCESS_SYMBOL } from '#consts';
 import { activityHeartbeatEnabled, activityHeartbeatIntervalMs } from '../configs.js';
+import { createChildLogger } from '#logger';
 
+const log = createChildLogger( 'Activity' );
 /*
   This interceptor wraps every activity execution with cross-cutting concerns:
 
@@ -27,11 +29,15 @@ export class ActivityExecutionInterceptor {
   };
 
   async execute( input, next ) {
-    const { workflowExecution: { workflowId }, activityId, activityType } = Context.current().info;
+    const { workflowExecution: { workflowId }, activityId, activityType, workflowType: workflowName } = Context.current().info;
     const { executionContext } = headersToObject( input.headers );
     const { type: kind } = this.activities?.[activityType]?.[METADATA_ACCESS_SYMBOL];
 
+    const startDate = Date.now();
+    const logContext = { workflowName, workflowId, stepId: activityId, stepName: activityType };
     const traceArguments = { kind, id: activityId, parentId: workflowId, name: activityType, executionContext };
+
+    log.info( LifecycleEventLogMessage[LifecycleEvent.START], logContext );
     addEventStart( { details: input.args[0], ...traceArguments } );
 
     const intervals = { heartbeat: null };
@@ -40,10 +46,13 @@ export class ActivityExecutionInterceptor {
       intervals.heartbeat = activityHeartbeatEnabled && setInterval( () => Context.current().heartbeat(), activityHeartbeatIntervalMs );
 
       const output = await Storage.runWithContext( async _ => next( input ), { parentId: activityId, executionContext } );
+
+      log.info( LifecycleEventLogMessage[LifecycleEvent.END], { ...logContext, durationMs: Date.now() - startDate } );
       addEventEnd( { details: output, ...traceArguments } );
       return output;
 
     } catch ( error ) {
+      log.error( LifecycleEventLogMessage[LifecycleEvent.ERROR], { ...logContext, durationMs: Date.now() - startDate, error: error.message } );
       addEventError( { details: error, ...traceArguments } );
       throw error;
 

package/src/worker/interceptors/activity.spec.js

@@ -1,6 +1,6 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-const METADATA_ACCESS_SYMBOL = Symbol( '__metadata' );
+const METADATA_ACCESS_SYMBOL = vi.hoisted( () => Symbol( '__metadata' ) );
 
 const heartbeatMock = vi.fn();
 const contextInfoMock = {
@@ -37,11 +37,14 @@ vi.mock( '../sandboxed_utils.js', () => ( {
   headersToObject: () => ( { executionContext: { workflowId: 'wf-1' } } )
 } ) );
 
-vi.mock( '#consts', () => ( {
-  get METADATA_ACCESS_SYMBOL() {
-    return METADATA_ACCESS_SYMBOL;
-  }
-} ) );
+vi.mock( '#consts', async importOriginal => {
+  const actual = await importOriginal();
+  return {
+    ...actual, get METADATA_ACCESS_SYMBOL() {
+      return METADATA_ACCESS_SYMBOL;
+    }
+  };
+} );
 
 vi.mock( '../configs.js', () => ( {
   get activityHeartbeatEnabled() {

package/src/worker/sinks.js

@@ -1,11 +1,11 @@
-import { WORKFLOW_CATALOG } from '#consts';
+import { LifecycleEvent, LifecycleEventLogMessage, WORKFLOW_CATALOG } from '#consts';
 import { addEventStart, addEventEnd, addEventError } from '#tracing';
 import { createChildLogger } from '#logger';
 
-const log = createChildLogger( 'Worker' );
+const log = createChildLogger( 'Workflow' );
 
 /**
- * Start a workflow trace event
+ * Adds a workflow trace event
  *
  * @param {function} method - Trace function to call
  * @param {object} workflowInfo - Temporal workflowInfo object
@@ -20,44 +20,31 @@ const addWorkflowEvent = ( method, workflowInfo, details ) => {
 };
 
 /**
- * Log workflow start
+ * Logs the internal workflow event
  *
- * @param {object} workflowInfo - Temporal workflowInfo object
- */
-const logWorkflowStart = workflowInfo => {
-  const { workflowId, workflowType: workflowName } = workflowInfo;
-  if ( workflowName === WORKFLOW_CATALOG ) {
-    return;
-  }
-  log.info( 'Workflow started', { workflowName, workflowId } );
-};
-
-/**
- * Log workflow completion with duration
- *
- * @param {object} workflowInfo - Temporal workflowInfo object
+ * @param {LifecycleEvent} event
+ * @param {Object} workflowInfo
+ * @returns {void}
  */
-const logWorkflowEnd = workflowInfo => {
+const logWorkflowEvent = ( event, workflowInfo, error ) => {
   const { workflowId, workflowType: workflowName, startTime } = workflowInfo;
+  // exclude internal catalog
   if ( workflowName === WORKFLOW_CATALOG ) {
     return;
   }
-  const durationMs = Date.now() - startTime.getTime();
-  log.info( 'Workflow completed', { workflowName, workflowId, durationMs } );
-};
 
-/**
- * Log workflow failure with duration
- *
- * @param {object} workflowInfo - Temporal workflowInfo object
- */
-const logWorkflowError = workflowInfo => {
-  const { workflowId, workflowType: workflowName, startTime } = workflowInfo;
-  if ( workflowName === WORKFLOW_CATALOG ) {
-    return;
+  if ( event === LifecycleEvent.START ) {
+    log.info( LifecycleEventLogMessage[event], { workflowName, workflowId } );
+  } else if ( event === LifecycleEvent.END ) {
+    log.info( LifecycleEventLogMessage[event], { workflowName, workflowId, durationMs: Date.now() - startTime.getTime() } );
+  } else if ( event === LifecycleEvent.ERROR ) {
+    log.info( LifecycleEventLogMessage[event], {
+      workflowName,
+      workflowId,
+      durationMs: Date.now() - startTime.getTime(),
+      error: error.message
+    } );
   }
-  const durationMs = Date.now() - startTime.getTime();
-  log.error( 'Workflow failed', { workflowName, workflowId, durationMs } );
 };
 
 /**
@@ -77,25 +64,25 @@ const addEvent = ( method, workflowInfo, options ) => {
 export const sinks = {
   trace: {
     addWorkflowEventStart: {
-      fn: ( workflowInfo, ...rest ) => {
-        logWorkflowStart( workflowInfo );
-        addWorkflowEvent( addEventStart, workflowInfo, ...rest );
+      fn: ( workflowInfo, details ) => {
+        logWorkflowEvent( LifecycleEvent.START, workflowInfo );
+        addWorkflowEvent( addEventStart, workflowInfo, details );
       },
       callDuringReplay: false
     },
 
     addWorkflowEventEnd: {
-      fn: ( workflowInfo, ...rest ) => {
-        logWorkflowEnd( workflowInfo );
-        addWorkflowEvent( addEventEnd, workflowInfo, ...rest );
+      fn: ( workflowInfo, details ) => {
+        logWorkflowEvent( LifecycleEvent.END, workflowInfo );
+        addWorkflowEvent( addEventEnd, workflowInfo, details );
       },
       callDuringReplay: false
     },
 
     addWorkflowEventError: {
-      fn: ( workflowInfo, ...rest ) => {
-        logWorkflowError( workflowInfo );
-        addWorkflowEvent( addEventError, workflowInfo, ...rest );
+      fn: ( workflowInfo, details ) => {
+        logWorkflowEvent( LifecycleEvent.ERROR, workflowInfo, details );
+        addWorkflowEvent( addEventError, workflowInfo, details );
       },
       callDuringReplay: false
     },

package/src/logger.d.ts

@@ -1,4 +0,0 @@
-import type { Logger } from 'winston';
-
-export declare const logger: Logger;
-export declare function createChildLogger( namespace: string ): Logger;