@pikku/core 0.12.7 → 0.12.9

package/src/wirings/workflow/pikku-workflow-service.ts

@@ -26,6 +26,7 @@ import {
 import type { WorkflowService } from '../../services/workflow-service.js'
 import { PikkuError, addError } from '../../errors/error-handler.js'
 import { RPCNotFoundError } from '../rpc/rpc-runner.js'
+import { ChildWorkflowStartedException } from './graph/graph-runner.js'
 
 /**
  * Exception thrown when workflow needs to pause for async step
@@ -111,6 +112,10 @@ const WORKFLOW_END_STATES: ReadonlySet<string> = new Set([
 export abstract class PikkuWorkflowService implements WorkflowService {
   private inlineRuns = new Set<string>()
 
+  protected get logger() {
+    return getSingletonServices()?.logger
+  }
+
   constructor() {}
 
   /**
@@ -386,12 +391,17 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     data: any
   ): Promise<void> {
     const queueService = this.verifyQueueService()
-    await queueService.add(this.getConfig().stepWorkerQueueName, {
-      runId,
-      stepName,
-      rpcName,
-      data,
-    })
+    await queueService.add(
+      this.getConfig().stepWorkerQueueName,
+      JSON.parse(
+        JSON.stringify({
+          runId,
+          stepName,
+          rpcName,
+          data,
+        })
+      )
+    )
   }
 
   /**
@@ -447,7 +457,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
     if (workflowMeta.source === 'graph' || workflowMeta.source === 'ai-agent') {
       const shouldInline =
-        options?.inline || !getSingletonServices()?.queueService
+        options?.inline ||
+        workflowMeta.inline ||
+        !getSingletonServices()?.queueService
       return runWorkflowGraph(
         this,
         name,
@@ -472,7 +484,9 @@ export abstract class PikkuWorkflowService implements WorkflowService {
     }
 
     const shouldInline =
-      options?.inline || !getSingletonServices()?.queueService
+      options?.inline ||
+      workflowMeta.inline ||
+      !getSingletonServices()?.queueService
 
     const runId = await this.createRun(
       name,
@@ -484,16 +498,22 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
     if (shouldInline) {
       this.inlineRuns.add(runId)
-      this.runWorkflowJob(runId, rpcService)
-        .catch((err) => {
+      try {
+        await this.runWorkflowJob(runId, rpcService)
+      } catch (error: any) {
+        if (
+          error.name !== 'WorkflowAsyncException' &&
+          error.name !== 'WorkflowCancelledException' &&
+          error.name !== 'WorkflowSuspendedException'
+        ) {
           getSingletonServices()!.logger.error(
             `Workflow ${name} (run ${runId}) failed:`,
-            err
+            error
           )
-        })
-        .finally(() => {
-          this.inlineRuns.delete(runId)
-        })
+        }
+      } finally {
+        this.inlineRuns.delete(runId)
+      }
     } else {
       await this.resumeWorkflow(runId)
     }
@@ -553,6 +573,18 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
     if (workflowMeta?.source === 'graph') {
       await continueGraph(this, runId, run.workflow)
+      const updatedRun = await this.getRun(runId)
+      if (updatedRun?.status === 'completed') {
+        await this.onChildWorkflowCompleted(updatedRun, updatedRun.output)
+      } else if (
+        updatedRun?.status === 'failed' ||
+        updatedRun?.status === 'cancelled'
+      ) {
+        await this.onChildWorkflowFailed(
+          updatedRun,
+          new Error(updatedRun.error?.message || 'Child workflow failed')
+        )
+      }
       return
     }
 
@@ -587,6 +619,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         )
 
         await this.updateRunStatus(runId, 'completed', result)
+        await this.onChildWorkflowCompleted(run, result)
       } catch (error: any) {
         if (error instanceof WorkflowAsyncException) {
           throw error
@@ -598,6 +631,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
             stack: '',
             code: 'WORKFLOW_CANCELLED',
           })
+          await this.onChildWorkflowFailed(run, error)
           throw error
         }
 
@@ -615,12 +649,41 @@ export abstract class PikkuWorkflowService implements WorkflowService {
           stack: error.stack,
           code: error.code,
         })
+        await this.onChildWorkflowFailed(run, error)
 
         throw error
       }
     })
   }
 
+  private async onChildWorkflowCompleted(
+    childRun: WorkflowRun,
+    result: any
+  ): Promise<void> {
+    const { parentRunId, parentStepId } = childRun.wire ?? {}
+    if (!parentRunId || !parentStepId) return
+
+    this.logger?.debug(
+      `Child workflow ${childRun.id} completed, updating parent step ${parentStepId}`
+    )
+    await this.setStepResult(parentStepId, result)
+    await this.resumeWorkflow(parentRunId)
+  }
+
+  private async onChildWorkflowFailed(
+    childRun: WorkflowRun,
+    error: Error
+  ): Promise<void> {
+    const { parentRunId, parentStepId } = childRun.wire ?? {}
+    if (!parentRunId || !parentStepId) return
+
+    this.logger?.debug(
+      `Child workflow ${childRun.id} failed, updating parent step ${parentStepId}`
+    )
+    await this.setStepError(parentStepId, error)
+    await this.resumeWorkflow(parentRunId)
+  }
+
   private async runVersionMismatchFallback(
     run: WorkflowRun,
     currentMeta: { source: string },
@@ -666,9 +729,8 @@ export abstract class PikkuWorkflowService implements WorkflowService {
       // Get step state
       let stepState = await this.getStepState(runId, stepName)
 
-      // Idempotency - if already succeeded, resume orchestrator and return
+      // Idempotency - if already succeeded, nothing to do
       if (stepState.status === 'succeeded') {
-        await this.resumeWorkflow(runId)
         return
       }
 
@@ -682,8 +744,7 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         stepState = await this.createRetryAttempt(stepState.stepId, 'running')
       }
 
-      if (stepState.status === 'pending') {
-        // Mark pending step as running before execution
+      if (stepState.status === 'pending' || stepState.status === 'scheduled') {
         await this.setStepRunning(stepState.stepId)
       }
 
@@ -725,6 +786,13 @@ export abstract class PikkuWorkflowService implements WorkflowService {
         // Resume orchestrator to continue workflow
         await this.resumeWorkflow(runId)
       } catch (error: any) {
+        if (error instanceof ChildWorkflowStartedException) {
+          this.logger?.debug(
+            `Workflow step '${stepName}': child workflow ${error.childRunId} started, waiting for completion`
+          )
+          return
+        }
+
         if (error instanceof RPCNotFoundError) {
           await this.setStepError(stepState.stepId, error)
           await this.updateRunStatus(runId, 'suspended', undefined, {
@@ -848,12 +916,14 @@ export abstract class PikkuWorkflowService implements WorkflowService {
 
       await getSingletonServices()!.queueService!.add(
         this.getConfig().stepWorkerQueueName,
-        {
-          runId,
-          stepName,
-          rpcName,
-          data,
-        },
+        JSON.parse(
+          JSON.stringify({
+            runId,
+            stepName,
+            rpcName,
+            data,
+          })
+        ),
         {
           // attempts includes initial attempt, retries doesn't
           attempts: retries + 1,

package/src/wirings/workflow/workflow.types.ts

@@ -40,6 +40,7 @@ export interface WorkflowRunWire {
   type: string
   id?: string
   parentRunId?: string
+  parentStepId?: string
 }
 
 export interface WorkflowServiceConfig {
@@ -224,6 +225,7 @@ export type WorkflowsMeta = Record<
     steps: WorkflowStepMeta[]
     context?: WorkflowContext
     dsl?: boolean
+    inline?: boolean
   }
 >
 
@@ -243,6 +245,8 @@ export interface WorkflowRuntimeMeta {
   description?: string
   /** Tags for organization */
   tags?: string[]
+  /** If true, workflow always executes inline without queues */
+  inline?: boolean
   /** Serialized nodes */
   nodes?: Record<string, any>
   /** Entry node IDs for graph workflows (computed at build time) */