ai-workflows 2.1.3 → 2.4.0

package/src/barrier.ts

@@ -113,16 +113,18 @@ export class Barrier<T = unknown> {
   private _timeoutId: ReturnType<typeof setTimeout> | null = null
   private _cancelled = false
   private _cancelError: Error | null = null
+  private _abortHandler: (() => void) | null = null
 
   constructor(expectedCount: number, options: BarrierOptions<T> = {}) {
     this._expected = expectedCount
     this._options = options
 
-    // Set up abort signal listener
+    // Set up abort signal listener with proper cleanup tracking
     if (options.signal) {
-      options.signal.addEventListener('abort', () => {
+      this._abortHandler = () => {
         this.cancel(new Error('Operation aborted'))
-      })
+      }
+      options.signal.addEventListener('abort', this._abortHandler, { once: true })
     }
   }
 
@@ -210,6 +212,7 @@ export class Barrier<T = unknown> {
    */
   reset(): void {
     this._clearTimeout()
+    this._clearAbortHandler()
     this._arrived = []
     this._waitResolve = null
     this._waitReject = null
@@ -224,6 +227,7 @@ export class Barrier<T = unknown> {
     this._cancelled = true
     this._cancelError = error
     this._clearTimeout()
+    this._clearAbortHandler()
 
     if (this._waitReject) {
       this._waitReject(error)
@@ -232,15 +236,26 @@ export class Barrier<T = unknown> {
     }
   }
 
+  /**
+   * Dispose of the barrier and cleanup all resources
+   */
+  dispose(): void {
+    this._clearTimeout()
+    this._clearAbortHandler()
+    this._waitResolve = null
+    this._waitReject = null
+  }
+
   /**
    * Get current progress information
    */
   getProgress(): BarrierProgress<T> {
+    const latestValue = this._arrived[this._arrived.length - 1]
     return {
       arrived: this._arrived.length,
       expected: this._expected,
       percentage: Math.round((this._arrived.length / this._expected) * 100),
-      latest: this._arrived[this._arrived.length - 1],
+      ...(latestValue !== undefined && { latest: latestValue }),
     }
   }
 
@@ -250,6 +265,13 @@ export class Barrier<T = unknown> {
       this._timeoutId = null
     }
   }
+
+  private _clearAbortHandler(): void {
+    if (this._abortHandler && this._options.signal) {
+      this._options.signal.removeEventListener('abort', this._abortHandler)
+      this._abortHandler = null
+    }
+  }
 }
 
 /**
@@ -277,13 +299,28 @@ export async function waitForAll<T>(
 
   const { timeout, signal } = options
 
+  // Track cleanup handlers
+  let abortHandler: (() => void) | null = null
+  let timeoutId: ReturnType<typeof setTimeout> | null = null
+
+  const cleanup = () => {
+    if (abortHandler && signal) {
+      signal.removeEventListener('abort', abortHandler)
+      abortHandler = null
+    }
+    if (timeoutId) {
+      clearTimeout(timeoutId)
+      timeoutId = null
+    }
+  }
+
   // Build array of promises to race against
   const racers: Promise<T[]>[] = [Promise.all(promises)]
 
   // Add abort signal handling
   if (signal) {
     const abortPromise = new Promise<never>((_, reject) => {
-      const abortHandler = () => {
+      abortHandler = () => {
         reject(new Error('Operation aborted'))
       }
       if (signal.aborted) {
@@ -298,14 +335,18 @@ export async function waitForAll<T>(
   // Add timeout if specified
   if (timeout) {
     const timeoutPromise = new Promise<never>((_, reject) => {
-      setTimeout(() => {
+      timeoutId = setTimeout(() => {
         reject(new BarrierTimeoutError(timeout, 0, promises.length))
       }, timeout)
     })
     racers.push(timeoutPromise)
   }
 
-  return await Promise.race(racers)
+  try {
+    return await Promise.race(racers)
+  } finally {
+    cleanup()
+  }
 }
 
 /**

package/src/cascade-context.ts

@@ -197,7 +197,10 @@ function correlationIdToTraceId(correlationId: string): string {
  */
 function traceIdToCorrelationId(traceId: string): string {
   // Convert 32 hex chars to UUID format
-  return `${traceId.slice(0, 8)}-${traceId.slice(8, 12)}-${traceId.slice(12, 16)}-${traceId.slice(16, 20)}-${traceId.slice(20, 32)}`
+  return `${traceId.slice(0, 8)}-${traceId.slice(8, 12)}-${traceId.slice(12, 16)}-${traceId.slice(
+    16,
+    20
+  )}-${traceId.slice(20, 32)}`
 }
 
 /**
@@ -208,13 +211,15 @@ export function createCascadeContext(options: CascadeContextOptions = {}): Casca
 
   // Handle restoration from serialized format
   if (fromSerialized) {
-    const restoredSteps: CascadeStep[] = fromSerialized.steps.map((s) => createRestoredStep(s, name))
+    const restoredSteps: CascadeStep[] = fromSerialized.steps.map((s) =>
+      createRestoredStep(s, name)
+    )
 
     const ctx: CascadeContext = {
       correlationId: fromSerialized.correlationId,
       spanId: fromSerialized.spanId,
-      parentId: fromSerialized.parentId,
-      name: fromSerialized.name,
+      ...(fromSerialized.parentId !== undefined && { parentId: fromSerialized.parentId }),
+      ...(fromSerialized.name !== undefined && { name: fromSerialized.name }),
       depth: fromSerialized.depth,
       steps: restoredSteps,
       path: fromSerialized.path,
@@ -241,7 +246,7 @@ export function createCascadeContext(options: CascadeContextOptions = {}): Casca
         correlationId,
         spanId: newSpanId,
         parentId: parsed.parentId,
-        name,
+        ...(name !== undefined && { name }),
         depth: 0,
         steps: [],
         path: [],
@@ -279,13 +284,13 @@ export function createCascadeContext(options: CascadeContextOptions = {}): Casca
   const ctx: CascadeContext = {
     correlationId,
     spanId,
-    parentId,
-    name,
+    ...(parentId !== undefined && { parentId }),
+    ...(name !== undefined && { name }),
     depth,
     steps,
     path,
     createdAt,
-    parent,
+    ...(parent !== undefined && { parent }),
     get fullPath() {
       if (this.parent) {
         return [...this.parent.fullPath, ...this.path]
@@ -308,10 +313,10 @@ function createRestoredStep(serialized: SerializedCascadeStep, contextName?: str
   const step: CascadeStep = {
     name: serialized.name,
     startedAt: serialized.startedAt,
-    completedAt: serialized.completedAt,
-    duration: serialized.duration,
+    ...(serialized.completedAt !== undefined && { completedAt: serialized.completedAt }),
+    ...(serialized.duration !== undefined && { duration: serialized.duration }),
     status: serialized.status,
-    metadata: serialized.metadata ? { ...serialized.metadata } : undefined,
+    ...(serialized.metadata !== undefined && { metadata: { ...serialized.metadata } }),
     complete: () => {
       step.status = 'completed'
       step.completedAt = Date.now()
@@ -327,15 +332,15 @@ function createRestoredStep(serialized: SerializedCascadeStep, contextName?: str
       step.metadata = { ...step.metadata, ...data }
     },
     to5WHEvent: () => ({
-      who: (step.metadata?.actor as string) || 'system',
-      what: (step.metadata?.action as string) || step.name,
+      who: (step.metadata?.['actor'] as string) || 'system',
+      what: (step.metadata?.['action'] as string) || step.name,
       when: step.startedAt,
       where: contextName || 'unknown',
-      why: step.metadata?.reason as string,
+      ...(step.metadata?.['reason'] !== undefined && { why: step.metadata['reason'] as string }),
       how: {
-        duration: step.duration,
+        ...(step.duration !== undefined && { duration: step.duration }),
         status: step.status,
-        metadata: step.metadata,
+        ...(step.metadata !== undefined && { metadata: step.metadata }),
       },
     }),
   }
@@ -356,7 +361,7 @@ export function recordStep(
     name,
     startedAt,
     status: 'running',
-    metadata: metadata ? { ...metadata } : undefined,
+    ...(metadata !== undefined && { metadata: { ...metadata } }),
     complete: () => {
       step.status = 'completed'
       step.completedAt = Date.now()
@@ -373,15 +378,15 @@ export function recordStep(
       step.metadata = { ...step.metadata, ...data }
     },
     to5WHEvent: () => ({
-      who: (step.metadata?.actor as string) || 'system',
-      what: (step.metadata?.action as string) || name,
+      who: (step.metadata?.['actor'] as string) || 'system',
+      what: (step.metadata?.['action'] as string) || name,
       when: startedAt,
       where: ctx.name || 'cascade',
-      why: step.metadata?.reason as string,
+      ...(step.metadata?.['reason'] !== undefined && { why: step.metadata['reason'] as string }),
       how: {
-        duration: step.duration,
+        ...(step.duration !== undefined && { duration: step.duration }),
         status: step.status,
-        metadata: step.metadata,
+        ...(step.metadata !== undefined && { metadata: step.metadata }),
       },
     }),
   }
@@ -408,16 +413,16 @@ function serializeContext(ctx: CascadeContext): SerializedCascadeContext {
   return {
     correlationId: ctx.correlationId,
     spanId: ctx.spanId,
-    parentId: ctx.parentId,
-    name: ctx.name,
+    ...(ctx.parentId !== undefined && { parentId: ctx.parentId }),
+    ...(ctx.name !== undefined && { name: ctx.name }),
     depth: ctx.depth,
     steps: ctx.steps.map((step) => ({
       name: step.name,
       startedAt: step.startedAt,
-      completedAt: step.completedAt,
-      duration: step.duration,
+      ...(step.completedAt !== undefined && { completedAt: step.completedAt }),
+      ...(step.duration !== undefined && { duration: step.duration }),
       status: step.status,
-      metadata: step.metadata,
+      ...(step.metadata !== undefined && { metadata: step.metadata }),
     })),
     path: ctx.path,
     createdAt: ctx.createdAt,
@@ -438,7 +443,8 @@ function formatContext(ctx: CascadeContext): string {
   lines.push(`  Depth: ${ctx.depth}`)
   lines.push(`  Steps:`)
   for (const step of ctx.steps) {
-    const status = step.status === 'completed' ? '[OK]' : step.status === 'failed' ? '[FAIL]' : '[...]'
+    const status =
+      step.status === 'completed' ? '[OK]' : step.status === 'failed' ? '[FAIL]' : '[...]'
     const duration = step.duration ? ` (${step.duration}ms)` : ''
     lines.push(`    ${status} ${step.name}${duration}`)
   }
@@ -464,7 +470,8 @@ function formatContextTree(ctx: CascadeContext): string {
     const indent = '  '.repeat(i)
     lines.push(`${indent}${context.name || 'cascade'} (depth: ${context.depth})`)
     for (const step of context.steps) {
-      const status = step.status === 'completed' ? '[OK]' : step.status === 'failed' ? '[FAIL]' : '[...]'
+      const status =
+        step.status === 'completed' ? '[OK]' : step.status === 'failed' ? '[FAIL]' : '[...]'
       const duration = step.duration ? ` (${step.duration}ms)` : ''
       lines.push(`${indent}  ${status} ${step.name}${duration}`)
     }

package/src/cascade-executor.ts

@@ -445,7 +445,8 @@ export class CascadeExecutor<T = unknown> {
         attempts++
 
         // Check if it's a timeout error
-        const isTimeout = lastError.message.includes('timed out') || lastError.name === 'TimeoutError'
+        const isTimeout =
+          lastError.message.includes('timed out') || lastError.name === 'TimeoutError'
 
         // If we've exhausted retries or it's a total timeout, stop
         if (attempts > maxRetries || lastError instanceof CascadeTimeoutError) {
@@ -506,7 +507,7 @@ export class CascadeExecutor<T = unknown> {
     return {
       tier,
       success: false,
-      error: lastError,
+      ...(lastError !== undefined && { error: lastError }),
       duration,
     }
   }

package/src/context.ts

@@ -2,7 +2,16 @@
  * Workflow context implementation
  */
 
-import type { WorkflowContext, WorkflowState, WorkflowHistoryEntry, OnProxy, EveryProxy, EveryProxyTarget, ScheduleHandler } from './types.js'
+import type {
+  WorkflowContext,
+  WorkflowState,
+  WorkflowHistoryEntry,
+  OnProxy,
+  EveryProxy,
+  EveryProxyTarget,
+  ScheduleHandler,
+} from './types.js'
+import { getLogger } from './logger.js'
 
 /**
  * Event bus interface (imported from send.ts to avoid circular dependency)
@@ -30,12 +39,15 @@ export function createWorkflowContext(eventBus: EventBusLike): WorkflowContext {
   // Create no-op proxies for on/every (these are used in send context, not workflow setup)
   const noOpOnProxy = new Proxy({} as OnProxy, {
     get() {
-      return new Proxy({}, {
-        get() {
-          return () => {}
+      return new Proxy(
+        {},
+        {
+          get() {
+            return () => {}
+          },
         }
-      })
-    }
+      )
+    },
   })
 
   // Cast to EveryProxy is safe: Proxy handler implements all EveryProxy behaviors dynamically
@@ -46,14 +58,29 @@ export function createWorkflowContext(eventBus: EventBusLike): WorkflowContext {
       get() {
         return () => () => {}
       },
-      apply() {}
+      apply() {},
     }
   ) as EveryProxy
 
   return {
-    async send<T = unknown>(event: string, data: T): Promise<void> {
+    track(event: string, data: unknown): void {
+      // Fire and forget - swallow errors
+      try {
+        addHistory({ type: 'event', name: `track:${event}`, data })
+        eventBus.emit(event, data).catch(() => {})
+      } catch {
+        // Silently swallow errors
+      }
+    },
+
+    send<T = unknown>(event: string, data: T): string {
+      const eventId = crypto.randomUUID()
       addHistory({ type: 'event', name: event, data })
-      await eventBus.emit(event, data)
+      // Fire async but don't await - guaranteed delivery via event bus
+      eventBus.emit(event, { ...(data as object), _eventId: eventId }).catch((err) => {
+        getLogger().error(`[workflow] Failed to send event ${event}:`, err)
+      })
+      return eventId
     },
 
     async do<TData = unknown, TResult = unknown>(_event: string, _data: TData): Promise<TResult> {
@@ -72,7 +99,7 @@ export function createWorkflowContext(eventBus: EventBusLike): WorkflowContext {
     getState(): WorkflowState {
       // Return a deep copy to prevent mutation
       return {
-        current: workflowState.current,
+        ...(workflowState.current !== undefined && { current: workflowState.current }),
         context: { ...workflowState.context },
         history: [...workflowState.history],
       }
@@ -88,7 +115,7 @@ export function createWorkflowContext(eventBus: EventBusLike): WorkflowContext {
 
     log(message: string, data?: unknown): void {
       addHistory({ type: 'action', name: 'log', data: { message, data } })
-      console.log(`[workflow] ${message}`, data ?? '')
+      getLogger().log(`[workflow] ${message}`, data ?? '')
     },
   }
 }
@@ -97,7 +124,9 @@ export function createWorkflowContext(eventBus: EventBusLike): WorkflowContext {
  * Create an isolated workflow context (not connected to event bus)
  * Useful for testing or standalone execution
  */
-export function createIsolatedContext(): WorkflowContext & { getEmittedEvents: () => Array<{ event: string; data: unknown }> } {
+export function createIsolatedContext(): WorkflowContext & {
+  getEmittedEvents: () => Array<{ event: string; data: unknown }>
+} {
   const emittedEvents: Array<{ event: string; data: unknown }> = []
 
   const ctx = createWorkflowContext({